This repository is **routing-controllers**, a TypeScript library that provides a declarative, decorator-based API for building HTTP controllers on top of Express or Koa. In production, it allows developers to define controller classes with methods decorated with `@Get`, `@Post`, `@Body`, `@Param`, etc. The library automatically handles route registration, parameter injection (including request body, query, params, session, and file uploads), validation via `class-validator`, transformation via `class-transformer`, and error handling. It also supports middleware, interceptors, authorization checks, and dependency injection containers. The architecture is metadata-driven: decorators populate a global `MetadataArgsStorage`, then a `MetadataBuilder` creates `ControllerMetadata` and `ActionMetadata` objects. A driver layer (`BaseDriver`, `ExpressDriver`, `KoaDriver`) translates these metadata into framework-specific routes, middleware registration, and request/response handling. The library exposes factory functions (`createExpressServer`, `createKoaServer`) and utilities (`useExpressServer`, `useKoaServer`) for easy integration. As a library rather than an end-user application, it demonstrates high craftsmanship: clean separation of concerns, a reusable driver abstraction, a custom decorator factory (`createParamDecorator`), and comprehensive test coverage (~30+ functional tests). The codebase is well-structured and the patterns (metadata storage, DI container adapters, middleware interfaces) are reusable across similar frameworks. Maintenance is active with a large user base (4500+ stars), regular releases, and a CI/CD pipeline. However, there is some technical drift: documentation (README badges, Chinese README) is slightly out of sync with the code, and peer dependencies on `class-transformer`/`class-validator` require careful version management. Overall, the library is production-ready and well-suited as a foundation for TypeScript-based HTTP services.
This repository is a WYSIWYG H5 (HTML5) page editor enabling drag-and-drop creation of responsive web pages without coding. Built with React, TypeScript, and Umi 3.0 framework, it features a plugin-based architecture where components are defined by template (metadata) and schema (editable properties). The editor includes a canvas for arranging components, property panels for configuration, and tools for previewing, exporting, and saving templates. A Node.js/Koa backend provides endpoints for saving and retrieving HTML content. The application emphasizes extensibility and performance through patterns like dynamic component loading with caching, schema-driven form generation, and a modular component library. Key reusable components include a dynamic engine for lazy-loading components, an editable list with drag-and-drop reordering, and an on-screen calibration ruler for alignment. While the project is actively maintained, it shows some technical drift in dependency versions (e.g., React 16, Ant Design 4) and relies on a simple in-memory backend that may require adaptation for production use.
Graphiti is a Python library and server framework for building temporal knowledge graphs that serve as persistent memory for AI agents. It ingests unstructured text episodes (messages, transcripts, JSON), uses LLMs to extract entities and relationships with bi-temporal validity windows, deduplicates against existing graph data, and provides hybrid search (semantic + BM25 + graph traversal) with configurable reranking. The codebase is structured around a clean driver abstraction (Neo4j, FalkorDB, Kuzu, Neptune) with per-provider operations classes, a prompt library supporting versioning and overrides, and a multi-provider LLM/embedder/cross-encoder client system. It is primarily an application library, though it includes evaluation infrastructure and research-grade deduplication algorithms (MinHash/LSH).
git-sim is a CLI tool that generates visualizations of Git operations from within a local repository. It uses the Manim animation library to render commit graphs, branches, tags, and file states as either static images (JPG/PNG) or animated videos (MP4/WEBM). The architecture is built around a base class `GitSimBaseCommand` that extends Manim's `MovingCameraScene` and provides common drawing methods for commits, refs, arrows, and zone tables. Each Git subcommand (add, branch, checkout, merge, etc.) is implemented as a separate Python class that inherits from this base class and overrides the `construct()` method to build the specific scene. The CLI interface is defined using Typer, and the application reads the current Git repository state via GitPython. The animation output is handled by a dedicated `handle_animations` function that manages rendering, format conversion, and file output. The codebase is well-organized, with clean separation between command logic, animation rendering, and configuration management via Pydantic settings. It demonstrates effective use of the Manim library for non-trivial graphics and provides a robust framework for simulating Git commands.
RViz is a 3D visualization tool for the Robot Operating System (ROS) that provides real-time visualization of sensor data, robot state, and navigation information. The application features a plugin-based architecture where displays, tools, and view controllers are dynamically loaded, enabling extensibility for various data types. Built with Qt for the GUI framework and Ogre for 3D rendering, RViz processes ROS messages through display plugins that convert data into renderable objects in the scene. Key systems include a property hierarchy for configuration, resource loading from ROS packages, and YAML-based configuration persistence. The architecture centers around a VisualizationManager coordinating the render loop, with core components including Display (visualization base), Tool (interaction base), and ViewController (camera control base). Data flows from ROS topic subscriptions through display plugins that process messages and update Ogre scene objects. User interactions via tools may publish ROS messages (e.g., setting navigation goals). The system maintains strict separation between Qt GUI elements, Ogre rendering, and ROS communication layers, using signals/slots for inter-component communication. Despite its complexity, RViz incorporates several reusable, well-engineered components. The property system provides a robust framework for editable parameters with automatic GUI generation and validation. The plugin architecture, built on pluginlib, offers a clean extension mechanism. Ogre helpers encapsulate common rendering tasks, and the configuration system handles hierarchical settings with locale-independent number parsing. The project shows active maintenance with ongoing efforts to modernize dependencies (Qt, Ogre, C++), though it remains primarily focused on ROS 1 with acknowledged technical debt regarding ROS 2 migration.
Litefin is a high-performance, native Jellyfin media client designed specifically for Samsung Tizen and LG webOS smart TVs. It is built as a single-page web application using vanilla JavaScript with a custom component framework, no external UI libraries. The architecture is event-driven, centered around a global EventBus, StateManager, and Router. The application provides full media browsing, playback with advanced subtitle rendering (ASS/SSA via libass-wasm), live TV with EPG, SyncPlay group synchronization, a plugin system, and integration with Jellyseerr for media requests. It is optimized for TV remote control navigation with a sophisticated FocusManager and spatial navigation engine. The system communicates with a Jellyfin server via REST API and WebSocket for real-time events. It also integrates with TMDB (via Jellyseerr) for metadata and trailers, and uses a background service (Luna on WebOS, HTTP proxy on Tizen) for device discovery, Wake-on-LAN, and Smart Hub preview. The codebase is organized into core modules (App, Router, EventBus, StateManager), UI components (pages, modals, grids), a player subsystem with OSD menus, and platform adapters for Tizen and WebOS. It supports multiple build variants (Modern, Normal, Legacy, Ultra-Legacy) to accommodate different Chromium versions on TV firmware. Key entry points include src/index.js (bootstrap), src/core/App.js (orchestration), and src/core/Router.js (navigation). Data flows primarily through the ApiClient for Jellyfin endpoints and the WebSocketHandler for server push events. The plugin system allows third-party extensions like skip-intro and mdblist-ratings. The application is heavily optimized for TV hardware, using GPU-accelerated CSS transforms, lazy loading, and memory-efficient virtual scrolling.
Seldon Core v2 is a production-grade, Kubernetes-native MLOps platform for deploying, scaling, and managing machine learning inference at scale. The system is architected as a set of microservices: a Kubernetes operator manages CRDs (Model, Pipeline, Server, Experiment), a centralized scheduler coordinates model placement and scaling across server replicas, an agent sidecar runs on each inference server to handle model loading/unloading, caching, and reverse proxying, and a Kafka Streams-based dataflow engine executes multi-step inference pipelines with joins, batching, and triggers. Inference requests enter via an Envoy proxy that routes to model servers or pipeline gateways, with Kafka as the underlying data plane for pipeline flows. The platform supports the V2 inference protocol, A/B experiments, explainability, drift detection, and OpenAI API translation. It integrates with MLServer, Triton Inference Server, and custom runtimes, and provides a CLI for lifecycle management.
This repository generates a minimalist, print-friendly single-page CV/resume website using Next.js (App Router) and Tailwind CSS. The primary code pattern is a static site generated from a TypeScript data file (`src/data/resume-data.ts`) that holds all resume content. The page renders sections for About, Work Experience, Education, Skills, and Projects, with a client-side command menu for navigation and actions. The project includes an Open Graph image generator, a verification script with comprehensive post-build checks, and a CI pipeline. It is not a dynamic application but a highly polished static portfolio template with excellent print and accessibility support.
HarmonyX is a runtime method patching library for .NET, forked from Harmony 2 and maintained by BepInEx. It allows modifying existing methods at runtime by injecting prefixes, postfixes, transpilers, finalizers, and IL manipulators. The library is primarily used in game modding, especially for Unity games via BepInEx, but can be used in any .NET application requiring runtime code transformation. The architecture centers on the Harmony class as the public API, which delegates to PatchProcessor and PatchClassProcessor for applying patches. Patches are defined via attributes or programmatically. The core patching backends are ManagedMethodPatcher (for methods with IL bodies) and NativeDetourMethodPatcher (for native/external methods). IL manipulation is handled by HarmonyManipulator, which uses MonoMod.Cil and Mono.Cecil to rewrite method bodies. The library also provides utilities like AccessTools (reflection helpers), Traverse (field/property traversal), CodeMatcher (IL pattern matching), and MethodInvoker (fast delegate invocation). Key data flows: A patch request specifies a target method and patch methods. The PatchManager resolves the appropriate patcher, which creates a detour or IL rewrite. For IL-based patching, the original method body is read via Mono.Cecil, converted to CodeInstruction objects, processed by transpilers and manipulators, and then written back using a custom IL emitter. The patched method then calls the original (or a copy) with the injected code. The library supports complex ordering via priority and before/after attributes, and handles edge cases like generics, value types, ref returns, and async methods. External dependencies include MonoMod.RuntimeDetour, MonoMod.Utils, and Mono.Cecil for IL manipulation. The library targets multiple .NET frameworks (net35, net452, netstandard2.0) and is distributed as a NuGet package (HarmonyX).
free-claude-code is a local proxy and developer tool that connects coding agents (Claude Code and similar harnesses) to OpenAI-compatible AI providers. It is a Python package (`free_claude_code`) with a CLI, a local API server, an admin web UI, and a substantial configuration subsystem. The system abstracts over a dozen AI providers (including NVIDIA NIM, Cloudflare, HuggingFace, and others) with provider-specific workarounds for tool parameter aliasing, thinking templates, and reasoning replay. It persists sessions, messages, and model metadata in SQLite, manages a tree-based conversation model with Telegram platform support, and renders transcripts with segment-based truncation and subagent state management. The repo is a shipped developer tool with installer/update scripts, GitHub issue templates, dependabot config, and a diagnostic `fcc-doctor` command; it is not a research or data project.
This repository provides a cross-platform BroadcastChannel library for inter-process communication between browser tabs, Node.js processes, WebWorkers, Deno, and iframes. It implements a unified messaging API with automatic backend selection (native BroadcastChannel, IndexedDB, localStorage, Unix sockets, or in-memory simulation) based on the runtime environment. The library also includes a leader election mechanism over the same channels, with two implementations: a standard token-based algorithm and a faster variant using the Web Locks API. The architecture follows a strategy pattern for transport backends, with each method conforming to a common interface (create, close, postMessage, onMessage, canBeUsed). The core BroadcastChannel class manages message lifecycle, deduplication via an external ObliviousSet, and graceful shutdown through unload hooks. The library is published as an npm package and is used in production by RxDB. It includes comprehensive testing (unit, integration, e2e, performance, Electron) and CI workflows for Node.js, browsers, and Deno.
This repository is a collection of Nx plugins for integrating various frontend frameworks (Svelte, Solid, Preact, Ionic/Angular, Ionic/React, Stencil, Capacitor, SvelteKit) with Nx workspaces. It provides generators for scaffolding framework-specific projects and components, and executors for running framework-specific build, test, and serve commands within Nx. The architecture follows a monorepo structure with framework-specific packages under `packages/` and a shared `@nxext/common` package containing reusable utilities for Vite integration, dependency management, and workspace modifications. Each plugin adheres to Nx's plugin architecture with clear separation between generators (code generation) and executors (task execution). The project demonstrates strong maintenance practices with version synchronization scripts, comprehensive testing (unit and E2E), and documentation generation tools.
Cocoa-Way is a macOS-native Wayland compositor that runs Linux GUI applications inside container runtimes (Apple Container, Docker, OrbStack, or via SSH/Waypipe) and renders them to macOS windows using Metal. The core architecture consists of a Rust binary that serves as both a desktop compositor (single window with tiled layout) and a rootless mode that maps each xdg-toplevel to a native macOS window. It features bidirectional clipboard relay (text and PNG, up to 64 MiB), CoreAudio forwarding, a control API over Unix sockets, and an optional MCP server for AI-assisted diagnostics and onboarding. The project demonstrates high craftsmanship in its Metal renderer with texture caching and damage-coalescing, as well as in its container session management, which handles multiple runtime backends and complex lifecycle orchestration. The codebase is well-structured but contains a few monolithic files (e.g., main.rs, container_mode.rs) that handle a large amount of state and UI logic.
CorsixTH is a comprehensive open-source reimplementation of the 1997 Bullfrog game Theme Hospital. It reconstructs the original game's mechanics faithfully using a C++ engine for performance-critical subsystems (rendering, audio, pathfinding, file I/O) and Lua scripting for game logic, UI, and data definitions. The architecture is a monolithic desktop application with separate utility tools (a Java level editor, a wxWidgets animation viewer, and a sprite encoder). The Lua codebase is extensive, featuring a custom class system, humanoid action queue pattern, room/object definitions, localization support, and a persistent save/load system. The game runs cross-platform on Windows, macOS, Linux, and BSD via SDL3. Notable reusable patterns include a lightweight OOP framework (class.lua), a generic pathfinder with multiple search strategies, a virtual filesystem abstraction, and an RNC decompression library. The project is actively maintained with CI, issue templates, and a large community, though some subsystems (e.g., movie player, MIDI) rely on optional dependencies.
Binance Grid Trader is a cryptocurrency trading bot that implements grid trading strategies for Binance Spot and Futures markets. The application features a modular architecture with separate layers for exchange gateways, event processing, strategy management, and user interface. It provides both a graphical interface built with PyQt5 and script-based execution modes for running trading strategies without UI. The system connects to Binance via REST and WebSocket APIs to receive market data and execute trades based on configurable grid strategies.
This repository is a reverse-proxy that translates ChatGPT's proprietary web API into OpenAI-compatible REST endpoints, enabling standard OpenAI SDK clients to generate images, edit images, have chat conversations, and search using ChatGPT's backend. It manages a pool of ChatGPT accounts, handles token refresh, proxy rotation, Cloudflare clearance (FlareSolverr, WARP), and provides a Next.js web dashboard for account management, image generation, settings, and backup. The backend is built with FastAPI and uses curl_cffi for HTTP impersonation, while the frontend is a modern React application with shadcn/ui components. The architecture is modular: protocol adapters in `services/protocol/` convert between OpenAI/Anthropic formats and ChatGPT's internal API, storage backends (JSON, SQLite, PostgreSQL, Git) abstract persistence, and services handle account lifecycle, image processing, and proxy configuration. The system is designed for self-hosted deployment via Docker Compose and supports advanced features like content filtering, chat completion caching, and editable file generation (PPT/PSD). Despite its strong engineering and active maintenance, the codebase is heavily dependent on reverse-engineering of ChatGPT's private API, making it fragile to upstream changes. The large single-file `OpenAIBackendAPI` class and limited test coverage are areas of concern, but the separation of concerns in storage, protocol, and service layers offers good reusability.
Intent UI is a production-ready React component library built on React Aria Components and Tailwind CSS v4, following the shadcn/ui copy-paste distribution model. It provides a comprehensive set of accessible UI primitives (buttons, forms, overlays, date pickers, collections, charts, navigation, etc.) that users install via CLI (`npx shadcn@latest add @intentui/button`) and fully own. The repository also includes a Next.js documentation site with MDX content, a registry server for component metadata, pre-built block templates (auth, charts, sidebars, navbars), an icon browser, a color palette tool, and AI agent skills for component composition, migration from v3 to v4, and registry auditing. The architecture is primarily a library of thin wrappers around React Aria primitives with `tailwind-variants` styling, plus a documentation/registry infrastructure that doubles as a marketing site. The codebase is actively maintained with low technical drift, but contains some repetitive example data and minor code smells (e.g., duplicate spreads, unused props).
This is a Flutter plugin monorepo (home_widget) for rendering native home screen widgets on iOS (WidgetKit/SwiftUI) and Android (Jetpack Glance). It provides a Dart runtime API to save/load widget data, update widgets, schedule updates, and handle interactivity via method channels. A companion code generator (home_widget_generator) uses Dart annotations to define widget layouts as declarative widget trees; these are compiled by the CLI (home_widget_cli) into platform-specific Swift and Kotlin code, along with a typed Dart helper for data synchronization. The CLI also scaffolds widget projects, patches Xcode project files and Gradle manifests, resolves fonts, and validates configurations. The codebase is production-grade with extensive unit, integration, and build tests across both platforms, comprehensive documentation, and migration guides. It is actively maintained with frequent releases and a clear monorepo structure.
Reddit Enhancement Suite (RES) is a browser extension that enhances the Reddit browsing experience. It injects a content script into Reddit pages and provides dozens of modular features such as inline media expansion, keyboard navigation, user tagging, account switching, night mode, content filtering, and comment tools. The architecture is modular: each feature is a self-contained Module with lifecycle hooks, and media support is extensible via a Host plugin system. The extension communicates between foreground (content script) and background (service worker) using a custom messaging abstraction built on browser runtime ports. Persistent configuration and user data are stored via a storage wrapper layer that supports key-value, prefix, and blob modes with atomic compare-and-set semantics. The build pipeline uses esbuild with Flow type stripping, and the project includes integration tests via Nightwatch and unit tests via ava. The codebase is mature and well-organized, though it relies on older patterns (Flow, jQuery, lodash) and is tightly coupled to Reddit's DOM and API, which introduces maintenance risk when Reddit changes. There are no data analysis or research components; it is purely a client-side enhancement application.
ConstraintLayout Compose Multiplatform is a Kotlin Multiplatform library that ports AndroidX ConstraintLayout's core engine and Compose DSL to Android, JVM, iOS, macOS, JS, and Wasm. It preserves the original androidx.constraintlayout.compose package names so existing Android Compose code can migrate with minimal changes. The repository is organized around a :compose main library module, a :parity differential test module containing a vendored Java oracle, build-logic convention plugins that generate shaded artifact variants, and platform sample apps for Android, desktop, iOS, and web/Wasm.