Locust is an open-source, developer-friendly load testing framework written in Python. It allows users to define test scenarios as regular Python code using `User` classes with `@task` decorators and configurable wait times. The system supports HTTP and other protocols via built-in clients (HttpUser, FastHttpUser) and extensible contrib modules (MQTT, gRPC, Postgres, etc.). It provides a real-time web UI built with React/Redux/MUI for controlling tests and viewing statistics, a headless CLI mode for CI/CD integration, and a distributed architecture using ZMQ for master/worker coordination. The framework collects detailed per-request metrics (response times, percentiles, error rates) and can export CSV, HTML, and JSON reports. It also integrates with OpenTelemetry for observability. The codebase is well-structured with a clean event-driven architecture, extensive test coverage, and a plugin system for custom extensions.
Apache Airflow is a workflow orchestration platform for authoring, scheduling, and monitoring data pipelines. The system uses a modular architecture with core components, extensible providers, a React/TypeScript web UI, and a FastAPI-based REST API. Key entry points include the CLI (`airflow` command), web server, scheduler, and triggerer. Data flows involve DAG parsing, task scheduling via executors, and state persistence in a metadata database. External dependencies include PostgreSQL/MySQL, Redis/RabbitMQ for Celery, and various provider-specific integrations. The codebase demonstrates strong engineering practices with version compatibility patterns, plugin systems, and well-structured API layers.
Radicale is a production-grade CalDAV/CardDAV server written in Python, providing calendar and contact synchronization over WebDAV. It operates as a standalone HTTP server (with optional WSGI compatibility) and includes a built-in web UI for managing collections, sharing, and user settings. The architecture is highly modular, with pluggable backends for authentication (htpasswd, LDAP, IMAP, OAuth2, PAM, etc.), storage (multifilesystem with caching and locking), authorization (owner-only, file-based rules), sharing (token-based, map-based, group/realm), and hooks (email, RabbitMQ). The server handles the full CalDAV/CardDAV protocol suite, including PROPFIND, REPORT, PUT, DELETE, MKCALENDAR, MKCOL, MOVE, PROPPATCH, and sync-collection, with support for recurring events, timezone handling, and free-busy queries. Key entry points include the CLI runner (`radicale/__main__.py`), the WSGI application factory (`radicale/__init__.py`), and the configuration system (`radicale/config.py`). Data flows from HTTP requests through the application layer (mixin-based HTTP method handlers) to the storage backend, which persists data as iCalendar (.ics) and vCard (.vcf) files on the filesystem. The sharing subsystem adds a REST API (`/.sharing/v1/`) for managing shares, property overlays, and on-the-fly conversions (e.g., VCF→ICS for birthdays). External dependencies include the `vobject` library for iCalendar/vCard parsing, and optional packages for LDAP, IMAP, PAM, RabbitMQ, and bcrypt/argon2 password hashing. The codebase demonstrates strong engineering practices: comprehensive test suites (unit, integration with Playwright, CalDAV compatibility), extensive CI/CD (Python 3.9–3.14, PyPy, multiple filesystems), and a well-documented plugin system. It is actively maintained with frequent releases and a responsive issue tracker. The modular design and clean separation of concerns make it a solid reference for building extensible server applications.
Gradio is a full-stack Python library and web framework for rapidly creating interactive web UIs for machine learning models, APIs, or any Python function. It provides a high-level Interface class for simple demos, a flexible Blocks API for custom layouts and event-driven apps, and a ChatInterface for chatbot applications. The backend is built on FastAPI and Uvicorn, serving both a REST API and WebSocket-based streaming. The frontend is a Svelte 5 / TypeScript application with per-component packages, a SvelteKit SSR app, and a standalone SPA that can be embedded via a custom HTML element. The library includes a rich component library (30+ input/output widgets), layout primitives (Row, Column, Tabs, Accordion, Sidebar), theming support, internationalization, and a CLI for development, deployment, and custom component creation. It also provides official Python and JavaScript client libraries for programmatic access to Gradio apps, and supports MCP (Model Context Protocol) for tool/resource integration. The repository contains over 100 runnable demos covering a wide range of ML use cases (image classification, text generation, speech recognition, object detection, chatbots, etc.), many of which integrate with Hugging Face models and datasets. While primarily an application framework, the extensive demo collection and focus on ML model visualization give it a secondary data/research character.
Sunshine is a self-hosted, cross-platform game streaming server that implements the NVIDIA GameStream protocol, enabling remote play via Moonlight clients. It captures the host's display (using platform-specific backends such as DXGI, Wayland, X11, KMS, or PipeWire), encodes video with hardware acceleration (NVENC, VAAPI, Vulkan, AMF, QuickSync, or software), and forwards input (keyboard, mouse, gamepad, touch) from the client to the host. The server also provides a web-based configuration UI, handles client pairing with X.509 certificates and AES encryption, and manages streaming sessions via RTSP. It supports HDR, surround audio, gamepad feedback, and network QoS. Architecturally, Sunshine is a monolithic C++ application with a modular platform abstraction layer. The core components include an HTTP/HTTPS server for pairing and configuration, an RTSP server for session setup, and UDP broadcast threads for video, audio, and control data. The codebase is heavily optimized for low-latency streaming, featuring thread-safe queues, a generic task pool, and RAII resource management. It integrates with Boost, FFmpeg, libcurl, and various hardware encoder SDKs, and is packaged for Windows, Linux, macOS, and FreeBSD via multiple distribution channels. The repository demonstrates strong engineering practices with extensive unit and integration tests, consistent coding style, and active maintenance. While some files are large and platform-specific, the core utility modules are cleanly separated and reusable. The project is not a data/research repository; it is a production-grade application for game streaming enthusiasts and developers.
hledger is a cross-platform plain text accounting application that provides three user interfaces: a command-line tool (hledger), a terminal UI (hledger-ui), and a web UI (hledger-web). It implements double-entry bookkeeping with support for multiple currencies, investment lot tracking, budgeting, forecasting, and CSV import. Users maintain their financial data in human-readable journal files, and hledger generates reports such as balance sheets, income statements, cash flow, and transaction registers. The project is structured as a Haskell monolith with four packages: hledger-lib (core library for parsing, data models, reporting, and output), hledger (CLI with 30+ commands), hledger-ui (terminal interface using brick/vty), and hledger-web (web interface using Yesod). The core library handles reading multiple input formats (journal, CSV, timedot, timeclock), applying queries and filters, and writing reports in text, CSV, JSON, HTML, and ODS formats. The CSV import system uses a declarative rules engine for mapping external data to journal entries. The codebase demonstrates high craftsmanship with clean abstractions, extensive test coverage (unit tests, shell tests, browser-based Playwright tests), and active maintenance with CI/CD across Linux, macOS, and Windows. It has comprehensive documentation, internationalization support, and a well-defined contribution process. While the project has some technical drift (vendored old web dependencies, multiple build systems), it remains a robust and well-engineered application with several reusable components that could be extracted for other projects.
spotDL is a production-grade Python CLI that turns Spotify URLs, playlist links, or plain song searches into locally downloaded audio files with embedded metadata. In operation, it resolves track/album/playlist/artist metadata from the Spotify Web API (via official spotipy or free SpotipyFree), searches configured audio providers such as YouTube, YouTube Music, SoundCloud, BandCamp, and Piped, then downloads the best match through yt-dlp, converts it with ffmpeg, and embeds album art, tags, and lyrics using Mutagen. Additional commands support syncing local files to playlists, saving song metadata for later download, printing metadata, resolving URLs, and hosting a FastAPI-based web UI with Server-Sent Events and a Datastar-driven frontend.
Hermes Studio is a self-hosted AI agent orchestration platform providing a unified interface for multiple AI agents (Hermes, Ekko, Claude Code, Codex, Pi) with chat, workflow automation, agent management, and skill-based extensibility. The architecture features a Vue 3 frontend, Node.js/Koa backend, Electron desktop client, and hybrid TypeScript/Python agent runtime. Key capabilities include real-time collaboration via Socket.IO, voice processing with multiple STT/TTS providers, file management with preview capabilities, usage analytics, and Model Context Protocol (MCP) integration for extending agent tools. The platform supports social messaging integrations (Feishu, Telegram, Weixin) and MCU device support for embedded voice processing.
Mailpit is an email testing tool that functions as an SMTP server with a web interface and API for inspecting and testing emails. The architecture is a monolithic Go application that includes an SMTP server (port 1025), POP3 server (port 1110), HTTP server for web UI and API (port 8025), WebSocket server for real-time updates, and an embedded Vue.js frontend. Key entry points are main.go (application entry), cmd/* (CLI commands), and sendmail/main.go (sendmail replacement). Primary data flows involve email ingestion via SMTP/storage, parsing with enmime, storage in SQLite/rqlite, indexing for search/tagging, and retrieval via HTTP/WebSocket for UI/API consumption. External dependencies include Go modules (enmime, sqlf, goquery, etc.) and npm packages (Vue.js, Bootstrap, axios) for the frontend.
VictoriaLogs is a high-performance, lightweight log management system designed for both small and large-scale deployments. It consists of multiple Go-based services for log ingestion (vlagent, vlinsert), storage (vlstorage), and querying (vlselect), complemented by a Preact/TypeScript web UI (vmui). The system uses a columnar storage approach with bloom filters, custom encoding, and a pipeline-based query engine (LogsQL) for efficient log processing. Key architectural patterns include composable data transformation pipes, extensible filter systems, mergeable statistical aggregations, and object pooling for performance optimization. The frontend features a modular component architecture with custom hooks for state management, contextual controls, and interactive visualizations.
This repository is an OpenCode plugin that provides interactive pseudo-terminal (PTY) management for AI coding agents. It allows agents to spawn, write to, read from, and kill multiple background terminal sessions, enabling long-running processes like dev servers, watch modes, and interactive programs. The plugin exposes five tools (pty_spawn, pty_write, pty_read, pty_list, pty_kill) and two slash commands for opening a web UI. The architecture is modular: a core PTYManager orchestrates session lifecycle, output buffering (via a RingBuffer), and exit notifications, while adapters decouple the plugin from OpenCode V1 and V2 APIs. A Bun-based web server serves a React frontend with real-time WebSocket streaming and a REST API for session management. The codebase demonstrates strong TypeScript patterns, clean abstractions, and comprehensive testing (unit, integration, and Playwright E2E).
ServerStatus is a lightweight server monitoring and cloud dashboard system. It consists of a Go-based server that accepts TCP connections from Python clients, collects system metrics (CPU, memory, disk, network, processes, ping latency), and exposes a real-time JSON stats endpoint and a full REST management API. The server also supports service monitoring (HTTP/TCP probes), SSL certificate expiry checks, and a configurable watchdog rule engine that evaluates expressions against live metrics and triggers HTTP callbacks. The web UI is a single-page application with filtering, sorting, detail drawers, and an admin panel for CRUD operations on configuration. The architecture is a classic client-server model: multiple Python agents (client-linux.py or client-psutil.py) connect to a single Go server over a custom TCP protocol. The server authenticates agents, receives periodic metric updates, and serves a web dashboard and API. The Go server is a monolith with separate modules for HTTP handling, TCP agent handling, configuration management, SSL checking, and watchdog evaluation. It uses the Gin web framework for HTTP and the expr-lang library for rule evaluation. Key entry points are the TCP agent listener (port 35601), the HTTP server (port 80/8080), and the CLI flags for configuration. External dependencies include Go modules (gin, expr-lang), Python libraries (psutil for the psutil client), and Docker for containerized deployment. The system is designed for easy deployment via Docker Compose or shell scripts, with environment variable overrides for all client and server settings.
This is a full-stack web application for managing a WireGuard VPN server, implemented with Nuxt 4 (Vue 3 frontend) and Nitro (backend) with a SQLite database via Drizzle ORM. It provides a web-based admin UI for configuring the WireGuard interface (MTU, port, device, CIDR, routing table), managing clients (create, enable/disable, set expiry, per-client firewall rules, custom DNS/MTU), viewing traffic charts, and monitoring client status. The application supports multi-user authentication with password login, TOTP two-factor authentication, and OAuth providers (Google, GitHub, generic OIDC). It also includes an experimental AmneziaWG obfuscation mode, Prometheus and JSON metrics endpoints, a CLI for administrative tasks (password reset, client listing, QR code generation), and integration with iptables/nftables for per-client firewall rules. The system is packaged as a Docker image and relies on the host kernel's WireGuard module and iptables tooling.
SPAG4D is a production-grade tool that converts 360° equirectangular panoramic photos into explorable 3D Gaussian Splat (3DGS) scenes. It integrates multiple depth estimation backends (DA360, DAP, PaGeR, SHARP, UniSHARP) to generate depth maps from a single panorama, then projects the points into standard 3DGS PLY format. The system provides a CLI, a FastAPI web server with a JavaScript frontend, and a Python API for programmatic use. Beyond the core conversion, it includes optional refinement pipelines to fill holes and improve scene quality: OmniRoam (WSL2-based video generation and distillation), ArtiFixer3D (Docker-based diffusion refinement), and a lighter geometric refinement pipeline using depth alignment and voxel aggregation. The architecture is modular with pluggable generators, comprehensive configuration dataclasses, and provenance tracking. While the tool is primarily an application, it leans heavily on research-grade depth models and refinement techniques, giving it a hybrid character. The codebase is well-structured with clear separation of concerns, reusable utilities (spherical projection, depth blending, scene filtering, geometric alignment), and extensive tests. It is actively maintained with recent commits, though it carries complexity from multiple backends and platform-specific dependencies (WSL2, Docker, CUDA).
Nginx Proxy Manager is a full-stack web application that provides a graphical user interface and REST API for managing Nginx reverse proxy configurations, SSL/TLS certificates (via Let's Encrypt or custom uploads), TCP/UDP streams, access control lists, and user permissions. The system is designed to run as a Docker container and is primarily used by self-hosting enthusiasts and small-to-medium deployments to simplify the otherwise complex task of configuring Nginx and maintaining certificates. The architecture is a classic three-tier web application: a Node.js/Express backend (ES modules) with Objection.js/Knex ORM supporting SQLite, MySQL, and PostgreSQL; a React 18/19 frontend built with TypeScript, Vite, TanStack Query, and Tabler UI; and a set of s6-overlay managed services (backend, frontend, Nginx) inside a single Docker image. The backend generates Nginx configuration files from Liquid templates and reloads Nginx on any change. External dependencies include Nginx, Certbot (for Let's Encrypt), OpenSSL, and optionally a database server. Key entry points are `backend/index.js` (server startup, migration, setup, Express app) and `frontend/src/main.tsx` (React bootstrap). The primary data flow is: user creates or modifies a proxy host, redirection, stream, or certificate via the UI → API call → backend validates permissions and data → persists to database → regenerates relevant Nginx config files → tests configuration → reloads Nginx. The system also periodically checks for certificate expiration and renews via Certbot, and fetches IP ranges from Cloudflare/Cloudfront for access control. The codebase demonstrates solid engineering practices: a consistent internal service layer with access control and audit logging, a well-typed API client with automatic camelCase/decamelize conversion, a reusable table framework built on TanStack Table, and a comprehensive i18n system supporting 24+ locales. While some modules (e.g., certificate management) are large and could benefit from refactoring, the overall structure is clean and maintainable.
FigMirror is a reference-conditioned scientific figure style transfer system that iteratively generates matplotlib scripts matching the visual style of a reference figure. It operates as a multi-agent loop (Drawer/Reviewer) orchestrated by a runner backend (Codex, Claude, or Mock), with a local web UI for upload, iteration browsing, and refinement. The system is packaged as skills for both Claude Code and Codex, plus a standalone web server. While primarily an application, it has a strong research component: the prompts, aesthetic library, and evaluation benchmarks (PlotTwin-Bench) are the result of extensive empirical iteration. The codebase demonstrates high craftsmanship in its runner architecture, atomic file operations, SSE streaming, and deterministic review gates. However, it suffers from dual skill bundles (Claude/Codex) that must stay synchronized, retired artifacts, and some incomplete features (ClaudeRunner, SSE integration).
SensESP is an embedded firmware framework for ESP32 microcontrollers that enables building custom marine sensors that communicate via the Signal K protocol. It provides a complete pipeline from physical sensor reading (via Arduino libraries or built-in ADC/digital inputs) through data transformation (30+ composable transforms like linear scaling, moving average, hysteresis, curve interpolation) to publishing over WebSocket to a Signal K server. The framework includes a full web-based configuration UI (Preact/Bootstrap) served directly from the device, WiFi/Ethernet provisioning with captive portal, OTA updates, and a REST API for device management. Architecture follows a reactive dataflow pattern: sensors produce typed values that flow through transform chains to consumers (Signal K output, UI, logging). The core is built on ReactESP event loop, with observable/value producer/consumer abstractions enabling type-safe connections. Notable components include a TOFU certificate pinning system for secure Signal K connections, a circular log buffer with snapshot cursor for the web UI, and a smart switch controller supporting local and remote actuation with double-click sync. The codebase is well-structured with unit tests for transforms, metadata, and networking components, though some deprecated APIs and a large god object (SensESPApp) indicate areas for refactoring.
cheek is a pico-sized declarative job scheduler written in Go. It reads a YAML schedule file defining jobs with cron expressions, retries, environment variables, working directories, and event-driven actions (webhooks, job chaining). The single binary provides a CLI (run, trigger, version) and an embedded HTTP server with a web UI for monitoring job execution and logs. Architecture is monolithic: the scheduler loop runs in a goroutine, executing jobs via os/exec with context cancellation for graceful shutdown. Job logs are persisted to SQLite. External dependencies include SQLite, cron parsing (gronx), HTTP routing (httprouter), CLI framework (cobra), config management (viper), and structured logging (zerolog). The codebase is well-tested, with comprehensive unit tests and CI/CD pipelines for cross-platform builds and Docker images.
ThermalMarky is a web application and CLI tool that converts Markdown text into formatted ESC/POS commands for thermal receipt printers. The system is built with FastAPI for the HTTP server and python-escpos for printer communication. It features a clean web UI (single HTML page with Bootstrap) and a command-line interface for piping or file input. The architecture is a straightforward monolith: the web endpoint accepts markdown, saves it to a temporary file, then invokes the CLI script via subprocess. The core library modules handle configuration (with content overrides via HTML comments), input loading (stdin/file), markdown parsing into tokens with formatting (bold, underline, headers, alignment, QR codes), and printer output with line-width wrapping and truncation. The project includes proper Docker support and environment variable configuration. It demonstrates good separation of concerns and a non-trivial markdown-to-ESC/POS converter that handles inline format toggling and scaled text width calculations.
PiPiClaw is a cross-platform AI agent application that enables users to interact with local and remote systems via natural language commands. It features a built-in web UI for remote control, scheduled task management, file operations, command execution, and a skill system for extending capabilities. The application is designed to be lightweight and portable, utilizing .NET 10.0 AOT compilation to produce a single binary of approximately 2MB. It maintains conversation history and long-term memory with embeddings for context-aware interactions.