Manim (ManimGL) is the original animation engine for explanatory math videos, developed for 3Blue1Brown. It is a complete GPU-accelerated rendering application/library: users define Python Scene subclasses with a construct() method, then run them through the manimgl CLI to preview in a real-time GLFW/WGPU window or render MP4/GIF/PNG via FFmpeg. The system is built around Mobject (mathematical objects), VMobject (vectorized paths), a WGSL shader pipeline, LaTeX/SVG text rendering, 3D surfaces, fractals, coordinate systems, and an interactive event system for mouse/keyboard manipulation. It is not a data/research repository, though it contains substantial numerical and scientific utility code for geometry, Bezier curves, color theory, and GPU data layout.
This repository is the **skymp** (Together Reborn) project, a comprehensive open-source multiplayer mod for Skyrim Special Edition. It is a monorepo containing a dedicated game server (`skymp5-server`), a client plugin (`skymp5-client`), a custom web frontend (`skymp5-front`), and a suite of supporting libraries. The server is a Node.js process with a C++ native addon that runs the core game simulation, manages player state, and handles networking via RakNet. The client runs inside Skyrim through the Skyrim Platform, synchronizing player actions and world state. The frontend provides a Skyrim-themed UI for login, chat, and dice rolling. The architecture is a classic client-server model with a strong emphasis on server-authoritative state. The C++ codebase is notably well-structured, featuring several high-quality, reusable libraries. These include a standalone Papyrus scripting VM (`papyrus-vm`), a comprehensive ESM/ESP plugin file parser (`libespm`), a template-based serialization framework (`serialization`), and a general-purpose utility library (`viet`). These components are largely decoupled from the game-specific logic and could be extracted for use in other modding tools or game engine projects. While the core libraries exhibit strong craftsmanship, the project as a whole shows signs of technical drift and complexity. It is tightly coupled to specific versions of Skyrim, SKSE, and CommonLibSSE-NG. The client-side TypeScript services contain some risky patterns (e.g., `eval` usage) and are tightly integrated with the optional SweetPie mod. The build system is complex, relying on specific toolchains (clang, vcpkg, Node.js). Despite this, the project is actively maintained with a robust CI/CD pipeline and a clear vision for multiplayer Skyrim.
This repository is an OBS Studio plugin that enables simultaneous streaming to multiple RTMP (and SRT/RIST, WHIP) destinations from a single OBS session. It provides a dockable Qt-based user interface where users can configure an arbitrary number of streaming targets, each with independent encoder settings (video and audio) or the option to reuse the current OBS streaming/recording encoder. The plugin manages per-target start/stop, bulk start/stop, and can synchronize with OBS's built-in streaming start/stop events. The architecture is a standard OBS plugin: it registers a dock via the obs-frontend-api, creates a main widget (MultiOutputWidget) that hosts a scrollable list of target cards (PushWidgetImpl), and provides an editor dialog (EditOutputWidgetImpl) for adding/modifying targets. Configurations are persisted in a JSON file (obs-multi-rtmp.json) within the OBS profile directory, with support for export/import. The build system uses CMake with platform-specific presets and GitHub Actions for CI/CD across Windows, macOS, and Linux, including Flatpak packaging. Key strengths include a reusable JSON utility (json-util.hpp), a generic OBS properties widget (obs-properties-widget) that can render any obs_properties tree with two-way data binding, and an RAII scope guard (Finally) in helpers.h. The code demonstrates solid C++ practices, cross-platform awareness, and careful handling of encoder sharing to avoid resource conflicts. However, the plugin is tightly coupled to OBS internals, has no automated tests, and some source files exceed 500 lines mixing UI and business logic.
Monitorian is a mature Windows desktop utility for adjusting brightness, contrast, and related display settings across multiple monitors, including external DDC/CI-capable displays. In production it enumerates physical and internal displays through several Windows APIs (Dxva2 DDC/CI, WMI, WinRT DisplayInformation, CCD DisplayConfig), wraps each display in a MonitorItem abstraction, and presents a tray-icon-anchored WPF UI with sliders for brightness, contrast, and adjustable range. It also supports unison changes, SDR white-level adjustment on HDR-capable displays, ambient-light-based adaptive brightness, startup registration, CLI-based control, and extensive probe/operation logging for diagnostics. Architecturally, this is a multi-project .NET Framework 4.8 solution: Monitorian (thin WPF executable), Monitorian.Core (domain and UI core), ScreenFrame (reusable WPF/Win32 window and tray helper library), StartupAgency (startup registration abstraction), IconImage (icon generation tool), Monitorian.Test (unit tests), and a WiX installer. The main entry path is App.xaml.cs -> AppKeeper -> AppController, which coordinates session/power/display watchers, monitor discovery, view models, and tray popup windows. The code is organized MVVM-style with custom WPF controls, converters, behaviors, and a clean separation between monitor hardware access and UI state. Key data flows are hardware-driven: MonitorManager aggregates monitor sources into DdcMonitorItem, WmiMonitorItem, HdrMonitorItem, and UnreachableMonitorItem objects; view models read and write brightness through DDC/CI calls or WMI methods; BrightnessWatcher reacts to external brightness changes; and session/power events trigger monitor rescans. External dependencies are Windows system APIs and contracts (Dxva2, SetupAPI, WMI, PowrProf, WinRT), Windows Forms NotifyIcon, Microsoft.Xaml.Behaviors, and MSTest. The codebase is actively maintained but carries medium technical drift: it targets legacy .NET Framework 4.8, uses preview C# language features, calls undocumented or version-gated Windows APIs, and contains some duplicated helper utilities and localization inconsistencies. Despite those issues, the core abstractions are well-structured and several subprojects are designed as genuinely reusable libraries.
WAT is a zero-dependency Python library for deep runtime inspection of objects. It provides a single `wat` object that can be used via `wat / obj`, `wat(obj)`, or `obj | wat` to display the object's type, value, attributes, methods, signatures, docstrings, source code, and more. The library supports a rich set of modifiers (short, long, dunder, code, caller, public, all) that can be chained fluently. It also offers `wat.locals` and `wat.globals` to inspect variable scopes. A notable feature is the ability to load the entire inspector without installation via a base64-compressed snippet or even a single Unicode glyph, making it extremely portable for debugging in any Python environment. The codebase is a single well-structured module with comprehensive test coverage, demonstrating solid Python engineering practices including operator overloading, AST manipulation for minification, and careful handling of edge cases in object introspection.
jgmenu is a lightweight, stand-alone X11 menu application written in C. It renders hierarchical menus using Cairo and Pango, supporting icons, search filtering, and extensive theming. The system is modular: data generators (XDG, Openbox, LXDE, pipe menus) produce CSV input that the menu widget renders. It integrates with desktop environments like tint2, xfce4, and MATE via IPC and applets. The codebase is well-organized with reusable data structures (hashmap, list, string buffer), a comprehensive test suite, and static analysis tooling. It is actively maintained with regular releases and CI pipelines.
Xonsh is a cross-platform, Python-powered interactive shell that combines Python syntax with shell subprocess commands. The codebase implements a full shell environment with a custom parser (PLY-based with version-specific extensions), an execution engine that compiles xonsh code to Python AST, a rich tab-completion system with multiple backends (bash, git, pip, python, custom completers), a pluggable history backend (JSON, SQLite), a prompt system with git status and virtualenv information, and a subprocess management layer with job control. It also includes CLI tools for formatting, linting, and interactive configuration (xonfig wizard and web UI). The architecture is monolithic with a clear module structure: parsers, executers, completers, prompts, history, procs, and shells. External dependencies include prompt_toolkit, pygments, and PLY (vendored). The repository is actively maintained with frequent releases, supports Python 3.10+, and has an extensive test suite. Some technical drift exists due to deprecated API shims, multiple parser versions, and LLM-generated tests, but the core is well-engineered.
LiteFS is a FUSE-based distributed filesystem for replicating SQLite databases across a cluster of machines. It operates as a Linux daemon that intercepts SQLite's file-level operations (journal, WAL, SHM) to capture every transaction. These transactions are recorded in a custom LTX (Lite Transaction) binary format and streamed to replica nodes via an HTTP/2 h2c protocol. The system uses leader election (via Consul or a static configuration) to designate a primary node that accepts writes, while replicas synchronously apply changes and enforce read-after-write consistency via TXID cookies and a proxy layer. The architecture is fundamentally a thin FUSE layer wrapping a distributed state machine: each node runs a store that manages multiple databases, tracks guards for SQLite lock compatibility (PENDING, SHARED, etc.), and exposes an HTTP API for streaming replication, manual imports/exports, handoff, and backup integration. The proxy server sits in front of the application to route read requests to the primary or a sufficiently caught-up replica, using Fly-Replay headers for transparent redirect. Backup is supported through either a file-based mechanism or the LiteFS Cloud client. External dependencies include Consul (for leader election), FUSE (required on Linux), and the underlying SQLite library (no cgo, pure Go via the ltxx package). The codebase is written in Go, with a heavy focus on correctness under concurrency—evidenced by extensive integration tests that exercise split-brain recovery, checkpoint races, and multi-node handoff. The project is in beta and follows a roadmap-driven contribution model where the maintainer rewrites feature PRs to ensure consistency.
Kuro is an Electron-based desktop client for Microsoft To-Do that wraps the web interface in a native application shell. It provides desktop-specific features like system tray integration, global keyboard shortcuts, auto-launch capabilities, and theme customization while maintaining compatibility with the Microsoft To-Do web service. The architecture follows a standard Electron pattern with main and renderer processes, using IPC communication for desktop features and electron-store for persistent settings. The application injects custom CSS to theme the Microsoft To-Do interface and adds platform-specific enhancements.
OpenCode-Mem is a plugin for OpenCode, an AI coding assistant, that provides persistent memory using vector embeddings and Turso/libSQL. It stores project-level technical memories (decisions, code facts, patterns) and learns user preferences/configs across sessions. The system uses local ONNX embeddings (or remote API) and supports multiple LLM providers (Anthropic, OpenAI, Google Gemini, MiniMax). It features auto-capture of session content, user profile learning with confidence decay, deduplication, and migration services. A full React web UI allows browsing, editing, and managing memories and user profiles. The architecture is modular: plugin entry, AI provider abstraction, Turso shard management, embedding service, web server, and shared API schemas. While primarily an application, it includes robust data pipeline patterns for vector search, ETL (migration), and user modeling.
Sunone Aimbot is an AI-powered aimbot for first-person shooter games that uses YOLO models to detect players and heads in real-time screen captures. The system captures frames via MSS, BetterCam, or OBS, processes them with Ultralytics YOLO, identifies targets (prioritizing heads unless disabled), calculates mouse movement to aim at targets, and optionally shoots automatically. It features a modular architecture with separate threads for capture, visualization, overlay, shooting, and hotkey monitoring. A helper API and React-based UI provide configuration management, model training/exporting, and testing capabilities. The aimbot supports multiple input methods including standard mouse, GHUB, Razer, and Arduino devices.
Blackfire Player is a PHP CLI application (blackfire-player) that executes declarative scenario files to crawl HTTP services, extract data, and assert responses, with integrated Blackfire performance profiling. It uses a custom DSL (`.bkf` files) to define sequences of steps (visit, click, submit, loop, while, etc.) and supports concurrent execution via PHP Fibers. The architecture is modular: a step hierarchy (AbstractStep, Step, etc.), dedicated step processors following the Chain of Responsibility pattern, an extension system for lifecycle hooks (before/after step, scenario), and a Symfony ExpressionLanguage wrapper providing scraping-specific functions (css, xpath, json, regex, fake, etc.). The tool integrates with the Blackfire SDK for profiling and assertion checks, and outputs results as JSON or text. It is distributed as a PHAR archive and a Docker image, built via GitHub Actions. The codebase is well-structured, heavily tested with PHPUnit, and follows modern PHP practices (typed properties, strict types, PHP 8.4+ features).
easyjson is a Go library and code generator that produces specialized, reflection-free JSON marshal/unmarshal code for Go structs. It achieves 4–5× faster serialization than the standard `encoding/json` by generating type-specific encoder/decoder functions at compile time. The architecture consists of a CLI tool (`easyjson/main.go`) that parses Go source files, extracts struct annotations (`//easyjson:json`), and generates `_easyjson.go` files implementing `easyjson.Marshaler`/`Unmarshaler` interfaces. The runtime library provides a fast JSON lexer (`jlexer`), writer (`jwriter`), buffer pool (`buffer`), optional types (`opt`), and helpers for unknown fields, string interning, and zero-copy parsing. The project includes extensive benchmarks comparing against ffjson, jsoniter, and go/codec, and a comprehensive test suite covering edge cases like omitempty, snake_case, embedded types, and custom key types.
Text Embeddings Inference (TEI) is a production-grade inference server for open-source text embedding models, built in Rust with multiple backend implementations (Candle, Python, ONNX). The system exposes both HTTP (REST) and gRPC APIs supporting dense and sparse embeddings, reranking, sequence classification, and OpenAI-compatible endpoints. It features dynamic batching with cumulative sequence length management, flash attention optimization across CUDA compute capabilities, and comprehensive observability with Prometheus metrics and OpenTelemetry tracing. The architecture cleanly separates the router layer (HTTP/gRPC handling) from the core inference pipeline (tokenization, batching, backend dispatch) via the `Backend` trait, allowing seamless integration of different model backends and hardware targets including CPU, CUDA, ROCm, Intel, and ARM64. The codebase demonstrates strong engineering practices: modular neural network layer implementations (Linear, LayerNorm, RMSNorm, Rotary) reused across model architectures, snapshot-based regression testing for all supported models, and feature-gated builds for precise dependency control. The router provides production features such as CORS, API key authentication, request size limits, health checks, and graceful shutdown. The batching system (`Queue` struct) efficiently accumulates requests and dispatches them to the backend in configurable token-bucket sizes. While the engineering quality is high, the repository exhibits some maintenance risks: significant model duplication across `flash_` and non-flash variants for each architecture, patched upstream dependencies (candle, cudarc) that may diverge from official releases, and commented-out integration tests. The Python backend, wrapping a subprocess, introduces platform-dependent fragility, and the large number of hardware-specific Dockerfiles increases build complexity. Overall, TEI is a well-architected, actively maintained inference server suitable for production deployments, with reusable patterns in its backend abstraction, batch processing, and layer implementations.
file.d is a high-performance, production-grade data pipeline tool developed by OZON.ru. It reads events from multiple sources (files, Kubernetes, Kafka, HTTP, sockets, journalctl, dmesg), processes them through a configurable chain of actions (transform, mask, throttle, join, decode, etc.), and outputs to a wide variety of sinks (ClickHouse, Elasticsearch, Kafka, S3, Prometheus, Loki, Splunk, HTTP, PostgreSQL, file, socket, etc.). The system is built as a single Go binary with a plugin architecture, leveraging zero-allocation JSON manipulation (insane-json) for maximum throughput. It features a custom expression language for event transformations, conditional rule engines (do_if), batching with backoff/dead queue, antispam, metrics via Prometheus, and Helm chart for Kubernetes deployment. While primarily an application, its configurable DSL and data processing pipeline may appeal to data engineering workflows. The codebase is well-tested with extensive unit and integration tests, and is actively maintained.
Sidequest.js is a production-grade, Redis-free background job processing library for Node.js. It implements a job queue system where jobs are persisted in PostgreSQL, MySQL, SQLite, or MongoDB, and claimed atomically via database-level locking (e.g., SELECT ... FOR UPDATE SKIP LOCKED for SQL backends). The architecture is a monorepo with separate packages for the core job model and state machine (core), the orchestration engine (engine) that manages forked child processes and worker thread pools, a web dashboard (dashboard) built with Express and EJS, a CLI for migrations, and pluggable backend drivers. The primary entry points are Sidequest.start() for full processing or Sidequest.configure() for enqueue-only mode. The library supports job scheduling (cron), retries with exponential backoff, uniqueness constraints, job timeouts with abort signals, and manual job resolution. It is well-tested with a shared conformance test suite for backends and integration tests covering lifecycle, cancellation, and logging.
Finicky is a macOS application that acts as a smart default browser handler. It intercepts URL open requests from the operating system and routes them to different browsers based on user-defined rules written in JavaScript or TypeScript, or via a simpler JSON rules file. The application is built as a hybrid of Go (using a custom Go-like language with Objective-C interop) and a Svelte-based web UI embedded via WKWebView. It includes a JavaScript virtual machine (goja) to evaluate user configuration scripts, supports URL rewriting, short URL resolution, browser profile detection, and provides a graphical configuration and testing interface. The codebase is well-structured with separate packages for the config API (TypeScript, compiled to JS), the UI (Svelte), and the core macOS app (Go/Objective-C). It demonstrates strong engineering practices including caching, debouncing, and comprehensive testing.
fastllm is a high-performance LLM inference engine written in C++ with CUDA/CPU backends, designed for local and server deployment of large language models. In production, it loads models from HuggingFace, GGUF, and custom formats, then executes inference with advanced features: quantization (FP8, INT4, NVFP4, GGUF), speculative decoding, multi-token prediction (MTP), Mixture-of-Experts (MoE), paged KV cache, tensor parallelism, NUMA-aware execution, and disk offloading. It serves models through multiple interfaces: a C++ CLI, a Python CLI (ftllm), an OpenAI-compatible HTTP API server (Chat Completions, Responses, Anthropic Messages), a WebUI, a desktop launcher with agent integrations (DeepSeek Harness, OpenCode, Codex, Claude Code), and an Android app. The system also includes model conversion/export tools, a launcher with hardware auto-recommendation, and a plugin system for UI customization.
This repository is a full-stack, multi-tenant AI API gateway platform (named 'sub2api') that proxies requests to a wide range of AI model providers including OpenAI, Anthropic, Gemini, Grok, DeepSeek, and many others. It provides authentication (JWT, OAuth, API keys), rate limiting, token-level billing, subscription management, user and admin management, payment processing (Alipay, WeChat Pay, Stripe, Airwallex, EasyPay), content moderation, channel monitoring, and operational dashboards. The backend is written in Go using the Gin framework and Ent ORM, with PostgreSQL and Redis for data storage and caching. The frontend is built with Vue 3, TypeScript, and Pinia stores, offering both admin and user interfaces. The system is designed for production deployment with Docker, includes extensive unit and integration tests, and supports a plugin architecture for extensible OAuth transport. Despite its large codebase and many features, the architecture follows a clear service-repository pattern with well-isolated packages, making it a solid example of a complex API gateway implementation.
PageIndex is a production-ready RAG framework that replaces vector databases with a reasoning-based, hierarchical tree index over documents. Its core innovation is the 'flash' pipeline: a sophisticated, LLM-free PDF structure extractor that uses character-level layout analysis, trie-based keyword matching, and heuristic classification to build a table of contents tree from PDFs in seconds. The system then enables agentic retrieval by feeding this tree to an LLM, which reasons over the hierarchy to find relevant pages without embedding or chunking. The repository provides a full Python SDK (PageIndexClient) with local and cloud modes, CLI tool, integrations with OpenAI Agents SDK, Anthropic SDK, and Claude Agent SDK, plus an MCP bridge for remote tool execution. While primarily an application, it contains a deep research-grade data processing pipeline (flash) with extensive multilingual dictionaries and layout analysis heuristics, giving it a hybrid character. The codebase is well-structured with clear module boundaries, extensive test coverage, and reusable patterns like the tool contract system and trie-based matching. However, it carries medium technical drift risk due to hardcoded thresholds, dependency on private APIs of LLM frameworks, and pdfium version sensitivity.