Ebib is a BibTeX database manager for GNU Emacs that provides a standalone interface for managing bibliographic references without editing raw .bib files. It features a two-window layout (index and entry buffers) and supports both BibTeX and biblatex formats. The system enables entry creation/editing, search/filtering, citation insertion into text buffers, external resource linking (files/URLs/DOIs), notes management (Org/Markdown), reading list tracking, and keyword handling. Built entirely in Emacs Lisp, it integrates with Emacs ecosystem tools like Ivy/Helm for completion, Org mode for notes/reading lists, and external utilities for DOI resolution and file viewing. The architecture is modular with separate modules for database logic, utilities, filters, notes, reading lists, and keywords, demonstrating good separation of concerns.
GQLAlchemy is a Python library and Object Graph Mapper (OGM) for the Memgraph graph database, with secondary support for Neo4j. It provides a fluent Cypher query builder, declarative node/relationship models (Pydantic v2-based), and full lifecycle management of graph database instances (Docker/binary), streams (Kafka, Pulsar), triggers, and high-availability routing. The library also includes a rich set of transformations for bidirectional conversion between Memgraph/Neo4j and popular graph machine learning frameworks (NetworkX, DGL, PyG, TF-GNN), as well as tabular data import (CSV, Parquet, ORC, Feather) from local filesystem, S3, and Azure Blob Storage. While primarily a software library for building graph applications, it has strong data research capabilities through its graph ML translators and ETL importers, making it a hybrid tool suited for both production graph apps and data science pipelines. The codebase is well-tested (unit and integration tests), has comprehensive CI/CD, and follows a modular architecture with abstract base classes for extensibility. However, some modules are large (e.g., monolithic query builders), and optional dependencies (PyTorch, DGL, TF-GNN, PyArrow) increase maintenance surface, with a medium level of technical drift due to some deprecated Pydantic v1 patterns and skipped tests.
Pegomock is a mocking framework for the Go programming language that generates mock implementations of interfaces for testing purposes. It provides a DSL inspired by Mockito for defining mock behavior and verifying interactions. The project consists of a core library for creating and verifying mocks in tests, a CLI tool for generating mock code from interfaces, and a watch mode that automatically regenerates mocks when interfaces change. The architecture follows a modular design with separate components for the DSL, mock generation, and CLI functionality.
Ember Data Factory Guy is an Ember.js addon designed for factory-based testing in Ember Data applications. It replaces traditional fixtures with factory definitions to generate test data, providing methods like `make`, `build`, and `mock*` for creating and persisting test records. The addon includes request mocking capabilities supporting both Pretender and MSW libraries, scenario management for test setup, and serializer-specific builders/converters for JSONAPI, REST, JSON, and ActiveModel formats. Architecture follows Ember addon conventions with a clear separation between core factory logic, adapter-specific handling, and mocking abstraters. The test application demonstrates usage patterns but is not the primary product.
DelphiAST is a Delphi/FreePascal Abstract Syntax Tree (AST) builder that parses Object Pascal source code into a structured XML or binary representation. The architecture centers around a core library (DelphiAST.pas) comprising a lexer/parser extension (SimpleParserEx), AST node hierarchy (DelphiAST.Classes), XML/binary serializers (Writer, Serialize.Binary), string interning pool (StringPool), and project indexing utility (ProjectIndexer). Key entry points include TPasSyntaxTreeBuilder.Run() for parsing, TProjectIndexer for dependency resolution, and demo applications like ParserDemo (GUI AST visualizer) and ProjectIndexerResearch (console project analyzer). Data flows involve source code input → lexer → parser → AST construction → serialization/output or project analysis. External dependencies include FreePascal support submodules and Delphi/FPC RTL units like Generics.Collections.
coreaudio-rs is a Rust library providing safe, zero-cost bindings to Apple's CoreAudio API, with particular focus on Audio Unit functionality. The library wraps the complex C API in Rust abstractions that maintain type safety and memory safety while preserving performance. It enables Rust developers to work with audio input/output, audio processing, and hardware interaction on Apple platforms (macOS, iOS, tvOS, visionOS). The architecture follows a modular library design with core functionality in src/, platform-specific helpers in src/audio_unit/macos_helpers.rs, and comprehensive examples demonstrating usage patterns. The library relies on the objc2 crate family for Objective-C interoperability and bitflags for flag management. Data flows involve audio buffers moving between hardware devices and AudioUnit instances through callback mechanisms, with configuration flowing from Rust definitions to the CoreAudio API. Entry points include the main library interface in src/lib.rs, the AudioUnit constructor and methods in src/audio_unit/mod.rs, and platform-specific initialization helpers. The examples directory provides practical demonstrations of audio playback, input/output streaming, and advanced audio unit configuration.
RVO2-3D is a C++ library implementing Optimal Reciprocal Collision Avoidance (ORCA) for multi-agent simulation in three-dimensional workspaces. It provides a simulator that manages agents with configurable parameters (radius, max speed, time horizon, etc.) and computes collision-free velocities each time step using a linear programming approach over ORCA half-planes. The library uses a k-d tree for efficient neighbor queries and optionally leverages OpenMP for parallel agent updates. The public API is exposed through the RVOSimulator class, with supporting types Vector3 and Plane. The codebase is written in C++98 for maximum compatibility, is thoroughly documented with Doxygen, and includes a single example (Sphere) that serves as both a demonstration and a test. The repository is well-maintained with CI across multiple platforms and build systems (CMake, Bazel), static analysis, and a quality declaration targeting ROS 2 Quality Level 2.
Tachyon is a production-grade serverless image resizing service built on AWS Lambda and S3. It takes HTTP requests that specify a path to an S3 object and query parameters (width, height, crop, quality, format, etc.), fetches the original image from S3 using the AWS SDK v3, resizes/transcodes it in-memory using the Sharp library (with support for animated GIF/WebP/PNG and smart cropping via smartcrop-sharp), and streams the result back to the client with appropriate cache headers. It natively supports presigned S3 URLs for accessing private objects by implementing a custom request signer that re-attaches presigned query parameters to the S3 GetObject call—bypassing the default SDK signing. The function is designed to be deployed as a single Lambda behind a Function URL (response streaming) or API Gateway, and includes a local development server for testing. While its primary use case is WordPress media handling (as part of the Human Made ecosystem), the core resizing and S3-fetching logic is framework-agnostic and could be adapted to any serverless image processing pipeline.
StreamForge AI is a real-time data platform designed for ML/AI workloads, integrating CDC ingestion, stream processing, feature storage, and serving. The architecture comprises distinct layers: ingestion (Debezium/Kafka), processing (Flink), storage (MinIO/S3 with optional Iceberg), and serving (online/offline feature store). Key components include a control plane API/UI for pipeline management, a Feast/Tecton-compatible feature store, schema registry client, drift detector, lineage tracker, and prefetch engine for ML training optimization. The platform supports end-to-end pipelines from database changes to feature materialization and inference, with examples demonstrating ML training, real-time serving, and feature consumption. While the system demonstrates strong modularity and integration of industry-standard tools, its operational complexity and polyglot nature (Java/Python/JS) present maintenance challenges.
PlumeLens (鉴翎) is a local bird photo analysis and culling workstation for bird photographers. It uses on-device ML models—YOLOv26l for detection, a custom 11-keypoint pose estimator, CLIPIQA+/HyperIQA for quality assessment, and DINOv3 with LoRA adapters for species classification—to process photos without any cloud upload. The system scans user photo directories (read-only), performs detection, pose estimation, quality scoring, and species identification, then presents a grading interface (reject/record/usable/select) with manual review and species override capabilities. Export supports JPG/RAW with XMP sidecars, and a geographic archive module visualizes species sightings on an interactive map with conservation status. The architecture is a desktop application split into an Electron+React frontend and a Python FastAPI backend. The backend runs as a subprocess managed by Electron, communicating via REST APIs and Server-Sent Events for progress. The ML pipeline is orchestrated in `engine/pipeline/manager.py` with ONNX Runtime and PyTorch inferences. The frontend uses React 19, TanStack Query, Zustand, and a virtualized grid for handling large photo sets. The application is packaged for macOS (arm64) via electron-builder and PyInstaller. While the primary delivery is a desktop application, the repository also contains extensive model training scripts, evaluation frameworks (`evals/`), and dataset preparation utilities, making it a hybrid project with significant research and data engineering components. Model integrity is enforced via SHA-256 manifest verification at startup, and all inference is deterministic with versioned pipeline hashes to invalidate caches on updates.
TermUI is a comprehensive TypeScript monorepo providing a full-featured terminal UI framework for building rich, interactive command-line applications. It includes a custom JSX runtime with hooks, reconciliation, and portals; a theme engine (TSS) with CSS-like syntax and 26 built-in themes; a widget library spanning layout, input, display, data visualization, and feedback components; a motion system with spring physics and composable animations; a client-side router; a Zustand-like state store; adapters for external integrations (AI, Git, GitHub, clipboard, keychain); real-time system data hooks (CPU, memory, disk, Docker); a CLI scaffolding tool; and a dev server with hot reload. The framework is designed to offer a React-like development experience for terminal UIs, supporting JSX/TSX, keyboard and mouse input, focus management, accessibility (OSC 133), and unicode/ASCII fallbacks across 14+ packages with over 5000 tests.
Tinty is a mature Rust CLI tool for managing color schemes across terminals, editors, and other applications, implementing the Base16/Base24/Tinted8 theming standards. It provides subcommands to install, update, apply, cycle, list, and build schemes, driven by a TOML configuration file that defines template repositories, scheme cycles, hooks, and per-item settings. The architecture separates concerns into operations modules, a git-based repository backend, and a static HTML/JS gallery with an embedded local HTTP server for live scheme preview and application. The codebase demonstrates strong engineering practices including trait-based abstraction for git operations, atomic artifact staging, locale-independent conflict detection, marker-based file editing, and parallel scheme parsing via rayon. It has extensive integration tests with a reusable test harness, CI/CD pipelines, and packaging for crates.io, Homebrew, Nix, and Docker. While the code is actively maintained and well-structured, there is moderate technical drift from deprecated dependencies (serde_yaml), duplicated test infrastructure, and pending architectural migrations (gix backend, shell completion script divergence). The system is tightly focused on its domain but the component patterns (config validation, atomic file writes, abstracted repository operations) are reusable in other CLI tools requiring similar infrastructure.
SpanFinder is a fully-featured Windows file explorer replacement built with WinUI 3 and .NET 8, implementing the macOS Finder Miller Columns paradigm. The application supports multiple view modes (Miller Columns, Details, List, Icons), multi-tab with tear-off, split pane, Quick Look preview, batch rename, archive handling (ZIP, RAR, 7z via native OtterZip engine), remote file access (FTP/SFTP/SMB), Git integration, cloud sync badges, and a file shelf for drag-and-drop staging. The architecture follows MVVM with dependency injection, extensive use of Win32 P/Invoke and COM interop for shell integration, and a separate thumbnail worker process for crash isolation. The codebase is well-organized into Services, Models, ViewModels, and Helpers, with over 150 unit tests and 40+ UI automation tests. However, it exhibits some mixed abstraction layers and a few large partial classes (MainWindow, MainViewModel), and many comments reference specific bug fixes, indicating ongoing refinement. The repository is actively maintained with recent commits, a single open issue, and regular versioned releases (v2.0.7).
Live Photo Converter is a cross-platform application for processing Android Live Photos (MVIMG files). It provides a modern GTK4/LibAdwaita graphical interface, a set of command-line tools, and a shared library (`liblivephototools`) for creating, extracting, and repairing these files. The core operation involves appending an MP4 video to a JPEG image and managing the associated XMP metadata (Google's GCamera and Container namespaces). It also supports generating long exposure photos from video frames and copying metadata between images. The architecture is a well-structured monolith written in Vala and built with Meson. The core logic resides in a shared library, with CLI and GUI frontends linking against it. Video processing is handled by a clean strategy pattern, defaulting to an in-process GStreamer pipeline with an FFmpeg subprocess fallback. The build system is highly sophisticated, supporting Linux (Flatpak, Arch), Windows (MSYS2), macOS (Homebrew), and Android (experimental, via pixiewood). The codebase demonstrates strong software craftsmanship. It features clean abstractions (abstract base classes `LivePhoto`/`LiveMaker`), meticulous thread safety (GOnce, AtomicInt, AsyncQueue, Mutex), and well-encapsulated utility components. The `PipelineWatch` class for GStreamer error handling and the `Reporter` class for CLI output are particularly well-crafted and reusable. The primary weakness is the absence of a formal unit test suite, which prevents a higher quality score.
LeanKG is a Go-based knowledge graph engine for AI-assisted development. It indexes source code from multi-language repositories into a graph of elements (functions, types, classes) and relationships (calls, imports, implements), stored in SQLite or PostgreSQL with optional vector embeddings for semantic search. The system provides a CLI, REST API, MCP (Model Context Protocol) server, and a React web UI (force-directed graph, file tree, code panel). Core capabilities include incremental indexing with three-signal change detection, a four-tier query ladder (cold/exact/fuzzy/semantic), impact analysis with blast radius, organizational knowledge management (incidents, notes, env reports), ontology matching, federation across servers, and token-budgeted compression for AI tool integration. The architecture is modular: the store backend interface supports SQLite and PostgreSQL with a shared migration ledger; indexing uses regex extractors for 40+ languages with an optional tree-sitter CGO tier; embeddings use a provider abstraction (OpenAI-compatible, llama.cpp sidecar, deterministic). The codebase is well-structured with extensive tests, hermetic test patterns, and deterministic output design. Notable reusability includes the compress package (shell output, git diff), auth token system, store abstraction pattern, and A/B benchmarking harness.
This repository implements an end-to-end 3D object generation application that takes natural language descriptions and produces 3D mesh models (GLB format). It orchestrates three generative AI models: an LLM (Qwen3 or Llama) for scene planning, a diffusion model (SANA Sprint) for 2D image generation, and Microsoft TRELLIS for 3D generation. The system presents a Gradio web interface for user interaction and includes a Blender addon for direct import of generated assets. It supports two deployment modes: native PyTorch models (for local development) and NIM containers (for scalable inference). Key architectural patterns include a singleton GPU memory manager that coordinates model loading/unloading across VRAM-constrained GPUs, a guardrail service for content safety, and a conditional service abstraction that transparently switches between native and NIM backends based on configuration. The repository is well-structured with modular UI components and comprehensive installation scripts, though it is Windows-only and has complex event chains in the main UI file. The code is actively maintained with recent commits and pinned dependencies, but the heavy reliance on patched versions of TRELLIS and a specific Gradio version introduces some maintenance risk.
oh-my-antigravity (OmA) is an extension for Gemini CLI that adds a structured, role-driven multi-agent workflow layer on top of the base CLI. It transforms a single-session AI assistant into an orchestrated engineering pipeline with roles such as architect, planner, executor, reviewer, and verifier. The extension provides over 40 slash commands, 11 retained deep-work skills, 13 sub-agent definitions, and two shipped hooks (silent BeforeModel model router and AfterAgent learn-signal filter). The architecture is entirely extension-native, relying on Gemini CLI's extension manifest (`gemini-extension.json`), command definitions in TOML files, agent prompts in Markdown, and hook scripts in JavaScript. The primary data flow is user input → `/oma:*` command → staged pipeline (intent → workspace → team-assemble → team-plan → team-prd → team-exec → team-verify → team-fix → loop) with persistent state in `.omg/state/`. The codebase demonstrates strong engineering discipline with version consistency checks, skill metadata validation, atomic file writes, environment-variable-driven runtime controls, and thorough documentation. It is not a data research project; it is a workflow automation and context-engineering pack for an AI terminal agent.
This repository implements a binary- and source-compatible compatibility layer for SDL2 on top of SDL3. It provides the complete SDL2 public headers (under include/SDL2/) and a shared library that intercepts all SDL2 API calls and translates them to the corresponding SDL3 functions. The core implementation resides in src/sdl2_compat.c and src/sdl2_compat.h, which perform type mapping, event conversion, and function dispatch. A sophisticated dynamic API mechanism in src/dynapi/ allows runtime overriding of exported symbols. The project also includes an extensive test suite (under test/) covering every major SDL2 subsystem, a reusable test framework (src/test/), and a comprehensive release automation script (build-scripts/build-release.py). The build system supports CMake, legacy Makefiles, Android NDK, and MSVC across Linux, Windows, macOS, and more. This is a library—not an end-user application—meant to ease the transition from SDL2 to SDL3 without modifying existing SDL2-based programs.
Morphir is a FINOS-hosted toolchain for capturing business logic as a language-agnostic Intermediate Representation (IR). It compiles source code (Elm, Gleam) into a typed IR, supports code generation for multiple backends (OpenAPI, Avro, Python, Rust), evaluates IR expressions, manages packages with TUF-signed metadata, and runs a conformance test kit (MCK) to verify IR adapter implementations. The architecture is a monorepo with a Rust CLI (`morphir`), a web UI server (JSON-RPC over WebSocket), a Docusaurus documentation website, and submodules for language backends. Key entry points include the CLI binary (`crates/morphir/src/main.rs`), the MCK engine (`crates/morphir-mck/src/lib.rs`), and the web UI server (`crates/morphir/src/commands/ui/server.rs`). The system relies on external compilers (Elm, Gleam), WASM extensions, and subprocess adapters for conformance testing. The repository is actively maintained with recent commits, low technical drift, and a well-structured codebase.
This repository is the development branch of the collaborative editing binding between CodeMirror 6 and Yjs, published as the unstable @y/codemirror package targeting Yjs v14 (@y/y). It is a library, not an application: consumers embed it into a CodeMirror editor to synchronize a Y.Text shared type with the editor's document, render remote cursors and selections, and enable shared undo/redo with per-client history. The primary entry point is the yCollab(ytext, awareness, opts) function in src/index.js, which composes three CodeMirror plugins: ySync (bidirectional Y.Text <-> editor sync), yRemoteSelections (awareness-based remote cursor/selection rendering), and yUndoManager (Y.UndoManager integration with selection restoration). A fourth internal state field, yAttributionDecorations, renders Yjs attribution manager data (insert/delete markers) as editor decorations. The architecture is a modular set of CodeMirror 6 extensions communicating through facets and annotations. Local editor transactions are converted to Yjs deltas and applied to Y.Text inside a tagged Yjs transaction; remote Yjs updates are observed and dispatched back into the editor with annotations. Remote selections are transmitted as Yjs relative positions via awareness and rendered as decorations and widget carets. The undo plugin stores selection ranges as YRange (relative positions) on Yjs stack items, allowing selections to be restored after concurrent edits. Code is ESM with JSDoc-based TypeScript checking, rollup for CJS/IIFE builds, and peer dependencies on @codemirror/state, @codemirror/view, @y/y, and @y/protocols. Tests are robust for a collaborative editor library: they use lib0's PRNG-based fuzzing with @y/y/testHelper to apply random multi-editor transactions and assert document convergence. The codebase is generally well-crafted with clean separation of concerns, though it sits on pre-release Yjs v14 APIs, contains a few TODOs, and pins CI to Node 16 with older jsdom — hence moderate technical drift. The stable Yjs v13 line remains the separate y-codemirror.next package; this repo is explicitly experimental.