One API is a production-ready OpenAI API gateway that aggregates 30+ LLM providers (OpenAI, Anthropic, Google Gemini, Azure, Baidu, Alibaba, Zhipu, Moonshot, DeepSeek, Ollama, etc.) behind a single OpenAI-compatible endpoint. The Go backend implements a sophisticated relay system with provider-specific adaptors that translate OpenAI-format requests to each provider's native API. It features token-based quota management with group/channel multipliers, load balancing across channels, automatic failover, channel health monitoring with metric-based auto-disable, and multi-node deployment with Redis synchronization. The React frontend (three themes: default, berry, air) provides admin dashboards for channel/token/user management, billing visualization, and system configuration. The codebase demonstrates strong engineering practices: clean adaptor pattern for provider extensibility, comprehensive middleware chain, batched database updates for performance, and well-structured configuration management.
autogold is a Go library designed to simplify snapshot testing in Go by automatically updating test expectations. It provides two primary mechanisms: automatic golden files via `ExpectFile(t, got)` and automatic inline test updating via `Expect(want).Equal(t, got)`. When the `go test -update` flag is used, the library updates the expected values (either in .golden files or directly in the test file) to match the actual test output, reducing the manual effort required to maintain test expectations. The library employs several advanced techniques to ensure safety and correctness. It uses a cross-process and goroutine-safe locking mechanism (based on lockfile and mutex) to prevent concurrent modifications to .golden files by parallel test processes. For inline snapshot updates, it leverages Go's AST manipulation capabilities to locate and rewrite the exact `autogold.Expect(...)` call in the test file based on callstack information. Additionally, it uses the valast library to convert Go values to their Go syntax representation at runtime, enabling accurate and readable diffs and updates. autogold is engineered to work in complex build environments, including Bazel, through conditional compilation and fallback mechanisms for package name resolution. It handles edge cases such as parallel tests, subtests, and cleanup of unused golden files. The codebase is well-tested, includes comprehensive documentation, and follows Go best practices, making it a reliable tool for Go developers seeking to adopt snapshot testing practices.
ifvisible.js is a modern, dependency-free browser library that provides a clean, event-driven API for detecting page visibility and user activity. It wraps the standard Page Visibility API to surface focus/blur events, and adds an idle-detection system that fires `idle`/`wakeup` events after a configurable period of user inactivity (mouse, keyboard, touch, scroll). Version 3 is a complete rewrite in TypeScript with per-instance event isolation, SSR-safe construction (no DOM access at import time), and support for the Page Lifecycle API (`freeze`/`resume` for bfcache). The library ships as an ESM module, CommonJS, and an IIFE global, with bundled type definitions. It is designed for use in any client-side JavaScript project—SPA frameworks, traditional websites, or even server-side rendering environments (where it becomes a safe no-op). The architecture is simple: a single `IfVisible` class holds an internal `EventEmitter` and a `Timer` class for smart intervals that auto-pause when the user is idle. The codebase is well-structured, thoroughly tested (including an SSR test), and follows modern best practices. It is not a data research project; it is a reusable application library.
WezTerm is a GPU-accelerated cross-platform terminal emulator and multiplexer written in Rust. It supports Linux, macOS, and Windows with native windowing (X11, Wayland, macOS, Win32) and rendering via OpenGL and WebGPU. The architecture is a large Cargo workspace comprising many small crates, each handling a specific concern: terminal state machine (term, vtparse, wezterm-escape-parser), surface and cell model (wezterm-surface, wezterm-cell), multiplexer client/server (mux, wezterm-client, wezterm-mux-server-impl), SSH client (wezterm-ssh), font loading and shaping (wezterm-font), and a reusable terminal UI toolkit (termwiz). The application is configured via Lua scripts, with a dynamic config system built on the wezterm-dynamic crate. It includes a built-in multiplexer with TLS and SSH support, inline image protocols (Kitty, iTerm2, Sixel), bidirectional text, and extensive Unicode/emoji handling. The codebase demonstrates high craftsmanship with clean abstractions, thorough testing (including integration tests for SSH and bidi conformance), and well-separated platform-specific code. Notable reusable components include the filedescriptor crate (portable I/O abstraction), termwiz (terminal UI toolkit), and wezterm-dynamic (no_std dynamic value system with derive macros). Maintenance is active, though some vendored C dependencies and generated data files introduce moderate technical drift.
Foblex Flow is an Angular-native library for building visual node editors, workflow builders, diagram editors, and AI pipeline UIs. It provides a comprehensive set of components and directives (f-flow, f-canvas, f-node, f-connection, f-connector, f-draggable, f-minimap, f-selection-area, etc.) along with plugins for managed state (undo/redo), accessibility (keyboard navigation), layout engines (dagre, elk), reflow-on-resize, and control schemes. The repository is a monorepo (NX) containing the core library, layout packages, a markdown renderer, a documentation portal with SSR, and multiple example applications (call center, schema designer, tournament bracket, UML diagram, marketing automation). The library is production-ready, actively maintained, and demonstrates high craftsmanship with decoupled architecture (mediator pattern), signal-based state management, Web Worker offloading for connection rendering, and extensive E2E testing.
MoviePilot-Frontend is the Vue 3 + Vuetify 3 single-page application frontend for the MoviePilot media management server. It provides a comprehensive UI for managing media libraries, subscriptions, downloads, file organization, plugins, user settings, and system administration. The architecture is a modern SPA with Pinia state management, Vue Router, Axios-based API client, and extensive use of composables for reusable logic. It features a plugin system using Module Federation for remote component loading, PWA support with service worker caching and offline capabilities, and a distinctive glass/transparent theme system with WebGL-based fluid dynamics and ripple effects. The codebase is well-structured with over 120 test files, MSW mock handlers, and a strong emphasis on testability. It is actively maintained with frequent commits and a large community (310 stars, 250 forks).
This repository is an unofficial PyTorch implementation of the Titans architecture from the research paper 'Titans: Learning to Memorize at Test Time'. It provides a library of neural network modules including Neural Memory, Memory-as-Context Transformer, and various attention mechanisms. The codebase consists of modular components that can be used as building blocks for sequence modeling, with training scripts demonstrating language modeling on the enwik8 dataset. The implementation focuses on test-time training mechanisms where the model learns to memorize at inference time through a neural memory module that updates its weights based on incoming sequences.
rb is a Python library for interacting with multiple Redis nodes, providing automatic routing of commands based on keys and broadcasting capabilities. It uses a cluster abstraction to manage connections to individual Redis instances, with routers (partition or consistent hashing) to determine the correct node for key-based operations. The library features a promise-based model for parallel execution, allowing non-blocking I/O via multiplexing (poll/epoll/kqueue) to handle multiple Redis connections efficiently. Key features include automatic batching of compatible commands (e.g., merging multiple GETs into MGET), fault tolerance through reconnection logic, and support for both routed and fanout operations. The codebase is well-structured with clear separation of concerns between cluster management, routing, client interfaces, and utility components.
MMM-GooglePhotos is a MagicMirror² module that displays photos from Google Albums on a smart mirror dashboard. It features a clean architecture separating UI logic (MMM-GooglePhotos.js) from backend processing (node_helper.js), with a well-abstracted Google Photos API client (GPhotos.js). The module handles OAuth2 authentication, automatic token refresh, paginated API requests, photo filtering (by date, dimensions, aspect ratio), sorting, and caching to minimize API calls. It supports user interactions via notifications for navigating photos and uploading new images to designated albums.
Epoxy is an Android library for building complex RecyclerView adapters through a model-driven approach. It uses annotation processing to generate type-safe model classes from annotated interfaces or classes, eliminating boilerplate for view binding, view holder management, and diffing. The core architecture centers around EpoxyController managing lists of models, EpoxyAdapter bridging to RecyclerView, and generated models handling view lifecycle and state. Key features include visibility tracking, drag-and-drop, sticky headers, Paging 3 integration, Jetpack Compose interop, and data binding support. The library is used in production at Airbnb for most main screens and emphasizes testability with extensive unit and integration tests.
IntelOwl is a production-grade, open-source threat intelligence platform that enables security analysts to analyze files and observables (IPs, domains, URLs, hashes) through a modular plugin system. The backend is built with Django 4.2, Django REST Framework, Celery for async task execution, PostgreSQL, Redis, and optional Elasticsearch. The frontend is a React application with real-time WebSocket updates, investigation flow visualization, and a chatbot assistant powered by LangChain and Ollama. The system supports multi-tenancy, organizations, fine-grained permissions, and extensive configuration via environment variables and AWS Secrets Manager. Architecturally, IntelOwl is organized into manager apps (analyzers, connectors, visualizers, pivots, ingestors, playbooks, investigations, data models, user events, chatbot) that each follow a consistent plugin pattern: configuration models, serializers, viewsets, and data migrations that seed the database with plugin definitions. Analyzers can be either Python-based (running in-process) or Docker-based (delegating to sidecar services in the integrations/ directory). The data model manager aggregates analysis results into structured verdicts with evaluation and reliability scores, which feed into engines that produce final classifications. The chatbot agent provides natural-language access to analysis results and can trigger new analyses with user confirmation. The codebase demonstrates strong engineering practices: extensive unit and integration tests (both backend and frontend), CI/CD pipelines, Docker Compose deployment, and a well-defined plugin API. While there is some boilerplate duplication in data migrations and a few hardcoded service URLs, the overall architecture is clean, modular, and extensible. The repository is actively maintained with frequent commits and a large community (4.7k stars, 695 forks).
NeoCodeium is a Neovim plugin that provides AI-powered code completion using the Windsurf (formerly Codeium) service. It features a modular architecture with separate modules for state management, completion logic, rendering, server communication, and utility functions. The plugin integrates with Neovim's autocommands to provide real-time suggestions as virtual text, supports cycling through completions, accepting partial suggestions, and includes a chat interface via the Windsurf service. It is designed to be highly configurable and works alongside other completion plugins like nvim-cmp and blink.cmp.
response-time is a minimal, high-quality Node.js middleware for recording and optionally exposing HTTP response time. It uses `process.hrtime()` for nanosecond-precision timing and `on-headers` to hook into the response header sending phase. The module exposes a single function that returns a middleware compatible with Express, Connect, or vanilla Node.js HTTP servers. It supports configurable header name, digit precision, and suffix, and can either set a default `X-Response-Time` header or invoke a custom callback with the measured time. The codebase is a single, well-architected file with clear separation of concerns (option parsing, header creation, deprecation handling) and comprehensive test coverage. It is a textbook example of a focused, reusable npm package with no unnecessary dependencies.
chasquid is a production-grade SMTP (email) server written in Go, focusing on simplicity, security, and ease of operation. It handles incoming and outgoing email with full support for modern email security standards including STARTTLS, DKIM signing and verification, SPF checking, MTA-STS enforcement, and per-domain security level tracking. The server architecture is modular: the main daemon delegates SMTP protocol handling to the internal/smtpsrv package, manages a persistent email queue via internal/queue, performs alias resolution with hooks via internal/aliases, and delivers mail either locally through an LMTP-based MDA (cmd/mda-lmtp) or remotely via SMTP courier with TLS and MX fallback. Authentication integrates with Dovecot or a local user database using scrypt password hashing. Configuration is defined via protobuf text format, supporting hot reload of domains, users, and aliases without restart. The repository includes CLI tools for administration (chasquid-util), SMTP connectivity checking (smtp-check), and Dovecot authentication testing (dovecot-auth-cli). A comprehensive test suite covers unit, integration, and fuzz tests, with test data for DKIM, SPF, aliases, and various protocol edge cases. The repository also provides a Dockerfile for containerized deployment and extensive documentation in Markdown and man pages. While primarily an application, the codebase contains several well-designed internal packages that could be extracted for reuse, such as the network tracing library, safe I/O utilities, and OpenMetrics exporter.
This is a comprehensive Cookiecutter template for generating production-ready Python projects. It is not a running application itself but a project generator that produces applications, libraries, or services based on user-selected features. The template includes sophisticated post-generation hooks that surgically remove unused files and configure dependencies, Docker Compose services, CI/CD workflows, and documentation based on the chosen options. It enforces modern Python practices: uv for package management, Ruff for linting/formatting, mypy for type checking, pytest for testing, and Pydantic Settings for configuration. The generated projects can include FastAPI, Celery, SQLAlchemy, QuasiQueue, aiocache, Jinja2, Typer CLI, Docker, and GitHub Actions. The template itself demonstrates high craftsmanship with clean Jinja2 templating, conditional logic, and a well-organized file structure. It is actively maintained and uses current tooling (uv, Ruff, etc.), indicating low technical drift.
Mole is a macOS system maintenance CLI tool that provides a unified interface for cleaning caches, uninstalling applications, analyzing disk usage, monitoring system health, and optimizing performance. It combines two Go binaries (cmd/analyze for disk exploration with a Bubble Tea TUI, cmd/status for real-time system metrics) with an extensive shell script library for orchestration and system-level operations. The `mo` command dispatches to subcommands like `clean`, `uninstall`, `analyze`, `status`, `optimize`, `purge`, and `installer`. The architecture is hybrid: Go handles performance-critical tasks (concurrent directory scanning with semaphore-based concurrency, hardlink deduplication, gob-based caching, and interactive TUI rendering) while Bash scripts manage cleanup logic, safety guards (path identity snapshots, whitelists, process guards), Homebrew integration, and sudo session management. Key data flows include disk scanning with progress events and cache invalidation, system metrics collection via gopsutil and macOS commands (system_profiler, ioreg, pmset), and cleanup operations with dry-run previews and bounded timeouts. External dependencies include Homebrew (for cask detection and uninstall), macOS system commands (tmutil, plutil, diskutil, osascript), and Go modules (charmbracelet/bubbletea, lipgloss, gopsutil). The codebase emphasizes safety with fail-closed policies, identity re-verification before deletion, and extensive timeout handling. It supports both interactive TUI and non-interactive JSON output for scripting.
Impress is an enterprise application server for Node.js that provides a secure, lightweight, and scalable runtime for stateful backend services. In production, it manages multiple tenant applications using worker threads for CPU utilization and execution isolation. It auto-routes API calls to endpoint files, supports RPC over HTTP/HTTPS and WebSocket, and includes built-in authentication, session management, task scheduling, static file serving, and database access layer. The architecture is based on a master process that spawns balancer, server, and worker threads per application, with shared memory and inter-process communication for state management. Key entry points include the impress.js master process, which loads applications from .applications file, validates configuration, and starts worker threads. Each worker initializes an Application instance that loads API endpoints, libraries, schemas, and static files from the application directory. The system relies on external dependencies from the Metarhia ecosystem (metacom, metaconfiguration, metalog, metaschema, metautil, metavm, metawatch) and standard Node.js modules. It does not use third-party npm packages for core functionality. Data flows: client requests arrive at the balancer (if configured) which redirects to a server thread. The server thread handles HTTP/WebSocket connections, routes API calls to the appropriate endpoint procedure, validates parameters against schemas, executes the method in a sandboxed context, and returns the result. Static files are served from memory cache with optional compression. Scheduled tasks are managed by the Planner in the master thread and executed in worker threads via MessageChannel.
Mentoss is a utility library for mocking JavaScript fetch() requests and responses in testing environments. It provides three primary classes: MockServer for defining request/response routes, FetchMocker for creating mocked fetch functions that work with one or more MockServers, and MockAgent for undici Dispatcher support in Node.js environments. The library handles complex HTTP features including CORS, credentials, redirects, and various request matching scenarios (URL parameters, headers, body content). The architecture is modular and well-separated, with distinct responsibilities for route matching (request-matcher.js), CORS handling (cors.js), cookie management (cookie-credentials.js), and request/response processing. Each MockServer instance maintains its own route registry and tracks which routes have been called, enabling precise test assertions. The FetchMocker coordinates multiple servers and handles cross-origin requests with proper CORS preflighting and credential attachment. Mentoss is designed for use in test suites where developers need to simulate HTTP interactions without making actual network calls. It supports both browser-like fetch() behavior (with baseUrl and credentials options) and Node.js undici/fetch() usage (via MockAgent). The library includes comprehensive testing helpers to verify which routes were called, assert all routes were exercised, and diagnose mismatched requests through detailed tracing.
Tabbycat is a Django web application for managing debate tournaments, supporting both British Parliamentary and two-team formats. It provides comprehensive tournament management features including draw generation (power-paired, round-robin, elimination, random), adjudicator allocation (Hungarian algorithm, preformed panels), ballot entry and results computation, speaker and team standings, break qualification, check-ins, notifications, and venue management. The system uses a monolith architecture with Django REST Framework for API access, Django Channels for real-time updates (WebSockets), and a Vue.js frontend for interactive drag-and-drop interfaces. It is deployed with PostgreSQL, Redis, and Nginx, and supports Docker and Heroku deployment. The codebase is well-structured with extensive use of mixins, base classes, and design patterns, though it exhibits some tight coupling between apps and a large migration history.
probreg is a Python library designed for robust point cloud registration, implementing a suite of probabilistic algorithms including Coherent Point Drift (CPD), FilterReg, Bayesian CPD (BCPD), and GMMTree. It serves as a specialized tool for computer vision and robotics applications requiring the alignment of 3D point sets under rigid, affine, or non-rigid transformations. The library provides a clean Python API that abstracts complex mathematical operations, allowing users to register point clouds with support for both CPU (OpenMP) and GPU (CuPy) acceleration. Architecturally, the project follows a hybrid model where performance-critical kernels are implemented in C++ and exposed to Python via pybind11. This ensures high computational efficiency for operations like the Kabsch algorithm, point-to-plane distance calculations, and permutohedral lattice filtering. The Python layer manages the orchestration of these kernels, handling data I/O (via Open3D), transformation modeling, and iterative optimization loops. The codebase is well-structured with distinct modules for cost functions, transformations, and specific registration algorithms, promoting modularity and extensibility. The repository demonstrates strong engineering practices with a comprehensive test suite covering core algorithms, CI/CD pipelines for cross-platform builds (Ubuntu/Windows), and Sphinx documentation. It includes example scripts that serve as both documentation and validation for the library's functionality. The inclusion of C++ extensions and dependency on Eigen and pybind11 indicates a mature build system capable of handling complex native compilation requirements. The project is actively maintained with recent commits and a stable versioning strategy.