RMQTT is a production-grade, high-performance MQTT broker written in Rust, supporting MQTT v3.1, v3.1.1, and v5.0. It is deployed as a standalone binary (`rmqttd`) or as an embeddable library, and features a modular plugin architecture with 26+ built-in plugins covering authentication (HTTP, JWT), authorization (ACL), storage (RAM, Sled, Redis, Redb), bridging to external messaging systems (Kafka, Pulsar, NATS, ReductStore, remote MQTT), clustering via Raft or broadcast, and a rich HTTP API with an embedded Vue.js dashboard. The broker handles millions of concurrent connections, supports TLS, WebSocket, and QUIC transports, and includes advanced features like shared subscriptions, delayed publishing, flapping detection, topic rewriting, and system topic subscriptions for observability. The architecture is based on the Tokio async runtime, with per-connection tasks, bounded message queues, and a plugin hook system that allows extending the broker without modifying core code. Key entry points include `rmqtt-bin/src/server.rs` for binary startup, `rmqtt/src/v5.rs` and `rmqtt/src/v3.rs` for protocol handling, and `rmqtt/src/context.rs` for runtime orchestration. External dependencies include gRPC (via Tonic) for inter-node cluster communication, Sled/Redis for persistent storage, and various client libraries for bridges (rdkafka, pulsar, nats). The broker is extensively tested with a custom test harness (`rmqtt-test`) that includes >600 functional, stress, and chaos tests, many reproducing real GitHub issues. The codebase demonstrates strong engineering practices: a clean plugin lifecycle, efficient topic trie for wildcard matching, reusable utility crates (`rmqtt-utils`, `rmqtt-codec`, `rmqtt-net`), and a comprehensive test framework that manages broker processes and configs. The dashboard and HTTP API provide operational tooling for client management, metrics, and plugin configuration. While the project is actively maintained, the large number of feature flags and optional storage backends create some configuration complexity, and a few tests rely on hardcoded ports or timing, which can be brittle. Overall, RMQTT is a solid, extensible MQTT broker suitable for IoT and real-time messaging use cases.
The TodoMVC repository serves as a collection of reference implementations of the TodoMVC specification across numerous frontend frameworks. It provides a static file server (server.js) to serve these examples and includes comprehensive Cypress-based test infrastructure to validate implementations against the specification. Each framework implementation is self-contained in the examples/ directory, with shared assets in todomvc-common/ and todomvc-app-css/. The repository enables comparative evaluation of frameworks through identical feature implementations and automated testing.
Dora SSR is a production-grade cross-platform game engine designed for rapid development directly on target devices (mobile, desktop, web). The engine is a monolithic C++ core that provides 2D/3D rendering (bgfx), physics (JoltPhysics, PlayRho, Box2D), audio (SoLoud, libopenmpt), animation (Spine, DragonBones), UI (Yoga layout), and a full scene graph. It exposes scripting via multiple languages: Lua (with a custom binding generator), TypeScript (compiled to Lua via a vendored tstl fork), WebAssembly (via wasm3), Rust (via FFI), and C# (via P/Invoke). A built-in Web IDE (React/Monaco-based) allows coding and debugging from a browser on the same network. The engine also includes an AI coding agent with memory, skill tools, and preview session management, integrated into the IDE workflow. Over 50 CI workflows build for Android, iOS, Windows, macOS, Linux, and Web (Emscripten).
The PyDev.Debugger (pydevd) is a Python debugger backend designed for IDE integration and remote debugging. It provides core debugging capabilities including breakpoints, stepping, variable inspection, and expression evaluation. The architecture features a client/server model for remote debugging, with in-process tracing via settrace(). Key entry points include pydevd.py (main debugger), pydevd_attach_to_process (live process attachment), and pydevconsole.py (interactive console). The debugger supports multiple protocols (legacy line-based and JSON/DAP for VS Code integration) and employs Cython optimizations with fallbacks to pure Python. It includes extensive test suites covering edge cases like multiprocessing, async, GUI event loops, and framework-specific integrations (Django, Flask). The code demonstrates strong modularity through extension points for custom variable rendering and plugin architecture.
Emmett is a TypeScript monorepo providing an opinionated event sourcing and CQRS framework for Node.js applications. It implements the decider pattern for business logic, with pluggable event store backends (PostgreSQL, SQLite, MongoDB, EventStoreDB, in-memory) and web framework integrations (Express, Hono, Fastify). The framework includes built-in projections (single/multi-stream, raw SQL, document-oriented via Pongo), consumer/processor pipelines with checkpointing and locking, workflow orchestration, and comprehensive observability via OpenTelemetry (tracing, metrics, logging). The codebase is modular with separate packages per database and web framework, extensive test coverage (unit, integration, e2e), and a CLI for schema migrations. It is actively maintained with a large community (539 stars, 53 forks) and zero dependabot alerts. The architecture demonstrates high craftsmanship with reusable patterns for middleware composition, streaming transformations, and BDD-style testing specifications.
Flog is a Ruby code complexity analyzer that calculates an ABC (assignments, branches, conditionals) complexity metric with Ruby-specific enhancements. It processes Ruby source files to identify complex/tortured code that is difficult to test and maintain. The system consists of a core Flog library that performs the analysis, a CLI interface for command-line usage, a Rake task for integration with build systems, and a plugin system for extensibility. The architecture cleanly separates concerns: the Flog class handles AST processing and scoring, FlogCLI manages option parsing and file discovery, and FlogTask provides Rake integration. Recent versions have switched to using the prism parser for improved performance while maintaining backward compatibility with a --legacy flag for RubyParser.
Servo is a parallel web browser engine written in Rust, designed to leverage modern hardware capabilities for rendering and script execution. The codebase is structured as a large Rust workspace with distinct components for scripting, layout, networking, styling, and media handling. The primary entry point is the 'servoshell' port, which acts as the browser host application. The repository includes extensive Web Platform Tests (WPT) to ensure standards compliance, alongside a custom Python-based build and test infrastructure ('mach'). While the core engine is tightly coupled, several tooling components and specific subsystems (like storage and bindings) exhibit reusable architectural patterns. The project demonstrates high engineering craftsmanship in memory safety and parallelism, utilizing Rust's ownership model to prevent data races in the rendering pipeline. However, the sheer scale of the test suite (Web Platform Tests) and the reliance on auto-generated test files introduce significant maintenance complexity. The codebase maintains its own forks of core libraries (e.g., 'stylo', 'servo_arc'), which creates a medium risk of technical drift if upstream changes are not synchronized. The build system and test infrastructure are robust but complex, requiring specific tooling to reproduce builds across platforms.
This is a monorepo of first-party middleware and service implementations for the Fiber web framework (v3). It provides production-grade authentication (JWT, PASETO, SPNEGO/Kerberos), authorization (Casbin, OPA), observability (OpenTelemetry, Prometheus, New Relic, Sentry, custom monitor/uptime dashboards), real-time communication (WebSocket, Socket.IO v5), Web Application Firewall (Coraza), resilience patterns (circuit breaker, CPU load shedding), structured logging (zap, zerolog), internationalization, hCaptcha verification, Swagger UI/OpenAPI docs, profiling (fgprof), and Testcontainers integration for testing. Each package lives in its own Go module under v3/, following a consistent Config+New() pattern and includes extensive test coverage with benchmarks. The architecture is library-oriented: components are imported by Fiber applications, not run standalone. The codebase demonstrates strong engineering practices: config validation at construction, atomic concurrency patterns, lock-free read paths, and protocol-level optimizations (e.g., zero-copy Socket.IO codec, WebSocket write coalescing). Some packages show signs of technical drift (e.g., paseto uses a deprecated library, socketio has mutable package globals), but overall the repository is actively maintained with weekly releases and automated dependency updates.
Qt.py is a Python compatibility shim that provides a single, unified import interface over multiple Qt bindings (PySide6, PyQt6, PySide2, PyQt5). It dynamically selects the best available binding at runtime and exposes a curated common subset of members, ensuring that code written against Qt.py runs identically on any supported binding. The library also includes compatibility wrappers for differences in APIs (e.g., loadUi, wrapInstance, translate), a CLI for converting compiled .ui files, and a site-config mechanism for customizing exposed members. It is widely used in the film, games, and VFX industries to write cross-binding Qt applications without vendor lock-in. The codebase is well-structured, thoroughly tested, and actively maintained, with a strong emphasis on co-existence with native bindings and minimal overhead.
YouDub WebUI is a full-stack video localization platform that enables users to import videos, transcribe speech via Whisper, translate via OpenAI-compatible APIs, clone voices with VoxCPM2, separate audio with Demucs, align subtitles with Qwen3 Forced Aligner, and export dubbed videos or subtitles. The architecture is plugin-based (Cordis framework) with a Node.js/TypeScript host orchestrating Python subprocesses for ML inference, a Next.js web frontend, and native desktop apps for macOS (Swift) and Windows (C#). The system features a task engine with queuing, cancellation, retry, and partial rerun; a worker protocol using NDJSON over stdin/stdout; and a comprehensive setup service that downloads and verifies model weights. While primarily an application, it includes research-grade model consumption and detailed validation records documenting real-media runs with SHA-256 hashes and human listening feedback. The codebase is actively maintained with recent commits, CI/CD pipelines, and extensive unit tests for contracts, protocols, and permissions.
Celestia Node is a production-grade Go implementation of the Celestia data availability (DA) network node. It runs light and bridge nodes that listen to a Celestia Core (CometBFT/Cosmos SDK) chain, construct extended headers, build and verify erasure-coded extended data squares (EDS), and continuously sample random shares to prove block data availability. The codebase exposes a CLI (`celestia`, `cel-key`, `cel-shed`), a permissioned JSON-RPC API, and P2P protocols (shrex request/response and Bitswap) for efficient share retrieval. Architecturally, the system is a modular application composed with `go.uber.org/fx`: `nodebuilder` packages wire together header sync, the DASer, share getters/store, blob service, state transaction client, p2p host/discovery, pruning, and telemetry. The share retrieval stack uses a cascade getter that tries local storage, then shrex, then Bitswap; the DASer uses configurable concurrency, exponential backoff, and checkpointing. The store persists ODS/Q4 files with caching and striplocks. External dependencies include libp2p, IPFS boxo/Bitswap, rsmt2d Reed-Solomon encoding, NMT, Badger, and custom forks of cosmos-sdk/celestia-core. This is primarily an application rather than a data research repository, although it implements advanced DA research concepts such as erasure coding, namespace Merkle proofs, and peer scoring. The repository is actively maintained, but it carries documented security-relevant proof-verification weaknesses in tests (blob commitment verification and sample column proof binding), and relies on many custom forks and `replace` directives, creating meaningful integration risk. Overall it is a well-structured, heavily tested codebase with several reusable concurrency and retrieval patterns.
This repository is the source and build infrastructure for the textbook 'Structure and Interpretation of Computer Programs' (SICP) adapted to three programming languages: Scheme (original), JavaScript, and Python. It is not a runtime application but a sophisticated static-site and content-generation pipeline that transforms XML source files (containing narrative, exercises, code snippets, and figures) into multiple output formats: LaTeX/PDF for print, interactive JSON consumed by the Source Academy web frontend, standalone HTML, Markdown, and executable program archives for each language edition. The build system is Node.js/TypeScript-based, orchestrated by a central index.ts script with subcommands (pdf, web, json, md, programs), and relies on external test runners (js-slang, py-slang, CPython, MIT/GNU Scheme) to validate embedded code snippets. The repository also includes a chatbot knowledge base (Elixir modules with section summaries and index terms) for RAG-based Q&A over the book's Python edition. Although primarily a publishing pipeline, its modular architecture—edition abstraction, tag-dispatch processing, trie-based search indexing, and cross-format output—exhibits strong software engineering craftsmanship, with some duplication across format-specific parsers as the main drawback.
Inspira UI is a curated collection of beautifully designed, reusable Vue & Nuxt UI components, inspired by Aceternity UI and Magic UI. The repository contains a Nuxt 4 documentation site built with Docus, featuring live interactive demos with DialKit config panels, multi-language documentation (en, fr, cn), and a component registry for CLI-based copy-paste installation. It delivers 150+ components spanning backgrounds, cards, text animations, buttons, cursors, device mockups, special effects, and more, many powered by WebGL (Three.js, OGL), canvas, or GSAP animations. The codebase is organized with a consistent pattern: each component has a Vue SFC under `app/components/inspira/ui/`, a demo file under `app/components/inspira/examples/`, and a config panel under `app/components/inspira/configs/`. The documentation site itself is a Nuxt application that also serves as the component showcase, with a rich set of shared utilities like `ComponentPlayground`, `ComponentTabs`, and `DialKitConfigPanel`. While primarily an application (component library + docs site), it has a data-like registry pipeline for generating installable packages from the component sources. The repo is actively maintained with a large community following (5k+ stars) and frequent commits.
Murex is a cross-platform shell and scripting language designed as a more readable, safe, and type-aware alternative to Bash. In production it works as both an interactive REPL (with autocomplete, hint text, preview panes, spellchecking, and job control) and a scripting interpreter with a custom expression language, typed pipelines, exception handling (try/catch/trypipe), multi-scope variables, a built-in unit test framework, event hooks (onPrompt, onKeyPress, onFileSystemChange, onSignalReceived), an HTTP client, and a package/module manager. The defining architectural feature is that data in pipelines carries type metadata: JSON, YAML, CSV, TOML, XML, S-expressions, HCL and more are first-class structured objects with registered Marshal/Unmarshal/ReadArray/ReadMap/ReadIndex hooks, so builtins like alter, tabulate, count, and jsplit operate on structured data rather than raw text. The implementation is Go (with a JS/WASM interpreter variant), organized around lang/ (parser, expression engine, process lifecycle), shell/ (interactive terminal layer), builtins/ (roughly 200 commands, data type adapters, pipes, and event handlers), config/ (profile-driven runtime configuration), and utils/ (standalone helper libraries).
Standardese is a documentation generator for C++ that parses source code (particularly header files) using libclang or cppast to extract code structure and documentation comments. It combines this information to produce documentation in multiple formats, including HTML, Markdown, XML, and plain text. The tool is designed to be extensible, with a modular architecture separating comment parsing, entity modeling, synopsis generation, and output generation. The project employs several software engineering patterns, such as the visitor pattern for traversing the markup DOM, a builder pattern for constructing documentation entities, and a thread pool for parallel processing. Configuration is handled via command-line options and configuration files using Boost.Program_options. The output generation system uses a generator interface that allows adding new formats without modifying the core logic. Standardese is actively maintained, with recent commits indicating ongoing development. It relies on well-established dependencies like Boost, cmark-gfm, and cppast/libclang, and its build system is based on CMake. The codebase demonstrates good craftsmanship in its separation of concerns and reusable components, such as escaping utilities and enum reflection helpers, which could be extracted for use in other projects.
The Serverless Framework is a mature, open-source CLI tool for deploying and managing serverless applications on AWS. It compiles declarative YAML/JSON configuration (serverless.yml) into CloudFormation templates, orchestrates deployments via S3 artifact uploads and stack operations, and supports a wide range of AWS event sources (API Gateway, SQS, SNS, DynamoDB Streams, etc.). The repository is a monorepo with multiple packages: `sf-core` (new unified runner), `serverless` (legacy framework with AWS plugins), `engine` (AWS SDK client abstractions), `mcp` (Model Context Protocol server for AI agent integration), and `util` (shared logging, error handling, proxy support). Key entry points include `packages/sf-core/bin/sf-core.js` and `packages/serverless/lib/plugins/index.js`. The architecture is plugin-based, with lifecycle hooks for packaging, compiling events, and deploying. External dependencies include AWS SDK v2/v3, esbuild, and various npm packages. The codebase demonstrates high craftsmanship in areas like deterministic naming, proxy wrapping, and variable resolution, though some technical drift exists (dual SDK versions, deprecated providers).
Clash Verge Rev is a cross-platform desktop proxy management GUI built with Tauri 2 (Rust backend) and React 19 (TypeScript frontend). It serves as the control interface for the mihomo (Clash Meta) proxy core, enabling users to manage proxy subscriptions, switch proxy groups, toggle system proxy and TUN mode, view real-time traffic and connection details, and configure advanced settings like DNS overrides, script enhancements, and backup to WebDAV. The architecture is modular: a Rust backend handles core lifecycle, config management (using a unique 'Draft' transactional pattern), system integration (tray, hotkeys, auto-launch), and IPC with a privileged service on Windows. The frontend uses MUI, SWR, and virtual lists for a responsive UI with drag-and-drop profile/group editing, a built-in Monaco editor for YAML/JS configs, and real-time WebSocket-based data visualization. The repository also includes a Rust workspace with several crates (media unlock checker, i18n, logging, signal handling, rate limiter, system info plugin) that could be extracted and reused in other Tauri applications.
Coolify is a self-hosted Platform-as-a-Service (PaaS) that enables users to deploy and manage applications, databases, and services on their own infrastructure. It serves as an open-source alternative to Heroku, Netlify, or Vercel, supporting Docker-based deployments with Git integration (GitHub, GitLab, Gitea, Bitbucket), multiple build packs (Railpack, Nixpacks), and one-click service templates. The system manages servers, reverse proxies (Traefik/Caddy), SSL certificates, scheduled backups, and multi-channel notifications (email, Discord, Slack, Telegram, Pushover, webhook). The architecture is a Laravel monolith with a Livewire + Alpine.js frontend for the v4 UI and a React + TypeScript canvas-based interface for the v5 UI. Background jobs are handled by Laravel Horizon with dedicated queues for deployments, cron tasks, and reconciliation. Real-time updates use Soketi (a Pusher-compatible WebSocket server) and Laravel Echo. The system integrates with cloud providers (Hetzner, Vultr, DigitalOcean) for server provisioning and Stripe for subscription billing. A Model Context Protocol (MCP) server exposes resources and tools for AI assistant integration. Key data flows include: webhook ingestion from Git providers triggering deployment jobs, SSH-based remote command execution on managed servers, Docker Compose parsing and environment variable injection, database backup scheduling with S3 storage, and proxy configuration generation. The v5 architecture introduces a control-plane/agent split with Flux (HTTP socket) and coold (gRPC) components for improved scalability and isolation. External dependencies include Docker, PostgreSQL, Redis, Soketi, Stripe API, cloud provider APIs, and various notification service endpoints. The codebase is actively developed with frequent schema migrations and a dual v4/v5 code path, indicating ongoing architectural evolution.
This is the official OWASP Cheat Sheet Series repository, providing concise, actionable security guidance for developers. It contains over 150 markdown cheat sheets covering web application security, cloud security, AI security, and more. The repository is primarily a documentation project but includes a sophisticated build system (MkDocs, Docker, CI/CD) and tooling for quality assurance: markdown linting, link checking, text linting, and automated PR review agents. The link checker is a standout reusable component with modular architecture. The project is actively maintained with strict quality gates and a well-defined contribution process.
The repository is the companion software for the MIT course 'Underactuated Robotics' (6.832/6.821) by Russ Tedrake. It provides a Python package (`underactuated`) that integrates with the Drake robotics simulation library to implement algorithms for walking, running, swimming, flying, and manipulation. The repository includes the full HTML textbook, Jupyter notebooks with examples and autograded exercises, robot models (URDF/SDF), and utilities for simulation, visualization, and grading. The codebase is primarily an educational software library, but it also serves as a research resource with advanced topics like sum-of-squares optimization, trajectory optimization, and reinforcement learning. It is heavily tied to Drake and uses its `LeafSystem`, `MultibodyPlant`, `MeshcatVisualizer`, and `MathematicalProgram` APIs extensively. The architecture is modular: the `underactuated` package provides reusable components (meshcat utilities, plotting helpers, scenario generators, a grader for exercises) that are used across notebooks. The notebooks themselves are the primary user interface, demonstrating concepts with interactive simulations. The repository is actively maintained, with recent commits and a CI pipeline. It has a large number of stars (1030) and forks (254), indicating a strong community. However, it has some technical debt: deprecated functions, TODO comments, and a tight coupling to specific Drake versions.