MCP-UI is a monorepo SDK implementing the MCP Apps standard for rendering interactive UIs over the Model Context Protocol. It provides server-side tools (in TypeScript, Python, and Ruby) to create UI resources, and a client-side React SDK to render them in sandboxed iframes. The architecture centers on a secure double-iframe proxy pattern that isolates third-party HTML and external URLs, with JSON-RPC communication via AppBridge. The codebase is well-structured with comprehensive tests, semantic release automation, and cloudflare workers example, demonstrating strong engineering practices across multiple languages.
Finicky is a macOS application that acts as a smart default browser handler. It intercepts URL open requests from the operating system and routes them to different browsers based on user-defined rules written in JavaScript or TypeScript, or via a simpler JSON rules file. The application is built as a hybrid of Go (using a custom Go-like language with Objective-C interop) and a Svelte-based web UI embedded via WKWebView. It includes a JavaScript virtual machine (goja) to evaluate user configuration scripts, supports URL rewriting, short URL resolution, browser profile detection, and provides a graphical configuration and testing interface. The codebase is well-structured with separate packages for the config API (TypeScript, compiled to JS), the UI (Svelte), and the core macOS app (Go/Objective-C). It demonstrates strong engineering practices including caching, debouncing, and comprehensive testing.
`gau` (getallurls) is a high-performance Go CLI tool that aggregates known URLs for a given domain from multiple public web archives: Wayback Machine, CommonCrawl, AlienVault OTX, and URLScan. It is designed primarily for security researchers and penetration testers to enumerate URL endpoints, supporting concurrent fetches, filtering by status code/mime-type/date, blacklisting extensions, and deduplication of parameters. The architecture follows a clean provider interface pattern, with each data source implemented as a separate package satisfying a common `Provider` interface. The runner orchestrates a worker pool for concurrent processing, and output is handled via configurable JSON or plain text writers. The codebase is well-structured, testable in principle (though no tests are present in the visible tree), and the dependency graph is minimal and modern, relying on `fasthttp` for efficient HTTP requests and `viper` for configuration management.
fastllm is a high-performance LLM inference engine written in C++ with CUDA/CPU backends, designed for local and server deployment of large language models. In production, it loads models from HuggingFace, GGUF, and custom formats, then executes inference with advanced features: quantization (FP8, INT4, NVFP4, GGUF), speculative decoding, multi-token prediction (MTP), Mixture-of-Experts (MoE), paged KV cache, tensor parallelism, NUMA-aware execution, and disk offloading. It serves models through multiple interfaces: a C++ CLI, a Python CLI (ftllm), an OpenAI-compatible HTTP API server (Chat Completions, Responses, Anthropic Messages), a WebUI, a desktop launcher with agent integrations (DeepSeek Harness, OpenCode, Codex, Claude Code), and an Android app. The system also includes model conversion/export tools, a launcher with hardware auto-recommendation, and a plugin system for UI customization.
This repository is an OBS Studio plugin that enables simultaneous streaming to multiple RTMP (and SRT/RIST, WHIP) destinations from a single OBS session. It provides a dockable Qt-based user interface where users can configure an arbitrary number of streaming targets, each with independent encoder settings (video and audio) or the option to reuse the current OBS streaming/recording encoder. The plugin manages per-target start/stop, bulk start/stop, and can synchronize with OBS's built-in streaming start/stop events. The architecture is a standard OBS plugin: it registers a dock via the obs-frontend-api, creates a main widget (MultiOutputWidget) that hosts a scrollable list of target cards (PushWidgetImpl), and provides an editor dialog (EditOutputWidgetImpl) for adding/modifying targets. Configurations are persisted in a JSON file (obs-multi-rtmp.json) within the OBS profile directory, with support for export/import. The build system uses CMake with platform-specific presets and GitHub Actions for CI/CD across Windows, macOS, and Linux, including Flatpak packaging. Key strengths include a reusable JSON utility (json-util.hpp), a generic OBS properties widget (obs-properties-widget) that can render any obs_properties tree with two-way data binding, and an RAII scope guard (Finally) in helpers.h. The code demonstrates solid C++ practices, cross-platform awareness, and careful handling of encoder sharing to avoid resource conflicts. However, the plugin is tightly coupled to OBS internals, has no automated tests, and some source files exceed 500 lines mixing UI and business logic.
Smol is a lightweight async runtime for Rust that bundles several well-known subcrates (async-executor, async-io, async-net, async-fs, async-process, async-channel, async-lock, blocking, futures-lite) into a single convenient dependency. It provides a global executor initialized lazily with configurable thread count via the SMOL_THREADS environment variable, and exposes a simple API (smol::spawn, smol::block_on, smol::Async, smol::Timer, smol::Unblock, etc.) for writing async programs. The source code itself is thin—primarily re-exports from subcrates plus a spawn module that sets up the global executor. This makes smol an excellent entry point for Rust async development without the complexity of larger runtimes like tokio. The repository includes a rich set of examples covering TCP, TLS, HTTP, WebSocket, file I/O, process management, and platform-specific features like inotify and timerfd. The codebase is well-maintained, uses modern Rust practices (edition 2021, MSRV 1.85, no unsafe), and has active CI and dependabot configuration.
Text Embeddings Inference (TEI) is a production-grade inference server for open-source text embedding models, built in Rust with multiple backend implementations (Candle, Python, ONNX). The system exposes both HTTP (REST) and gRPC APIs supporting dense and sparse embeddings, reranking, sequence classification, and OpenAI-compatible endpoints. It features dynamic batching with cumulative sequence length management, flash attention optimization across CUDA compute capabilities, and comprehensive observability with Prometheus metrics and OpenTelemetry tracing. The architecture cleanly separates the router layer (HTTP/gRPC handling) from the core inference pipeline (tokenization, batching, backend dispatch) via the `Backend` trait, allowing seamless integration of different model backends and hardware targets including CPU, CUDA, ROCm, Intel, and ARM64. The codebase demonstrates strong engineering practices: modular neural network layer implementations (Linear, LayerNorm, RMSNorm, Rotary) reused across model architectures, snapshot-based regression testing for all supported models, and feature-gated builds for precise dependency control. The router provides production features such as CORS, API key authentication, request size limits, health checks, and graceful shutdown. The batching system (`Queue` struct) efficiently accumulates requests and dispatches them to the backend in configurable token-bucket sizes. While the engineering quality is high, the repository exhibits some maintenance risks: significant model duplication across `flash_` and non-flash variants for each architecture, patched upstream dependencies (candle, cudarc) that may diverge from official releases, and commented-out integration tests. The Python backend, wrapping a subprocess, introduces platform-dependent fragility, and the large number of hardware-specific Dockerfiles increases build complexity. Overall, TEI is a well-architected, actively maintained inference server suitable for production deployments, with reusable patterns in its backend abstraction, batch processing, and layer implementations.
Expensify/App is the primary mobile application for Expensify, a corporate expense management platform. It is a cross-platform React Native app (iOS, Android, Web) built with React 19, React Native 0.86, and Expo 57. The app provides a full suite of expense management features: receipt scanning, multi-currency expense reporting, corporate card integration, reimbursement (ACH, global), workspace/policy administration, approval workflows, and accounting integrations (NetSuite, QuickBooks, Xero, Sage Intacct, etc.). The architecture is a typical React Native monolith with a reactive state management layer (react-native-onyx) for offline-first behavior, custom navigation (split/stack/tab), and a rich component library. It includes server-side chart rendering for PDF reports and extensive telemetry via Sentry and FullStory. The codebase is well-structured with platform-specific files, thorough TypeScript typing, and a comprehensive test suite. It is a mature, actively developed application with a large team and community.
Arduino-IRremote is a comprehensive Arduino library for sending and receiving infrared remote control signals. It supports over 20 standard IR protocols (NEC, Sony, RC5, Samsung, LG, etc.) as well as exotic protocols like Bose Wave and Bang & Olufsen. The library is designed for embedded systems, handling the low-level timing generation and decoding required for IR communication. It provides both a full-featured receiver with a 50µs timer interrupt and a lightweight interrupt-based receiver (TinyIRReceiver) for resource-constrained boards. The sender uses software or hardware PWM to generate the 38kHz carrier, with bit-bang fallback for boards without PWM timers. Key entry points are the main include header (IRremote.hpp), static objects IrReceiver and IrSender, and a command dispatcher for mapping IR codes to callback functions.
MonkeyType is a Python library and CLI tool that collects runtime types of function arguments and return values using Python's sys.setprofile hook. It stores these call traces (default SQLite) and can generate PEP 484 stub files or directly apply type annotations to source code via libcst. The architecture separates tracing (CallTracer), storage (CallTraceStore interface with SQLite implementation), stub generation (FunctionDefinition, ModuleStub), and application (libcst-based code transformation). It provides a configurable plugin system (Config/DefaultConfig) for customizing trace storage, code filtering, sampling, and type rewriting. The type rewriting subsystem includes a GenericTypeRewriter visitor pattern and several built-in rewriters (RemoveEmptyContainers, RewriteConfigDict, RewriteLargeUnion, RewriteMostSpecificCommonBase, RewriteGenerator) that refine raw union types into more idiomatic annotations. The project is well-tested with a comprehensive test suite and has been used in production at Instagram.
Simple.css is a classless CSS framework that provides an instant, clean design for any HTML page. The entire repository consists of a single well-crafted CSS file (simple.css) that styles all standard HTML elements—headings, paragraphs, lists, tables, forms, navigation, blockquotes, code blocks—without requiring any CSS classes. It uses CSS custom properties for theming, supports both light and dark modes via the `prefers-color-scheme` media query, employs a responsive CSS Grid layout, and includes accessibility features like focus-visible outlines and proper contrast. The repo also includes a minified version, an older v1 for backward compatibility, and a comprehensive HTML test page to demonstrate all styled elements. It is a self-contained, drop-in solution for quickly improving the appearance of any website or prototype, with no external dependencies.
tfenv is a command-line Terraform version manager written in Bash, modelled after rbenv. It provides a `terraform` shim that intercepts invocations and selects the appropriate Terraform binary based on a `.terraform-version` file, the `TFENV_TERRAFORM_VERSION` environment variable, or the default version file under `TFENV_CONFIG_DIR`. The repository implements full version lifecycle operations: install (download, verify SHA256 and optional PGP signatures, unzip), switch (`use`), uninstall (including multiple versions), list local and remote versions, pin current version, and a `min-required`/`latest-allowed` resolver that reads `required_version` constraints from `.tf` files. Architecturally it follows the rbenv pattern: a dispatcher (`bin/tfenv`), a shim (`bin/terraform`), shared libraries in `lib/` (logging, version-file discovery, version-name resolution, execution), and standalone subcommand scripts in `libexec/` that each include boilerplate to resolve `TFENV_ROOT`. The code deliberately avoids shellcheck and additional dependencies, maintaining portability across Linux, macOS, and Windows (git-bash). An extensive integration test suite downloads real Terraform binaries, and CI covers a broad OS matrix plus Docker validation. The codebase demonstrates solid engineering practice for a Bash project: clean separation of concerns, a capable logging library (`lib/bashlog.sh`) that supports file, JSON, syslog and coloured console output; careful handling of cross-platform differences (BSD vs GNU grep, CRLF line endings, ARM architecture detection); and a concurrency-safe install lock using atomic `mkdir`. Notable weaknesses are intentional boilerplate duplication across `libexec/` scripts, a test runner that historically exits 0 on failure (documented as a known bug being fixed), and regex-based HCL constraint parsing that is functional but fragile. A proposed ADR outlines a future Go edition, but the Bash implementation remains canonical.
Joda-Time is a mature, comprehensive Java library for date and time manipulation, offering a rich set of immutable and thread-safe classes for instants, partials, intervals, periods, durations, and time zones. It supports multiple calendar systems (ISO, Gregorian, Julian, Buddhist, Coptic, Ethiopic, Islamic, GJ) and provides extensive formatting and parsing facilities, including ISO 8601 and locale-aware period formatting. The library is designed for production use, with a clean interface hierarchy (Readable* and ReadWritable*), a pluggable chronology architecture, a converter pattern for flexible object construction, and a field system that allows modular arithmetic. Despite being 'largely finished' since Java 8's java.time (JSR-310), Joda-Time remains a high-craftsmanship codebase demonstrating immutable value objects, abstract base classes, builder patterns, and internationalization support. Its design influenced java.time, and many components (e.g., the converter set, chronology assembly, type-safe period classes) are reusable patterns for any domain with complex temporal logic.
This is a Go client library for the Slack API, providing comprehensive coverage of Slack's REST API, Real-Time Messaging (RTM) over WebSocket, Socket Mode for event-driven interactions, and the Block Kit for rich interactive messages. It enables developers to build Slack apps, bots, and integrations with full access to Slack's platform features including messaging, files, admin functions, workflows, and more. The library is organized into several packages: `slack` (main client with all API methods), `socketmode` (WebSocket client for Socket Mode), `slackevents` (Events API parsing), `slacktest` (mock server for testing), and `internal` (backoff, error handling). It uses a functional options pattern for API calls, context propagation for cancellation, and a pluggable retry system. The Block Kit is implemented with builder patterns and custom JSON serialization for type-safe block construction. Key entry points include `slack.New(token)` to create a client, `socketmode.NewClient` for WebSocket connections, and `slackevents.ParseEvent` for Events API payloads. The library handles authentication, rate limiting, pagination, and error responses. External dependencies are minimal, relying primarily on the Go standard library and a WebSocket library for real-time communication.
This repository provides client-side integrations, tooling, and examples for Zep, a long-term memory platform for AI agents built on temporal knowledge graphs. It is not the Zep service itself but the ecosystem to use it. The codebase includes SDK packages for over a dozen AI agent frameworks (Google ADK, AutoGen, CrewAI, LangGraph, Pydantic AI, LiveKit, Mastra, Vercel AI SDK, Microsoft Agent Framework, Strands, AG2) in Python, TypeScript, and Go. Each integration follows a consistent pattern: out-of-band provisioning of users and threads (server-generated UUIDs), automatic context injection before each LLM call, and on-demand graph search tools. The repository also contains a standalone ingestion pipeline (zep-ingest) for bulk-loading historical data (Slack exports, emails, documents, transcripts) into Zep graphs, a Model Context Protocol (MCP) server exposing Zep graph tools, benchmarks (LoCoMo, LongMemEval) for evaluating long-term memory retrieval, and an evaluation harness for testing retrieval and question-answering accuracy. While primarily an application-focused repository, it includes data pipeline components and evaluation frameworks that give it a hybrid character.
MCA Selector is a desktop application (JavaFX) for viewing, filtering, editing, exporting, and importing chunks from Minecraft Java Edition world saves (.mca files). It provides a tile map interface where users can select chunks based on various criteria (biome, block, entity, status, etc.), modify chunk data (change fields, replace blocks, edit NBT), export selections as images or .mca files, and import chunks from other worlds. The application supports a wide range of Minecraft versions (1.9 through 26) through version-specific implementations for chunk filtering, rendering, and color mapping. It includes both a full GUI mode and a CLI mode for batch operations. The architecture is modular, with separate packages for filtering, data modification, overlays, I/O, configuration, and UI components. It uses a job-based parallel processing system for efficient I/O and computation. The codebase is well-structured and demonstrates solid software engineering practices, though there is some duplication across version-specific implementations.
easyjson is a Go library and code generator that produces specialized, reflection-free JSON marshal/unmarshal code for Go structs. It achieves 4–5× faster serialization than the standard `encoding/json` by generating type-specific encoder/decoder functions at compile time. The architecture consists of a CLI tool (`easyjson/main.go`) that parses Go source files, extracts struct annotations (`//easyjson:json`), and generates `_easyjson.go` files implementing `easyjson.Marshaler`/`Unmarshaler` interfaces. The runtime library provides a fast JSON lexer (`jlexer`), writer (`jwriter`), buffer pool (`buffer`), optional types (`opt`), and helpers for unknown fields, string interning, and zero-copy parsing. The project includes extensive benchmarks comparing against ffjson, jsoniter, and go/codec, and a comprehensive test suite covering edge cases like omitempty, snake_case, embedded types, and custom key types.
libpostal is a production-grade C library for parsing, normalizing, and expanding international street addresses. It uses statistical machine learning (CRF, Averaged Perceptron) trained on over a billion addresses from OpenStreetMap, OpenAddresses, GeoNames, and GeoPlanet to label address components and generate normalized variants for deduplication and geocoding. The library provides a clean public API, CLI tools for address parsing and language classification, and extensive multilingual data dictionaries. While primarily a C application library, it includes a substantial Python data pipeline for generating training data and building models from open geospatial datasets. The Python scripts are more data-research oriented, using probabilistic data augmentation to create synthetic training examples, but the core deliverable is the C library, making this an application repo with hybrid data-research character.
AnonAddy (addy.io) is a self-hosted anonymous email forwarding service built with Laravel, Inertia.js, and Vue 3. In production, it allows users to create email aliases that forward to real inboxes, with support for custom domains, PGP/MIME encryption, user-defined rules (sender/subject/header conditions with actions like block, quarantine, label), and a blocklist. The system receives inbound email via a Postfix pipe, applies rules, and either forwards, replies, or sends-from aliases with rewritten headers, List-Unsubscribe banners, and optional DKIM signing. Outbound sending handles VERP bounce tracking and stores failed deliveries with deduplication. The architecture is a monolith Laravel application with a REST JSON API (used by mobile/extension clients) and a server-driven SPA frontend. Key entry points include the ReceiveEmail console command, the CustomMailer driver, and numerous API controllers under /api/v1/. The frontend uses reusable Vue components and Inertia form handling across pages for alias, recipient, domain, rule, blocklist, and settings management.
LiteFS is a FUSE-based distributed filesystem for replicating SQLite databases across a cluster of machines. It operates as a Linux daemon that intercepts SQLite's file-level operations (journal, WAL, SHM) to capture every transaction. These transactions are recorded in a custom LTX (Lite Transaction) binary format and streamed to replica nodes via an HTTP/2 h2c protocol. The system uses leader election (via Consul or a static configuration) to designate a primary node that accepts writes, while replicas synchronously apply changes and enforce read-after-write consistency via TXID cookies and a proxy layer. The architecture is fundamentally a thin FUSE layer wrapping a distributed state machine: each node runs a store that manages multiple databases, tracks guards for SQLite lock compatibility (PENDING, SHARED, etc.), and exposes an HTTP API for streaming replication, manual imports/exports, handoff, and backup integration. The proxy server sits in front of the application to route read requests to the primary or a sufficiently caught-up replica, using Fly-Replay headers for transparent redirect. Backup is supported through either a file-based mechanism or the LiteFS Cloud client. External dependencies include Consul (for leader election), FUSE (required on Linux), and the underlying SQLite library (no cgo, pure Go via the ltxx package). The codebase is written in Go, with a heavy focus on correctness under concurrency—evidenced by extensive integration tests that exercise split-brain recovery, checkpoint races, and multi-node handoff. The project is in beta and follows a roadmap-driven contribution model where the maintainer rewrites feature PRs to ensure consistency.