ReadAny is a cross-platform, local-first AI-powered e-book reader. The pnpm monorepo ships a Tauri 2 + React 19 desktop app, an Expo/React Native mobile app, a Node CLI that exposes an MCP server, a Cloudflare Worker for feedback ingestion, and an Astro docs site — all sharing a single TypeScript core package (@readany/core). The reader renders EPUB, PDF, MOBI, AZW, CBZ, FB2, TXT, and UMD through a vendored Foliate.js fork, and provides highlights, notes, bookmarks, multi-engine TTS (Edge, DashScope, Xiaomi, OpenAI-compatible, system), chapter translation, reading statistics with streaks/badges/goals, and an EPUB draft-editing workflow with undo snapshots and validation. AI features are central: streaming chat grounded in the current reading position, hybrid RAG (sqlite-vec vector search fused with a BM25 inverted index using a CJK-aware tokenizer), local Transformers.js/ONNX embeddings, and a tool-based agent with eight built-in reading skills. Sync is a first-class subsystem using SQLite tombstones, sync_version/last_modified_by columns, and pluggable WebDAV, S3, and LAN backends.
This repository is a production-grade Model Context Protocol (MCP) server that bridges AI assistants to Figma. It exposes 100+ MCP tools for reading and manipulating Figma files, variables, components, styles, FigJam boards, Slides, version history, tokens, and accessibility audits. The architecture is dual-mode: a local Node.js server (`src/local.ts`) communicates over stdio to AI clients and via WebSocket to a bundled Figma Desktop Bridge plugin, while a Cloudflare Workers variant (`src/index.ts`) supports cloud sessions with OAuth and a Durable Object WebSocket relay. The Desktop Bridge is the primary data channel, with Figma REST API fallbacks for scenarios where the plugin is unavailable or limited to certain plans. Beyond basic Figma CRUD, the codebase contains substantial engineering investment in design-token synchronization: canonical DTCG-aligned token documents round-trip through parsers and formatters for CSS variables, Tailwind v3/v4, SCSS, TypeScript modules, Style Dictionary, and Tokens Studio. A separate extraction engine (`src/core/extraction/`) mines production codebases for styling conventions and scaffolds design-system packages, while a scoring engine produces weighted design-system health dashboards. These components give the repo a hybrid quality: it is fundamentally an application, but its token pipeline and codebase-analysis subsystems are data-engineering-like assets that could be reused independently. The codebase demonstrates strong engineering practices: strict Zod schemas, consistent tool registration factories, connector abstraction, extensive Jest test coverage, atomic file writes, adaptive response compression, and careful caching/invalidation. However, it also carries meaningful debt: some token parsers are unimplemented stubs, a few files are monolithic (`figma-tools.ts`, `src/local.ts`), local/cloud connector implementations must be kept in sync manually, and some documentation references outdated internal paths. Overall, this is a mature, feature-rich MCP server with several genuinely reusable components for anyone building design-tool pipelines, token bridges, or local process-lifecycle infrastructure.
INTERCEPT is a self-hosted, open-source web application for signal intelligence (SIGINT) and spectrum monitoring. It provides a unified dashboard to control Software Defined Radios (SDRs) and decode over 20 wireless protocols, including ADS-B (aircraft), AIS (ships), ACARS/VDL2 (airline data), POCSAG/FLEX (pagers), APRS, Bluetooth, WiFi, satellite imagery (SSTV/weather satellites), and drone remote ID. It also features a dedicated Technical Surveillance Counter-Measures (TSCM) suite for detecting hidden devices and Bluetooth trackers. Built as a Flask monolithic application, it orchestrates external SDR tools as subprocesses, parsing their output and streaming decoded data to a real-time web UI via Server-Sent Events (SSE) and WebSockets. The architecture features a clean SDR hardware abstraction layer (Strategy pattern), a centralized event pipeline for alerts and data persistence, and a modular JavaScript frontend with reusable components. It supports distributed operation via remote agents. While primarily an application, it contains significant data engineering components for processing RF data, including signal databases, heuristic engines for Bluetooth tracker detection and WiFi channel analysis, and RSSI-based trilateration algorithms. It is designed for security researchers, radio enthusiasts, and TSCM professionals. The codebase demonstrates high craftsmanship with extensive test coverage (including a novel FakeProcess test utility), clean abstractions, and active maintenance. It is a strong example of a complex, hardware-integrated web application, though its monolithic nature and heavy reliance on specific external tool versions introduce some technical drift risk.
pymupdf4llm is a Python library for converting PDF documents into Markdown, JSON, text, or structured chunks optimized for LLM/RAG ingestion. It is the official PDF-to-Markdown converter for the PyMuPDF ecosystem, delivered as part of the pymupdf package. The system provides two parallel conversion paths: a legacy mode (pymupdf_rag.py) and a layout-aware mode (document_layout.py) that uses a GNN-based page segmentation model (PyMuPDF-Layout) for improved table, header, and list detection. A dedicated chunking subsystem (src/helpers/chunking/) splits documents into retrieval-friendly pieces using layout signals (bounding boxes, font sizes, gaps) without semantic embeddings, and supports export to LangChain Document and LlamaIndex Node objects. OCR support is integrated via multiple backends (Tesseract, RapidOCR, PaddleOCR) with an ONNX-based decision model that classifies pages to determine if OCR is needed. The library also includes a batch converter with automatic worker sizing, a Gradio-based GUI example, and a LlamaIndex reader integration. External dependencies include pymupdf, optional pymupdf-layout for layout mode, tiktoken for token counting, and optional OCR engines. The codebase is modular with clear separation of concerns, comprehensive tests, and active maintenance, though it carries some technical debt from dual code paths and a custom build backend.
This repository is a modular library for loading and using VRM (Virtual Reality Model) avatars within three.js applications. It provides a set of GLTFLoader plugins that parse VRM extension schemas—covering humanoid bone rigging, facial expressions, spring bone physics, node constraints, animation clips, and custom materials (MToon for anime-style rendering, HDR emissive multiplier, and VRM0 compatibility)—and injects runtime objects into the loaded model. The architecture is composed of several packages: a core package handles humanoid, look-at, first-person, and expression systems; separate packages add spring bone physics, node constraints, animation playback, and material extensions. The main entry point is the VRMLoaderPlugin, which composes all sub-plugins. External dependencies are three.js (with version-specific compat shims) and the GLTF loader. The library is designed for browser-based 3D applications, with extensive examples and debug helpers. The codebase demonstrates strong engineering practices: clear separation of concerns via the plugin pattern, dual VRM0/VRM1 support, comprehensive test coverage, and careful management of Three.js API drift. Notable reusable components include a Proxy-based matrix inverse cache, spring bone physics with dependency sorting, constraint graph with circular dependency detection, and a custom MToon material with outline generation and rim lighting. The monorepo structure with typed packages ensures type safety across extensions.
TaskNotes is a mature Obsidian plugin that implements a full task-management system on top of Markdown notes. Each task is a note with YAML frontmatter; the plugin provides natural-language creation, recurring tasks (RRULE), dependencies, projects/contexts/tags, time tracking, Pomodoro, reminders, and custom user fields. It registers custom Bases views — task list, Kanban, calendar, and mini-calendar — and extends the editor with CodeMirror widgets and reading-mode overlays for task links and inline task cards. Architecturally, the plugin is an event-driven TypeScript codebase with a clear service layer: TaskService/TaskUpdateService and VaultMutationService handle file mutations; FieldMapper abstracts frontmatter-field naming; FilterService and TaskManager index and query tasks from the Obsidian metadata cache; OAuthService plus GoogleCalendarService/MicrosoftCalendarService/ICSSubscriptionService manage calendar sync; NaturalLanguageParser converts free text into structured task data. It also exposes an HTTP API built with OpenAPI decorators, an MCP server, webhooks, and CLI commands. All external integrations share the same core services, and many modules use dependency-injection or pure planning functions to stay testable. External dependencies include Obsidian's internal APIs, FullCalendar, chrono-node, rrule, ical.js, YAML, @modelcontextprotocol/sdk, @tasknotes/model, and tasknotes-nlp-core. The repository is heavily issue-driven: there are hundreds of regression tests, a Playwright e2e suite that launches real Obsidian, and a conformance runner pinned to a spec submodule. Maintenance is active, but technical drift is medium: several regression tests are skipped/fixme, some tests assert source/CSS text rather than behavior, there are known version mismatches with @tasknotes/model, and the plugin relies on Obsidian's fast-moving Bases internals.
LinkSheet is an Android application that restores a modern, privacy-oriented URL chooser: it intercepts http/https and related intents, runs the URL through a configurable resolution pipeline, and presents a bottom sheet where users pick an app, browser, or action such as copying or downloading. The core pipeline is implemented in the engine feature module as a series of steps and rules: ClearURLs parameter stripping, embed resolution, FastForward link shortening, LibRedirect frontend substitution, AMP-to-HTML conversion, redirect following, download detection, and preview generation. It also supports user-defined scenarios and expression rules, Shizuku elevation for domain-verification tasks, profile switching, backup/restore, remote configuration, and opt-in Aptabase analytics.
This is an MCP (Model Context Protocol) server implementation that provides LLMs with MySQL database access. The server exposes a single `mysql_query` tool for executing SQL queries and resources for listing tables and column metadata. It supports both stdio and HTTP transport modes, the latter with bearer token authentication. Key features include multi-database mode (querying across schemas without reconnection), schema-specific write permissions (INSERT/UPDATE/DELETE/DDL per database), SSL/TLS with mTLS, Unix socket connections, and a sophisticated PII redaction system that combines column-name heuristics with regex value scanning and Luhn-verified credit card detection. The architecture is monolithic: a single Express server (or stdio process) manages a mysql2 connection pool and routes all MCP protocol requests through zod-validated schemas. The codebase is well-tested with unit, integration, and end-to-end test suites, and demonstrates careful engineering in areas like query parsing (using node-sql-parser), permission enforcement, and secure defaults (write operations disabled by default).
This repository is a VS Code extension that provides an enhanced Markdown preview and editing experience. It supports live preview with scroll sync, math rendering (KaTeX/MathJax), diagrams (Mermaid, PlantUML, D2, etc.), wikilinks, backlinks, graph view, AI translation, code chunk execution, and export to HTML, PDF, and other formats via Pandoc. All rendering is performed locally for privacy, with optional opt-in remote services for PlantUML and image uploading. The architecture is a monolithic VS Code extension with two activation paths: desktop (`src/extension.ts`) and web (`src/extension-web.ts`), sharing common logic in `src/extension-common.ts`. Core rendering is delegated to the `crossnote` library, while the extension provides VS Code integration including preview panels, custom editor, commands, configuration, file watchers, and language features (completion, hover, navigation). The build system uses esbuild and gulp to produce multiple output targets. Key entry points include `src/preview-provider.ts` for preview lifecycle management, `src/notebooks-manager.ts` for workspace note indexing and backlinks, and `src/config.ts` for bridging VS Code settings with crossnote configuration. External dependencies include `crossnote` (rendering engine), `@earendil-works/pi-ai` (AI translation providers), and optional binaries like Pandoc, PlantUML, D2, and Chrome/Puppeteer for export. Data flows center on file changes triggering re-rendering via crossnote, with wikilinks resolved through a note index. AI translation operates incrementally: blocks are split, sent to an LLM API, cached on disk, and streamed into the preview. The extension is highly configurable with over 80 settings and supports localization in 10 languages.
NVRHI (NVIDIA Rendering Hardware Interface) is a C++ library that provides a unified hardware abstraction layer over Direct3D 11, Direct3D 12, and Vulkan 1.3. It is designed for high-performance rendering applications such as game engines and real-time visualization tools. The library exposes a consistent API for GPU resource management (textures, buffers, shaders, samplers), command list recording, pipeline execution (graphics, compute, meshlet, ray tracing), and automatic state tracking with barrier placement. It also includes a validation layer for debugging and correctness checks, and integrates NVIDIA-specific extensions like NVAPI, Aftermath crash dump analysis, and RTXMU memory utility. The architecture is backend-agnostic: common abstractions (resource lifecycle, state tracking, binding layouts) are implemented once and specialized for each backend. Key patterns include reference-counted resource handles (RefCountPtr), automatic barrier insertion based on resource state transitions, a two-phase binding system (BindingLayout → BindingSet), and upload/scratch buffer suballocation with version tracking. The library is distributed as a reusable SDK with CMake build support, shared-library exports, and optional feature toggles for NVAPI, Aftermath, RTXMU, and validation. While primarily an application library, NVRHI includes research-oriented features such as cooperative vector (CoopVec) support for AI/ML workloads, ray tracing acceleration structures (BLAS/TLAS, OMM, LSS), and cluster acceleration structure operations. These components are integrated into the same rendering pipeline abstraction, making the library suitable for both production graphics and experimental compute tasks.
Dire Wolf is a software-defined Terminal Node Controller (TNC) for AX.25 packet radio, primarily serving the APRS (Automatic Packet Reporting System) community. It replaces traditional hardware TNCs by performing all modem and protocol processing in software on a general-purpose computer. The application demodulates audio from a sound card (or SDR/file) using high-performance DSP algorithms for AFSK, PSK, and GMSK modulations, decodes AX.25 frames, and processes APRS data types including position, weather, telemetry, and messages. It functions as a digipeater, IGate (Internet Gateway), APRStt (DTMF) gateway, and KISS TNC, providing multiple interfaces (TCP, serial, pseudo-terminal) for client applications like Xastir and APRSIS32. The codebase is a well-structured monolithic C application with a modular internal architecture, featuring clean abstractions for audio I/O, DSP, protocol framing, and network services. It includes experimental forward error correction modes (FX.25, IL2P) and a comprehensive telemetry toolkit.
ArgoX is a monolithic Bash script that automates the deployment and management of Xray (a proxy) and Cloudflare Argo tunnels on Linux VPS. It supports 12 proxy protocols (VLESS, Hysteria2, Trojan, Shadowsocks, etc.) with various transport and security layers, including Reality, WebSocket, XHTTP, and direct connections. The script handles the full lifecycle: dependency installation, binary download (Xray, cloudflared, jq, qrencode), configuration generation, service management (systemd/OpenRC), firewall rule management (iptables/UFW/firewalld), and client subscription file generation for V2rayN, Clash, Shadowrocket, Sing-box, and Throne. Architecturally, ArgoX is a single-file Bash script with a modular protocol system. It provides an interactive menu, CLI flags, long-parameter support, and a config-file mode for non-interactive/CI/CD deployment. Key features include Argo tunnel integration (temporary or fixed domain via Token/JSON/Cloudflare API), Hysteria2 Realm mode for NAT traversal, WARP outbound routing for ChatGPT unlocking, live traffic statistics via Xray API, and zero-downtime hot-reload for configuration changes. The script is actively maintained with frequent updates tracking upstream Xray and cloudflared releases. The primary data flow involves the user invoking the script, which detects the system, checks dependencies, downloads required binaries, generates inbound and outbound JSON configurations, starts services, and outputs node information and subscription URLs. Configuration changes are applied via Xray API hot-reload or service restart, with automatic firewall rule synchronization. The script is designed for minimal system dependencies, downloading jq and qrencode as static binaries and installing nginx only when needed.
Field Theory CLI is a local-first TypeScript application for managing X/Twitter bookmarks and building personal knowledge bases. It provides a comprehensive CLI interface for syncing bookmarks from Twitter/X (via OAuth API or browser session extraction), classifying content, exporting to markdown with wikilinks, generating interconnected wikis, and enabling agent workflows through skill installation for AI coding agents like Claude Code and Codex. The application features a 'Possible' idea generation pipeline that applies bookmark collections to repositories for innovation planning, with local data storage in ~/.fieldtheory/ using SQLite FTS5 for full-text search. Built with modular architecture separating concerns into bookmarks, ideas, agent context, and document operations modules.
This repository is SAP's official, community-driven collection of coding style guides, focused on ABAP development within the SAP ecosystem. The centerpiece is Clean ABAP (clean-abap/CleanABAP.md), a comprehensive adaptation of Robert C. Martin's Clean Code for the ABAP language, covering naming conventions, language constructs, variables, internal tables, conditions, classes, methods, error handling, comments, formatting, and testing - with each rule paired as good and anti-pattern code examples. A companion guide (abap-code-review/ABAPCodeReview.md) defines a pragmatic, checklist-based ABAP code-review process tied to the Clean ABAP rules. The repo is documentation-only; it is not a runnable application, service, or data pipeline. Its only executable surface is a GitHub Actions workflow (build.yml) that validates markdown links via markdown-link-check, plus an automated issue labeler. Content is organized as a single large primary document (~10,000+ lines) with modular deep-dive sub-sections (clean-abap/sub-sections/), a print-optimized cheat sheet, and full translations into eight languages (English, Chinese, German, Spanish, French, Japanese, Korean, Russian). The project is actively maintained - last commit April 2026, 79 open issues triaged through structured templates (propose new rule, clarification, adjust existing rule) - and uses a formal governance model requiring consensus and quarterly review for significant changes. The guides are opinionated by design and openly acknowledge tensions with legacy code, performance, and official SAP guidelines; enforcement is delegated to companion tools such as abaplint and code pal for ABAP. Primary drift risk is translation lag - several translations are based on English versions from 2019-2022 - and evolution of the ABAP language beyond the NetWeaver releases referenced in the text.
This repository contains CANopenNode, a full-featured, portable ANSI C implementation of the CANopen protocol stack compliant with EN 50325-4 (CiA 301) and related standards (CiA 302, 303, 304, 305, 309). It is designed for embedded microcontrollers and real-time industrial automation systems. The stack implements Network Management (NMT) with heartbeat and node guarding, SDO server/client with expedited/segmented/block transfer, PDO with dynamic mapping, Emergency messages, SYNC, Time-stamp, LSS, Safety-Related Data Objects (SRDO), and an ASCII gateway for remote management (CiA 309-3). The architecture is modular, with each protocol in its own directory (301/, 303/, 304/, 305/, 309/). Central orchestration is provided by `CANopen.c` with a main processing loop `CO_process()` that should be called cyclically. The stack is configuration-driven via compile-time macros in `CO_config.h`, allowing feature enable/disable to reduce footprint. A hardware abstraction layer (`CO_driver.h`) separates CAN bus specifics, and example blank drivers (`CO_driver_blank.c`, `CO_storageBlank.c`) facilitate porting to new platforms. Key design patterns include a generic Object Dictionary interface with extension callbacks, a reusable circular FIFO buffer with protocol parsing, storage abstraction with CRC integrity, and non-blocking state machines. The codebase adheres to MISRA C:2012 (with documented exceptions) and includes Doxygen documentation. While primarily a library, the repository contains an example application skeleton and a generated device profile XML. Technical debt includes the FIFO and gateway modules being excluded from static analysis, certain static variables limiting reentrancy, and the trace feature being non-functional. The project is actively maintained with a large user base and multiple derivative repositories for specific platforms (Linux, STM32, PIC, etc.).
Homer is a production-grade VoIP/SIP telemetry capture, storage, and analytics platform. It ingests HEPv3 packets over UDP/TCP/TLS/HTTP, plus OpenTelemetry traces/metrics/logs and InfluxDB line protocol, decodes SIP and RTCP/VQ-RTCPXR/SIPREC, and stores everything in a DuckDB/DuckLake lakehouse with Parquet files and a SQLite catalog. The system provides tiered hot/cold storage, compaction, retention, time-travel queries, Arrow FlightSQL access for Grafana/BI tools, a REST v4 API, a React dashboard, live WebSocket stream views, a CLI, and a Lua scripting engine for correlation. Although it is fundamentally an operational application, it contains a sophisticated data-lake/ETL layer, so it is hybrid in character; the dominant personality is an application service. The architecture is a modular Go monolith that can run as an all-in-one process or split into writer, node, and coordinator roles via configuration. Ingest listeners feed a zero-copy SIP/HEP decoder into batched DuckLake writers; background compaction and tiering move data across volumes; queries route through an Arrow FlightSQL server or the coordinator's search API. The embedded React/TypeScript UI is extensive, with dashboards, settings, user auth (internal, LDAP, OAuth2), alerting, and even isolated mini-games such as Chess, Tetris, and Doom. External dependencies include DuckDB and its DuckLake extension, S3/Azure object storage, LuaJIT, and optional log shipping to Loki/Elasticsearch. The codebase is well-tested and modular, with several genuinely reusable components such as a zero-copy SIP parser, a generic Go-Lua bridge, a pub/sub broker, and a CIDR-trie alias map. However, there is meaningful technical debt: hand-rolled SQL string interpolation, some duplicate CRUD patterns, a few known failing/skipped tests, pinned DuckDB extension versions, and scope creep from dashboard games. The project is actively developed and the drift is manageable rather than severe.
NanoSVG is a C library for parsing and rasterizing SVG files. It consists of two single-header files: nanosvg.h for parsing SVG into cubic bezier paths, and nanosvgrast.h for rasterizing those paths into RGBA pixel data. The library handles a wide range of SVG features including basic shapes (rect, circle, ellipse, line, polyline, polygon, path), fills, strokes, linear and radial gradients, and transformations. Designed for ease of use in applications and games, it requires only standard C libraries and can be integrated by simply copying the header files and defining the appropriate implementation macros. The parser (nanosvg.h) reads SVG files through a custom XML parser and converts them into a structured representation of bezier paths. It properly handles SVG coordinate systems, viewBox transformations, and unit conversions (px, pt, pc, mm, cm, in). The rasterizer (nanosvgrast.h) then takes this path data and converts it to a pixel buffer using a scanline rasterization algorithm with anti-aliasing. Together, these components provide a complete solution for rendering SVG content in applications that need vector graphics support without heavy dependencies. While the README notes the project is not actively maintained, the library continues to be widely used due to its simplicity, reliability, and permissive zlib license. Its single-header design makes it particularly suitable for embedding in projects where minimizing dependencies is important, such as game development or desktop applications.
async-openai is an unofficial, async Rust client library for the OpenAI API, covering nearly all endpoints including chat completions, responses, audio, images, embeddings, fine-tuning, vector stores, batches, realtime, administration, and more. It is designed with a modular architecture where each API family is a separate module behind feature flags, allowing users to compile only what they need. The library provides ergonomic builder patterns for request construction, comprehensive streaming support via SSE and WebSocket, and a middleware stack based on the Tower ecosystem for custom retry policies, concurrency limiting, and logging. Key entry points include the `Client` struct (constructed via `Client::new()` or `Client::with_config()`) and per-API group methods like `.chat()`, `.responses()`, `.audio()`, etc. Data flows are straightforward: requests are built using typed builders, serialized to JSON (or multipart for file uploads), sent via `reqwest` to the OpenAI API, and responses are deserialized into strongly-typed structs. The library also supports Bring Your Own Types (BYOT) via a proc-macro, Azure OpenAI, Ollama, Gemini compatibility, and WebAssembly targets (Dioxus). External dependencies include `reqwest`, `tokio`, `serde`, `tower`, `tungstenite`, and `utoipa` for optional OpenAPI schema generation.
bsnes is a multi-platform Super Nintendo (SNES) emulator with high accuracy, also incorporating a Game Boy emulator (SameBoy). The codebase is structured as a modular application with a core emulation engine (bsnes/sfc/ for SNES, bsnes/gb/ for Game Boy), a cross-platform GUI toolkit (hiro), a multimedia abstraction layer (ruby), a utility library (nall), and a coroutine library (libco). The emulator supports save states, movie recording, cheat codes, shader effects, and multiple input/output backends. It can be built as a standalone desktop application or as a libretro core. The architecture emphasizes cycle-accurate emulation of SNES coprocessors and hardware components, with extensive serialization for deterministic state saving. External dependencies include platform-specific GUI toolkits (GTK, Qt, Cocoa, Windows native), audio/video drivers (ALSA, PulseAudio, OpenGL, etc.), and vendored libraries (LZMA, SameBoy). The primary data flow involves loading ROM files, heuristic detection, cartridge parsing, and then running the emulation loop (CPU, PPU, DSP, coprocessors) while handling user input and rendering audio/video output.
This is a high-performance SVG rendering library for Node.js, Deno, Bun, and browsers, powered by the Rust `resvg` engine. It converts SVG to PNG/AVIF with support for cropping, scaling, background colors, custom fonts (including WOFF2), bounding box extraction, and simplified SVG output. The library is implemented as a native addon via `napi-rs` for optimal speed on server-side runtimes, and also ships a WebAssembly build for browsers and edge environments. The codebase is well-structured, with clean separation between Rust core (rendering, option handling, font management) and JavaScript/TypeScript bindings. It includes comprehensive test suites, cross-platform CI/CD with prebuilt binaries for 18+ platforms, and thorough examples. The architecture demonstrates high craftsmanship in memory management (ObjectFinalize), error handling (panic catching), and pattern reuse (shared crop logic between NAPI and WASM).