Blackbird is a Swift library that provides a lightweight, asynchronous SQLite wrapper and model layer, using Swift concurrency and Codable, with no other dependencies. It allows developers to define database models as Swift structs with @BlackbirdColumn annotations, and automatically handles table creation, schema migrations, caching, change notifications, and full-text search. The library is designed for reactive SwiftUI applications, offering live-updating model observers and query publishers. It uses a key-path-driven query DSL for type-safe database operations. The architecture centers on the Blackbird.Database class, which manages SQLite connections, transactions, and a per-table cache. External dependencies are limited to Apple frameworks (SQLite3, Combine, SwiftUI, OSLog, Observation, Foundation, Dispatch). The library is in beta but used in production by the author, with a focus on speed of development over raw execution speed.
The JPImageresizerView repository is an iOS library for cropping images, GIFs, and videos. It provides a customizable cropping interface (JPImageresizerView) with support for rotation, mirroring, masks, borders, rounded corners, and various visual effects. The library is designed for flexibility through a fluent configuration pattern (JPImageresizerConfigure) and delegates processing to a core utility class (JPImageresizerTool) that handles asynchronous media transformations and caching. The architecture separates concerns into configuration, UI components, and processing logic. Key reusable components include the configuration builder, the interactive crop frame view (JPImageresizerFrameView), and the media processing tool. The library supports output formats such as JPEG, PNG, GIF, and video, and integrates with AVFoundation and the Photos framework for media handling. While the library is feature-rich and demonstrates solid engineering practices, it shows signs of technical drift due to the use of deprecated Objective-C APIs, manual memory management, and reliance on third-party libraries like Masonry and POP. Despite this, it remains maintained with regular updates and is compatible with iOS 11.0 and above.
d3-flame-graph is a D3.js library that renders interactive flame graphs from hierarchical profiling data. It follows the D3 closure-based chart pattern, providing a factory function `flamegraph()` that returns a chart function with getter/setter methods for configuration (width, height, colors, tooltips, transitions, etc.). The library processes JSON input with name/value/children structure, uses d3-hierarchy for partition layout, and generates an SVG with clickable, searchable, zoomable frames. It supports multiple color schemes (warm, cold, blue, red, etc.), custom color mappers, differential analysis, self-value mode, inverted (icicle) layout, and live data merging. The tooltip system is pluggable with a default implementation that handles smart positioning and HTML/text content. The codebase is well-structured with separate modules for color mapping, color scheme calculation, color hashing, and tooltip logic, each following pure function or factory patterns that are independently reusable. The build system uses Vite with multi-entry UMD/ES module output, and the library is published on npm with a comprehensive test suite using Vitest and jsdom.
This is the official BNB Chain Evolution Proposal (BEP) repository — a governance/specification hub, not a software application. It contains 100+ BEPs and one BNB Application Proposal (BAP-578) that jointly define protocol changes for BNB Smart Chain (BSC), the Beacon Chain, opBNB, and Greenfield. Proposals cover consensus mechanics (fast finality BEP-126, short block intervals BEP-520/BEP-670, consecutive block production BEP-341), EVM semantics adopted from Ethereum EIPs (blob transactions, transient storage, PUSH0, set-code transactions), cryptographic precompiles (BLS12-381, secp256r1, KZG), cross-chain interoperability (BEP-171, BEP-293, BEP-363), staking and governance migration (BEP-294, BEP-297, BNB Chain Fusion BEP-333), and token standards (BEP-2, BEP-20, CAS20 BEP-702).
PyMeshLab is a Python library that provides bindings to the core functionality of MeshLab, a mature C++ application for processing and editing large 3D triangle meshes and point clouds. The library exposes a MeshSet class that wraps hundreds of geometry processing filters (e.g., simplification, smoothing, Boolean operations, surface reconstruction, parameterization) via a dynamic method registration pattern—each filter becomes an method on MeshSet at import time. The architecture relies on a pybind11-based C++ extension module that communicates with MeshLab's filter plugins, VCG library, Eigen, and Qt. Users can load meshes in many standard formats (OBJ, PLY, STL, etc.), apply filters with typed parameters (including custom types like PercentageValue and Color), and export results. The project includes comprehensive documentation, automated tests with sample meshes, and cross-platform build scripts for Linux, macOS, and Windows. While the library is tightly coupled to the MeshLab submodule, its design patterns—such as dynamic filter registration and reusable parameter wrappers—demonstrate solid engineering for bridging C++ and Python.
This repository is a comprehensive C++ library and suite of command-line tools for mesh processing research, originally developed by Hugues Hoppe at Microsoft Research. It implements algorithms from several SIGGRAPH papers (1992–2003), including surface reconstruction from unorganized points, mesh optimization, progressive meshes, view-dependent refinement, subdivision surface fitting, spherical parameterization, and gradient-domain video looping. The core library, libHh, provides a rich set of reusable data structures (e.g., fixed-size vectors, D-dimensional grids, half-edge meshes, progressive mesh representations) and algorithms (spatial search, least-squares solvers, multigrid, image filtering, parallel patterns). The tools are designed as stream-oriented filters that read from stdin and write to stdout, enabling Unix-style pipelines for complex processing workflows. An interactive OpenGL viewer (G3dOGL) supports real-time rendering with level-of-detail and geomorph transitions. The build system supports multiple platforms (Windows, Linux, macOS via Cygwin/MinGW) using GNU make and Visual Studio, with optional dependencies on libpng, libjpeg, and ffmpeg for media I/O. The codebase is well-tested with a comprehensive suite of unit and integration tests, and includes numerous demo scripts that reproduce published research results.
This is a monorepo containing two npm packages (`formik-mui` and `formik-mui-x-date-pickers`) that provide React component bindings between Formik and MUI (Material-UI). The `formik-mui` package wraps common MUI form components (TextField, Select, Checkbox, Switch, Autocomplete, RadioGroup, ToggleButtonGroup, etc.) to automatically manage Formik state (value, error, touched, disabled during submission). The `formik-mui-x-date-pickers` package does the same for MUI X date and time pickers (DatePicker, DateTimePicker, TimePicker, and their desktop/mobile/static variants). Both packages export a set of React components that accept Formik's `FieldProps` and MUI component props, along with corresponding `fieldTo*` mapper functions for custom component creation. The codebase is well-structured with TypeScript, comprehensive unit tests using Vitest and Testing Library, Storybook for interactive documentation, and a Docusaurus documentation site. It is actively maintained with recent commits and CI pipelines.
Sup is a console-based email client written in Ruby, designed for heavy email users who prefer a keyboard-driven, terminal interface. It provides a Gmail-like workflow with thread-centric conversation view, labeling (tags), archiving, muting, and full-text search powered by Xapian. The application supports multiple local mail sources (mbox and Maildir), multiple accounts, and can be extended via Ruby hooks. It runs as a full-screen ncurses application with a buffer-based window manager, offering modes for inbox, search results, compose, reply, forward, and more. Architecturally, Sup follows a modular pattern with manager classes (PollManager, UpdateManager, UndoManager, DraftManager, etc.) that encapsulate state and behavior. The UI is built on a Mode hierarchy with a shared keymap DSL, allowing consistent keyboard navigation across different views. The core data flow involves polling mail sources, parsing messages with RMail, threading them using a JWZ-inspired algorithm, and indexing them into a Xapian database for fast search. Labels and state are persisted in YAML files and the Xapian index. Key entry points include the main `bin/sup` TUI, `bin/sup-sync` for index synchronization, `bin/sup-add` for adding sources, and various utility scripts. External dependencies include ncursesw, RMail, Xapian, GPGME, and Chronic for date parsing. The project is in maintenance mode, focusing on stability and bug fixes rather than new features, but remains actively maintained with CI across many Ruby versions.
Kotlin Explorer is a desktop application built with Compose Desktop and Swing that disassembles Kotlin source code into multiple bytecode representations: JVM bytecode (via javap), Android DEX bytecode (via dexdump), and Android OAT assembly (via oatdump on a connected device). It orchestrates the full toolchain—compiling Kotlin with kotlinc, optionally optimizing with R8, and running the compiled code—all within a GUI that provides syntax-highlighted source and disassembly views, jump arrows for branch instructions, and integrated documentation for AArch64 opcodes. The application persists user settings (SDK paths, window geometry, source code) to disk and supports macOS, Windows, and Linux. The architecture is a single desktop application with a clear separation of concerns: UI components (menus, text areas, splitters) in Kotlin Explorer.kt and related files, build/disassembly orchestration in Disassembly.kt, and parsing logic in dedicated parsers for each bytecode format (ByteCodeParser, DexDumpParser, OatDumpParser). The codebase demonstrates strong Kotlin idioms, coroutine-based concurrency, and careful integration of Swing components within Compose. It relies on external toolchains (JDK, Android SDK, Kotlin compiler) and a connected Android device for OAT disassembly. Key reusable components include a generic PeekingIterator for lookahead parsing, a thread-safe ProgressUpdater for coroutine progress reporting, a suspend helper for running external processes with cancellation, and a CodeBuilder that constructs formatted disassembly text with line numbers and instruction metadata. The test infrastructure uses a Builder abstraction that can run the real toolchain or fall back to committed test data, enabling offline testing.
This repository is a Hugo theme named 'Jane' designed for creating readable, customizable blogs and websites. It integrates the Pico CSS framework for styling and provides extensive features including multilingual support, multiple comment system integrations (Disqus, Utterances, Giscus, etc.), analytics options, responsive design, and interactive JavaScript components (theme toggle, mobile navbar, table of contents, code copy). The theme follows Hugo's conventional structure with templates in layouts/, styling in assets/sass/, and functionality in assets/js/. It emphasizes long-term stability with minimal build dependencies (no Node.js required for core functionality) and provides an example site demonstrating full capabilities. The codebase shows good modularity in its partials, shortcodes, and widget system, allowing flexible customization while maintaining a clean separation of concerns.
TasmoAdmin is a web-based application for managing Tasmota-flashed IoT devices. It provides a responsive interface for device configuration, monitoring, firmware updates, and batch operations. The application features a modular PHP backend with dependency injection, factory patterns, and reusable helper utilities. It supports MQTT-based device discovery, automatic firmware updates via GitHub, and includes a self-update mechanism. The frontend uses Bootstrap 5 and jQuery for a modern user interface, with JavaScript modules handling dynamic interactions and state management.
Turbowatch is a file change detector and task orchestrator for Node.js that provides a more capable alternative to tools like Nodemon. It watches specified directories for file changes and executes user-defined tasks in response, featuring debouncing to batch rapid changes, retry logic for failed tasks, interruptible tasks to cancel ongoing operations, and graceful shutdown handling. The architecture uses a pluggable backend system for file watching (supporting native FSWatcher on macOS, falling back to Chokidar elsewhere), with an event processing pipeline that deduplicates and distributes changes to relevant subscribers. Key entry points include the CLI (bin/turbowatch.ts) and programmatic API (src/watch.ts). The system relies on dependencies like chokidar, zx for process spawning, micromatch for pattern matching, and roarr for structured logging.
GraphQLSwift/GraphQL is a Swift implementation of the GraphQL query language, ported from the JavaScript reference implementation graphql-js. It provides a complete runtime for parsing, validating, and executing GraphQL queries, mutations, and subscriptions. The library is designed to be embedded in Swift server applications, with companion packages for HTTP integration (graphql-vapor, graphql-hummingbird). It includes a full type system (Object, Interface, Union, Enum, InputObject, Scalar), schema building from SDL, introspection support, and a comprehensive set of validation rules that enforce the GraphQL specification. The architecture follows the graphql-js structure with modules for Language (lexer, parser, AST, printer, visitor), Type (schema, types, directives, scalars, introspection), Execution (query execution, subscription), Validation (validation rules, context), Utilities (schema building, type info, value from AST), and Map (dynamic value representation, JSON encoding). The library uses a visitor pattern for AST traversal and validation, and provides a Map type for handling dynamic GraphQL values with ordered dictionary semantics. Key features include support for persisted queries, subscription fields via AsyncThrowingStream, custom scalar types, and schema extension. The codebase is well-tested with extensive unit tests and benchmarks. However, some features are incomplete (e.g., variable directives, certain validation rules) and there is code duplication between AnyCoder and MapCoder. The library is actively maintained and follows the GraphQL specification closely, though it may lag behind the latest spec changes.
This repository is a comprehensive research codebase for Vision-Language-Action (VLA) models in robotic manipulation. It implements multiple model architectures (PI0, PI05, GR00T N1.5/N1.7, Cosmos3, FastWAM, DreamZero, DiT4DiT, SmolVLA, OpenVLA, LLaVA) with flow matching, diffusion, and autoregressive action heads. The primary purpose is to train, evaluate, and deploy VLA policies, with full pipelines for data ingestion (LeRobot parquet datasets), transformation (normalization, augmentation, video decoding), training (FSDP, mixed precision, gradient checkpointing), and inference (simulation benchmarks and real-robot ROS-based runners). Additionally, it includes research contributions in reward modeling (ARM, SARM, RA-BC/AW-BC), progress reconstruction, and subtask annotation. The codebase is highly configurable via mmengine-style configs and a registry system. While predominantly research-oriented, it also serves as an application framework for real-robot deployment with CUDA and Triton kernel optimizations, ZMQ-based serving, and Jetson Orin compatibility.
This repository is a Linux patching and distribution framework for Anthropic's Claude Desktop Electron app. It does not contain the original Claude Desktop source but instead ships a set of surgical Nim-compiled binary patches (55+) that regex-transform the minified Electron bundle (app.asar) to add Linux-specific fixes and community features. These patches address Wayland/X11 issues (popout menus, Quick Entry, tray icons, focus-follows-mouse, keep-awake, renderer clean-exit) and inject new functionality: a themes engine with 97 palettes, panel tabs (Diff, Terminal, Browser), a files quick-open (Ctrl+P) picker, custom third-party model routing, window transparency controls, a settings panel for feature toggles, and a Computer Use desktop automation bridge (x11, wlroots, GNOME portal, KWin portal). The build system ingests the official upstream .deb, extracts the bundle, applies all patches in staged order, adds platform-specific bridge binaries (musl/glibc), and repackages into six Linux formats: pacman (AUR + signed repo), APT, RPM, Nix flake, AppImage, and a raw tarball. A launcher shell script (claude-desktop-launcher.sh) manages profile isolation, Wayland/X11 detection, GPU fallbacks, systemd scopes, and diagnostics. Architecturally, the project is a layered set of Electron extensions. The core patching layer is written in Nim and compiles to standalone binaries that apply idempotent regex replacements to the minified JS. Each patch includes a positive end-state assertion (expected marker count) and quits with code 1 on mismatch. A Python orchestrator (apply_patches.py) scans patches grouped by target, stages them in dependency order, and validates absorption. The JavaScript layer consists of modules injected into the main or renderer processes via the patches; they communicate over origin-validated IPC channels (e.g., cdb-extra:*, cdb-diff:*, cdb-tlimits:*), read/write configuration from claude-desktop-extra.jsonc (human-locked) and .json (app-written), and use localStorage for MRU state. The Computer Use feature employs a bridge CLI contract with external binaries that expose a standardized protocol (doctor, screens, session-start, etc.). The project includes a comprehensive test suite (headless Chromium DOM tests, vm-sandboxed module tests, and integration tests for bridges) that runs in CI. The codebase demonstrates high craftsmanship in several areas: a minimal D-Bus client over Unix sockets (js/kde_global_shortcuts_rebind.js), a reusable test harness for injected scripts (tests/lib/theme-engine-harness.mjs), atomic file writes with tmp+rename, JSONC comment stripping with string-aware guards, and origin-based sender validation that fails closed. Maintenance risk is centered on upstream minified JS shape changes — every patch anchors on specific minified identifiers that can shift with each Claude Desktop release, though the project mitigates this with version-specific fallback logic, absorption detection, and a documented update workflow. The project is actively maintained (last commit 2026-10-23, GitHub Actions auto-release on upstream version bumps), low technical drift (pinned dependencies, ES modules, modern Node API usage), and the code is well-organized with clear separation between patches, JS modules, packaging scripts, and documentation.
Godot-Secure is a set of Python scripts that automatically modify the Godot Engine source code to integrate enhanced encryption (AES-256 or Camellia-256) with a unique security token system. The scripts generate random magic headers, a 32-byte security token embedded in the engine binary, and optionally apply advanced key derivation formulas or scramble the GDScript tokenizer buffer to prevent decompilation. The tool is designed to be run once before compiling a custom Godot engine build, making each build cryptographically unique and resistant to generic decryption tools. The codebase demonstrates solid engineering with declarative modification definitions, backup creation, and detailed logging, though it is tightly coupled to the Godot source structure.
This repository contains a user script (smg_fivestar.user.js) designed to bypass restrictions on the SMGTV live streaming website (kankanews.com). The script modifies the behavior of the video player to remove trial countdowns, prevent auto-pausing when switching tabs, and unlock content via API response manipulation. It also implements a custom fullscreen fallback mechanism using CSS when the native fullscreen API fails. The script runs in the browser via Tampermonkey/Violentmonkey and targets pages matching *://*.kankanews.com/huikan*. While highly specific to the target website, the script contains reusable utility functions for CSS injection, Vue instance retrieval, and method wrapping that demonstrate solid web extension craftsmanship.
QElectroTech is a mature, open-source desktop CAD application for creating electrical schematics and diagrams. Built on Qt (C++) with a rich graphics view framework, it provides full interactive editing for folios, conductors, terminals, element symbols, title blocks, and terminal strips. The system manages project files via XML, supports auto-numbering of elements and conductors, cross-referencing, bill-of-materials export, and imports EPLAN EDZ archives using bundled LZMA decompression. It is purely a desktop application with no server or data-pipeline components, offering a comprehensive set of features for electrical documentation in industrial and domestic contexts. The architecture follows a monolithic desktop GUI pattern with extensive use of Qt's model/view and graphics view frameworks. Key entry points include the main window (QETMainWindow), diagram editor (QETDiagramEditor), element editor, and terminal strip editor. The codebase demonstrates strong use of the undo/redo command pattern (QUndoCommand), a generic QPropertyUndoCommand, and a custom DXF paint engine. The project has a large number of interdependent modules but maintains reasonable separation through abstract base classes (PropertiesInterface, DiagramEventInterface). The code is professionally written with moderate complexity and a clear focus on functional CAD features rather than framework novelty.
This repository contains a Jupyter notebook that processes Strava data exports to generate interactive running heatmaps. The core functionality involves parsing GPS and sensor data from .fit.gz files, filtering activities by type and date, detecting a home location, rasterizing GPS tracks into multiple value grids (frequency, pace, heart rate, gradient, elevation change), applying Gaussian blurring and normalization, and rendering the results as overlay layers on a Leaflet basemap via Folium. The output is a single HTML file with six toggleable layers showing different aspects of running patterns. The code demonstrates solid data processing techniques including efficient caching, coordinate transformations, and custom visualization logic, though it remains tightly coupled as a monolithic notebook.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.