SpatialClaw is a research evaluation harness for training-free spatial reasoning, in which a VLM agent uses Python code as its action interface: it plans, writes one code cell per step, passes an AST safety check, executes in a persistent Jupyter kernel pre-loaded with perception primitives (SAM3 segmentation, Depth-Anything-3/Pi3/MapAnything 3D reconstruction, EasyOCR) and scientific libraries, then receives condensed stdout/variable/image feedback until it emits a ReturnAnswer sentinel. The loop is assembled as a LangGraph state machine (init -> plan -> llm_step -> execute -> feedback -> reflection -> terminate) with code, ReAct, and single-pass executor variants plus a no-tool CoT baseline. This is the system that generated 14k+ executable video-QA demonstrations for NVIDIA Nemotron 3.5 Super VL per docs/nemotron.md. The runtime is a three-service distributed architecture: vLLM OpenAI-compatible LLM servers, a FastAPI GPU tool server exposing segmentation/reconstruction/OCR over a type-safe MessagePack RPC codec, and CPU-side agent processes managing Jupyter kernel pools. Services discover each other via file-locked JSON registries (serve.json, gpu_server.json) and are orchestrated as auto-resuming, overlapping SLURM chain jobs with sendmail-like rotate-and-restart behavior. It ships interactive CLIs for vllm/gpu-server/agent lifecycle management, a FastAPI results visualization server, and a GPU monitoring dashboard. Key entry points are python -m spatial_agent.entrypoints.run (benchmark evaluation), cot_baseline.py, launch_vllm.py, and launch_gpu_server.py. On the data side, 20 benchmark loaders (BLINK, ERQA, Omni3D, MMSI, VSI-Bench, Video-MME-v2, SPAR-Bench, CV-Bench, etc.) are registered through a factory pattern with per-benchmark exact-match and Mean Relative Accuracy (MRA) threshold scoring, category/question-type aggregation, deterministic subsampling, JSONL prediction resume, and per-sample trace/HTML reports. Datasets are fetched externally into data/ by scripts/download_datasets.sh; third-party vision models are pinned git submodules. This is application-class research infrastructure rather than a reusable library or data pipeline. It is tightly coupled to NVIDIA-internal SLURM accounts/partitions, conda envs, nightly vLLM wheels (CUDA 12.9), HF offline caches, and gated weights; it will not run outside the original cluster without significant reconfiguration. No test suite is present, several modules carry acknowledged hacks (a placeholder crc32 in the hand-rolled TFRecord parser, regex-only security sandbox, GPU idle-reaper keepalives), and chain managers/benchmark evals show duplication. The genuinely reusable assets are the RPC codec, MRA scoring utilities, lazy video loading scaffolding, aligned per-frame data model, and LLM error-condensation logic.
PySB is a Python framework for building and simulating rule-based mathematical models of biochemical systems. It provides a domain-specific language (DSL) embedded in Python for defining monomers, rules, parameters, and observables, with operator overloading to express reactions concisely. The library supports multiple simulation backends (SciPy ODE, BioNetGen, StochKit, Kappa, CUDA/OpenCL SSA, cupSODA) and can export models to SBML, MATLAB, Mathematica, BNGL, JSON, and other formats. It includes tools for sensitivity analysis, pattern matching, model testing, and parameter estimation. While primarily a software library, it also contains research examples, paper figure reproduction scripts, and experimental data, making it a hybrid project with a strong application core. The codebase is well-structured with clean abstractions (simulator base class, exporter registry, composable filter predicates) and extensive test coverage, though it carries some technical debt from deprecated modules and external tool dependencies.
nix-topology is a NixOS module and toolchain that automatically generates infrastructure and network topology diagrams (SVG) from NixOS configurations. It defines a global module system to declare nodes, networks, interfaces, and services. A NixOS module automatically extracts information from systemd-networkd, known services, microvms, nixos-containers, and DHCP servers (kea). The architecture decouples information gathering from rendering: two renderers (ELK for layout, SVG for per-node cards) produce both a physical-connection diagram and a network-centric view. The project demonstrates advanced Nix module system usage (merge, lazy evaluation, option types) and provides standalone Node.js tools (elk-to-svg, html-to-svg) for converting ELK JSON and Satori HTML to SVG. It supports user-defined nodes, connections, networks, and icons, with automatic network propagation through connections.
This repository provides a library and build-time plugin for embedding a React (or Preact / React Native Web) web application inside a React Native WebView, with automatic bundling and two-way communication between the native and web sides. It consists of a Metro transformer plugin that uses Babel AST analysis to detect entry files (those calling webViewRender or webViewCreateRoot), then bundles the web app via esbuild with custom asset loaders for images, CSS, JSON, text, Markdown, and WebAssembly. The bundled output is wrapped in an HTML string and returned as the module source, which is then loaded into a react-native-webview at runtime. The library exposes React hooks (useWebViewMessage for native, useNativeMessage and emit for web) that handle message passing via window.postMessage and ReactNativeWebView.postMessage. The architecture is a classic library + build plugin pattern, with clear separation between native (React Native) and web (React DOM) concerns. The codebase is TypeScript, has end-to-end Playwright tests with HTML snapshots, unit tests, and thorough type definitions. It is designed for rapid prototyping or features that require web-specific APIs (e.g., WebAssembly, contenteditable) without rewriting the entire UI for React Native.
CATMAID (Collaborative Annotation Toolkit for Massive Amounts of Image Data) is a full-stack web application for collaborative connectomics research. It enables neuroscientists to trace neuron skeletons, annotate synapses, and analyze neural circuits across massive image stacks. The backend is a Django monolith with a REST API, PostgreSQL/PostGIS database, Celery for async tasks, and WebSockets for real-time collaboration. The frontend is a large JavaScript codebase using jQuery, Three.js, Pixi.js, D3, and custom widget system. Key features include skeleton tracing tools, 3D visualization, NBLAST neuron similarity, connectivity matrices, and review workflows. The codebase is well-structured with many reusable client-side utilities (event system, command pattern, caching, settings manager) and demonstrates strong engineering practices with CI/CD, tests, and Docker deployment. However, it carries some technical debt from vendored libraries and complex database migrations.
Spam Call Blocker is an Android application written in Kotlin that blocks unwanted incoming calls using a combination of local blocklists, pattern matching, and real-time checks against multiple online phone reputation services (UnknownPhone, Tellows, Truecaller, and regional directories). It registers a call screening service to intercept calls, evaluates them against user-defined rules and external APIs, and can block, mute, or answer-and-hangup spam calls. The app provides a full settings UI for managing blocked/whitelisted numbers, pattern-based blocking, API toggles, and export/import of configuration. It also includes a donation screen and automatic update checking via GitHub releases. The codebase is well-structured with clear separation of concerns, uses Kotlin coroutines for concurrent API checks, and supports multiple languages.
Hercules is a GPL-licensed, open-source MMORPG server emulator specifically for Ragnarok Online. It provides a multi-process server architecture consisting of login, character, map, and HTTP API servers, all written in C (migrating to C++20). The codebase is large (4,000+ files) and implements the full game logic including combat, skills, item systems, quests, instances, guild wars, parties, mail (RoDEX), auction houses, vending, and a plugin system (HPM) for extensibility. The project maintains compatibility with multiple official client versions through conditional packet definitions, and uses MySQL/MariaDB for persistent storage with a robust SQL migration system. The architecture follows an interface pattern, where each major subsystem exposes a struct of function pointers, enabling loose coupling and plugin hooks. The repository includes extensive configuration files (libconfig), game databases (monsters, items, skills, etc.), and utility libraries for networking, memory management, and string processing.
gh-poi is a GitHub CLI extension (written in Go) that safely removes local git branches whose associated pull requests have been merged or closed. It solves a real pain point: squash-merged PRs leave no merge commit in the default branch, so tools like `git branch --delete-merged` cannot identify them as safe to delete. The tool reconstructs the branch-to-PR association by querying GitHub's GraphQL API with commit hashes, then applies a layered safety model (locks, worktrees, uncommitted changes, untracked files, detached HEAD, default-branch protection) before deleting anything. It supports `--dry-run`, `--state merged|closed`, `--scan quick|deep`, and `lock`/`unlock` subcommands that persist locks in git config as `branch.<name>.gh-poi-locked`.
This is a Visual Studio Code extension that provides comprehensive Nix language support. It delivers syntax highlighting via a custom TextMate grammar (programmatically generated from TypeScript definitions), formatting through external tools like nixfmt, linting via nix-instantiate, and full LSP integration for language servers such as nil and nixd. The extension also includes snippets, language configuration (auto-closing, indentation rules), and embedded Nix code block highlighting in Markdown. The architecture is a standard VS Code extension with a client-side LSP client, formatting providers, and a diagnostic collection. The codebase is actively maintained, uses modern tooling (Bun, Biome, TypeScript 6), and has CI/CD with testing. It is not a data pipeline but a developer tool.
ComfyUI-VoxCPM is a ComfyUI custom node package that provides expressive text-to-speech (TTS) using the VoxCPM model family (v1.x and v2). It supports zero-shot TTS, voice cloning (prompt or reference audio), voice design via text descriptions, LoRA inference, and LoRA fine-tuning. The architecture is a ComfyUI extension with heavy JavaScript frontend, HTTP API routes, and vendored model inference code. The core functionality is implemented in the `src/voxcpm/` directory, which contains model architectures (MiniCPM4, AudioVAE, local DiT, etc.), a standalone CLI, and training utilities. External dependencies include ComfyUI, PyTorch, Hugging Face Hub, and several optional libraries (argbind, datasets, modelscope, etc.). The codebase demonstrates good software engineering practices with clean abstractions, reusable components, and graceful degradation for optional features. However, it is tightly coupled to ComfyUI's ecosystem and vendors upstream model code, which may drift from upstream. The repository also includes a standalone `hf_progress` library for HuggingFace transfer progress tracking, which is a well-isolated, reusable component.
This repository is a comprehensive, interactive documentation website (handbook) for LLM inference, built with Docusaurus. It covers the full stack from hardware selection to kernel optimization, with embedded calculators, visualizers, and simulators. The content is heavily branded by Modular (MAX/Mojo ecosystem) and serves as both a technical reference and a product funnel. The codebase is well-structured with a custom design system, but the interactive components are tightly coupled to the Docusaurus framework and the specific educational content, limiting reusability. The repo is actively maintained and uses modern web technologies. It is not a data research project; it is a static web application for education.
Swabble is a macOS 26 CLI daemon and Swift library that listens to the microphone, detects a configurable wake word (default 'clawd'), transcribes speech locally using Apple's Speech.framework (SpeechAnalyzer + SpeechTranscriber), and executes a user-defined shell hook with the transcript. It also supports offline file transcription to TXT or SRT. The architecture is a monolith Swift package with a library target (SwabbleCore) exposing reusable components like the speech pipeline, hook runner, config loader, and transcript store, and an executable target (SwabbleCLI) using the Commander library for command routing. Key data flows: microphone audio → AVAudioEngine tap → BufferConverter → SpeechAnalyzer → SpeechTranscriber → async stream → wake-word matching → HookRunner → shell process. External dependencies are limited to Apple frameworks and the Commander package. The codebase demonstrates strong use of Swift 6.2 concurrency (actors, async streams), careful process management with timeout and cancellation, and clean separation of concerns. It is well-tested with CI covering formatting, linting, unit tests, and release verification.
This repository is a curated collection of Markdown files providing detailed, step-by-step instructions for configuring privacy and security settings across a wide range of software, operating systems, and online services. It covers desktop and mobile browsers (Brave, Firefox, Chrome, Edge, Vivaldi), operating systems (Windows 10/11, Android versions, macOS Sequoia), messaging apps (Signal, WhatsApp, Telegram), social media (Facebook, Instagram, Reddit, Twitter), and many other tools. The content is organized alphabetically, with each file containing screenshots (referenced but not included in the repo), notes, and tips. There is no executable code or build system; the repository is purely documentation. It serves as a reference guide for users seeking to minimize data collection and tracking. The project is actively maintained, with frequent updates tracking changes in the latest versions of the covered software.
PhotoEditor is an Android library (published on Maven Central) that provides a comprehensive image editing SDK. It allows users to draw on images with customizable brushes and shapes (line, oval, rectangle, arrow), apply filter effects via Android's deprecated MediaEffect API, add and edit text with rich styling (color, font, shadow, border), insert emoji and stickers, and perform pinch-to-scale/rotate gestures on added elements. The library is built around a `PhotoEditorView` custom RelativeLayout that composes an ImageView, a DrawingView (custom canvas for brush/shape rendering), and an ImageFilterView (GLSurfaceView for filters). The architecture employs several design patterns: Builder (PhotoEditor, ShapeBuilder, TextStyleBuilder, SaveSettings), Composite (Graphic interface with Text, Sticker, Emoji implementations), Strategy (Shape interface with concrete shapes), and Listener (OnPhotoEditorListener, BrushViewChangeListener). The sample app demonstrates all features. The library has a robust undo/redo system managed by GraphicManager and PhotoEditorViewState. While the core functionality is solid, the filter implementation relies on deprecated Android APIs (android.media.effect), which is a known limitation and source of issues. The codebase is well-structured with unit and instrumentation tests, CI/CD pipelines, and proper Kotlin coroutines for async saving.
Jellyfish is an open-source, full-stack AI short drama studio application. It provides an end-to-end production pipeline for generating vertical short dramas from scripts: script parsing (division, element extraction, consistency checking), storyboard generation (shot breakdown, asset linking, camera language), image/video generation via multiple AI providers (OpenAI, Volcengine), and async task orchestration with Celery. The backend is built with FastAPI, SQLAlchemy 2.0 async, and Redis; the frontend uses React 18, TypeScript, Ant Design, and Vite. The application is production-oriented with Docker Compose deployment, GitHub Actions CI, and automated OpenAPI client generation. It emphasizes visual consistency through global seed, style inheritance, and asset reuse. While primarily an application, it includes a significant amount of AI/LLM agent code for script analysis, giving it a hybrid character with research-oriented structured extraction pipelines.
Ultrachromic is a CSS theme for the Jellyfin media server that provides a modular system of CSS overrides to customize the appearance of the Jellyfin web interface. It consists of multiple CSS files that can be imported in a specific order to build a theme, including base styling, accent colors, rounding, progress bars, and various visual effects. The theme uses CSS variables for easy customization and includes presets that replicate the appearance of older chromic themes. It demonstrates good use of modern CSS features such as CSS variables, animations, backdrop-filter, and media queries.
swift-sh is a CLI tool that enables Swift scripts to declare and fetch third-party dependencies via special comments in import statements. It parses a script's imports (e.g., `import Foo // @mxcl ~> 1.0`), generates a Swift Package Manager project with those dependencies, builds it, and runs the resulting executable. The architecture is modular with separate targets for script parsing (Script), command handling (Command), and utility functions (Utility). The tool supports both file-based and stdin scripts, local dependencies, and provides subcommands for ejecting to a full package and editing in Xcode (macOS only). It is a pragmatic solution that bridges the gap between ad-hoc scripting and SwiftPM's package structure.
phpspec is a mature Behavior-Driven Development (BDD) testing framework for PHP, functionally a Command-Line Interface (CLI) application and developer toolset rather than an application server. In production (i.e., when run in a developer workflow via `bin/phpspec`), it locates PHP spec files, executes each example method through a runner pipeline composed of 'maintainers' (subject creation, matcher injection, let/letgo lifecycle, error handling), evaluates assertions against a flexible priority-based matcher system, and reports results through pluggable formatters (progress, dot, JUnit, TAP, HTML, JSON, TeamCity). It also performs interactive code generation: when a spec fails because a class or method does not exist, listeners prompt the developer and generate the missing class, method, interface, named constructor, or return constant using token-based code writers and templates, then automatically re-runs the suite. The architecture is event-driven (Symfony EventDispatcher), wired through a custom service container (`IndexedServiceContainer`), with an extension API (`PhpSpec\Extension`) for registering custom matchers, formatters, and listeners. The framework is self-hosted: it tests itself using its own spec system and Behat feature tests, with extensive spec coverage for nearly every class.
qaac is a command-line audio encoder that uses Apple's CoreAudioToolbox (or the reference ALAC encoder) to encode audio to AAC or ALAC formats. It supports a wide range of input formats (WAV, FLAC, WavPack, Opus, Ogg Vorbis, CAF, and more) via runtime-loaded codec libraries, and outputs to MP4/M4A, ADTS, CAF, WAV, or raw PCM. The architecture follows a clean pipeline pattern: input sources implement the ISource interface, pass through optional DSP filters (resampler, normalizer, limiter, compressor, matrix mixer, etc.), and are written to output sinks. Metadata handling is integrated via vendored taglib, and the encoder supports gapless encoding, chapter markers, artwork, and various tagging formats. The codebase is predominantly C++ with platform-specific adaptations for Windows and macOS, and includes several reusable utility components such as a streaming FFT convolver, ring buffer, and cross-platform dynamic library loader.
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.