This repository is the official reference implementation of the VP8 and VP9 video codec standards (libvpx), maintained by the WebM project. It provides a C library for encoding and decoding VP8/VP9 video streams, with support for multiple container formats (IVF, WebM, Y4M), real-time and two-pass encoding, scalable video coding (SVC), and high-bit-depth profiles (10/12-bit). The architecture is a classic monolithic codec library: a public API layer (`vpx_codec_*` functions) dispatches to internal encoder/decoder state machines, which in turn call a large set of DSP primitives (transforms, quantization, motion estimation, loop filtering, entropy coding) implemented in both portable C and heavily optimized SIMD for x86 (SSE2/SSE4/AVX2/AVX512), ARM (NEON, SVE), MIPS (MSA, DSPR2), PowerPC (VSX), and LoongArch (LSX). The build system uses custom `.mk` files with runtime CPU detection (RTCD) to select the appropriate function pointer at runtime, enabling a single binary to run across diverse hardware. The primary data flow is frame-by-frame: raw YUV frames enter the encoder, are transformed, quantized, entropy-coded, and output as a bitstream; the decoder reverses the process. Rate control models buffer fullness and scene complexity to meet target bitrates. The codebase includes extensive Google Test-based unit tests covering algorithm correctness, bitstream conformance, and performance benchmarks. Example applications (`vpxenc`, `vpxdec`, `simple_encoder`, `simple_decoder`) demonstrate the API and serve as integration tests. Key entry points include `vpx_codec_enc_init()`, `vpx_codec_encode()`, `vpx_codec_dec_init()`, `vpx_codec_decode()`, and the control interface (`vpx_codec_control_`). External dependencies are minimal (only standard C library and optional platform headers); third-party code includes Google Test, libwebm (WebM mux/demux), libyuv (color conversion, bundled), and x86inc.asm (NASM macros). The repository also contains research-oriented tools under `tools/3D-Reconstruction/` (Python/Processing sketches for motion estimation and 3D reconstruction) which are experimental and not part of the core library.
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.
MSAL Python is a production-grade OAuth2/OIDC client library for the Microsoft identity platform (Entra ID / Azure AD, ADFS, MSA). It implements the full token acquisition lifecycle: authorization code, client credentials, device code, ROPC, on-behalf-of, and managed identity flows, plus WS-Trust for legacy ADFS federation. The library exposes two primary application classes — PublicClientApplication (desktop/mobile) and ConfidentialClientApplication (web apps/daemons) — built on a shared ClientApplication base with an embedded oauth2cli sub-package for low-level OAuth2 protocol handling. It also supports broker integration via pymsalruntime, proof-of-possession tokens, and regional endpoints.
sass-resources-loader is a Webpack loader that automatically injects Sass resources (variables, mixins, functions) into every Sass module processed by Webpack. It eliminates the need to manually import shared Sass utilities in each file by preprocessing Sass source files to prepend resource content. The loader supports both @import and @use Sass syntax, includes special handling for hoisting @use statements (which must precede other declarations), and correctly rewrites relative paths in imports to be relative to the webpack context. It handles glob patterns for resource files and provides detailed error reporting.
Stream Chat Swift is an iOS/macOS SDK for building real-time chat and messaging applications. It provides a modular architecture separating core networking (StreamChat), UI components (StreamChatUI), and shared utilities (StreamChatCommonUI). The SDK supports features like channels, messages, reactions, threads, polls, attachments, typing indicators, and presence. It uses Combine for reactive programming, Core Data for persistence, and WebSocket for real-time communication. The repository includes demo applications, example implementations (SlackClone, MessengerClone, etc.), and extensive testing infrastructure. The SDK follows protocol-oriented programming with dependency injection via Appearance and Components providers, enabling high customization.
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.
This repository is a fork of Prism Launcher specifically modified to enable offline Minecraft gameplay without Microsoft/Mojang authentication. It's a cross-platform desktop application built with the Qt framework that manages Minecraft instances, handles mod installation from various sources (Modrinth, CurseForge, FTB, etc.), and launches the game with configured settings. The application features a modular architecture with separate components for core logic, Minecraft-specific functionality, user interface, mod platform integrations, networking, and task management. Key features include instance management, version control, mod/resource pack handling, Java installation management, screenshot capabilities, and offline authentication support.
OpenRath is a production-grade multi-agent workflow orchestration framework with a PyTorch-like composable API. It provides a structured session abstraction (dataflow with lineage, fork/merge, placement via `.to()`), pluggable LLM providers (OpenAI, Anthropic, LiteLLM), sandboxed execution (local subprocesses, containerized OpenSandbox), persistent memory (local filesystem with BM25, OpenViking vector backend), and a durable runtime with effect ledger, checkpoints, interrupts, and lease-based worker fencing. The framework includes a full AgentServer (REST + SSE) with authentication, authorization, audit, and an OpenAPI contract. It supports defining agents and workflows as composable Python objects with `@step`/`@router` decorators and a compiler that validates resource manifests. The codebase is heavily tested with conformance, integration, and benchmark suites, and follows modern Python patterns (protocols, dataclasses, async/await, asyncio runtime bridging). While the repository contains evaluation and memory backends that touch on data aspects, its dominant character is a software application framework for building and deploying AI agents.
Awesome Cursor Skills is a curated knowledge repository — an 'awesome list' that doubles as a library of 70 ready-to-use SKILL.md instruction files for Cursor's AI agent. Each skill is a self-contained markdown document with YAML frontmatter (name, description, user-invocable flag) and a body of workflow instructions, organized as resources/<slug>/SKILL.md. Skills cover browser-based QA (visual testing, accessibility auditing, responsive/dark-mode checks), testing (Playwright, TDD, parallel test fixing), CI triage, code review, security/performance auditing, auth/payments integration, infrastructure (Docker, Kubernetes, Terraform), and meta-skills for generating new skills, rules, and hooks. The README is the curation layer: a categorized index linking to in-repo skills, external community skills, and official Cursor marketplace plugins. This is a content library rather than a traditional software application — the only executable code is resources/generating-images/scripts/generate_image.py, a production-grade Python CLI wrapping OpenAI's gpt-image-2.
This repository is a full-stack video course management system (CVM) designed for creating, editing, and publishing technical video lessons. It consists of a web application (React Router v7 with SSR), a CLI tool (`cvm`), a remote RPC API (Hono, deployed on Vercel), and several internal packages including a core domain library with Drizzle ORM schema, a standalone Remotion overlay renderer, and a vendored Lucide icon set. The system orchestrates complex workflows such as video capture (OBS integration), timeline editing with clip trimming and overlay compositing, AI-assisted content generation (chapter autofill, SEO descriptions, newsletters using Anthropic Claude), and publishing to YouTube, Dropbox, and Buffer. A teleprompter popup syncs via BroadcastChannel, and a diagram editor built on tldraw supports snapshot-based revision history. The architecture is heavily driven by Effect-ts for backend services, with a clear separation between read-only CLI operations (via HTTP RPC) and write operations (via web app routes). The frontend uses optimistic updates for a fluid user experience, while the backend enforces draft-gate policies to prevent writes to published course versions. The codebase is thoroughly tested with Vitest and PGlite in-memory PostgreSQL, using fake service layers for external dependencies (Dropbox, AI generation, video processing). Despite its healthy test coverage and well-structured service pattern, the repository shows signs of organic growth: multiple modals with duplicated state logic, large reducer files, and some drift between duplicated prompt definitions. The dependency on the Effect-ts ecosystem and a large number of third-party APIs (Dropbox, YouTube, Buffer, OBS, Cloudinary) creates a maintenance surface that requires careful version alignment. The overlay renderer is isolated as a separate package with its own build process, reducing coupling but adding deployment complexity.
DeepZero is an automated vulnerability research pipeline engine, primarily targeting Windows kernel driver (BYOVD) analysis. It provides a highly concurrent, resumable orchestration framework where pipelines are defined declaratively in YAML. The engine supports stages: ingest, map (parallel analysis), reduce (aggregation), and bulk_map, with built-in fault tolerance, atomic state persistence, and live progress dashboards. It integrates external tools like Ghidra (headless decompilation), Semgrep (static analysis), LIEF (PE parsing), and LLM backends (LiteLLM, Claude Code) for exploitability assessment. The repository includes a full reference pipeline (loldrivers) and multiple language documentation sites. While primarily an application framework, it has strong data research characteristics due to its focus on binary corpus analysis and heuristic/AI assessment.
BlazorBlueprint is a comprehensive Blazor UI component library inspired by shadcn/ui, providing over 112 styled components and 28 headless primitives. It targets .NET 8 across Server, WebAssembly, and Auto render modes, with full accessibility (ARIA, keyboard navigation), theming via CSS custom properties (compatible with shadcn CSS variables), and zero Tailwind/Node setup. The library is split into two layers: Primitives (headless, behavioral components with focus management, positioning, and portal services) and Components (styled, ready-to-use widgets like DataGrid, charts, forms, dialogs, and navigation). It ships with four icon libraries (5,200+ icons) and 11 chart types via Apache ECharts. The architecture emphasizes composability through cascading contexts, a consistent form-field pattern, and a utility-first approach with the ClassNames.cn helper for Tailwind class merging. The codebase demonstrates strong engineering practices: extensive use of generics, expression trees for filtering, JS interop with guarded disposal, and a localization system with 200+ string keys. However, the large API surface, heavy JS interop, and limited test coverage (only a few unit tests for DataGrid and hierarchy utilities) present maintenance risks.
This is a small, focused Go library that automatically sets the GOMEMLIMIT environment variable for Go applications based on the Linux cgroup memory limit. It provides a simple side-effect import (import _ "github.com/KimMachineGun/automemlimit") that configures the Go runtime memory limit to a configurable fraction (default 90%) of the cgroup limit, or alternatively offers a programmatic API via memlimit.Set() with options for custom providers, ratios, minimum limits, and periodic refresh. The library handles both cgroup v1 and v2, correctly resolving the effective memory limit from the cgroup hierarchy, including handling of conflicting mounts, unlimited memory sentinels, and fallback to system memory. It is not a hybrid; it is purely an application library.
This repository implements a system to use NVIDIA GPU VRAM as swap space on Linux via the NBD (Network Block Device) protocol. The core component is a userspace daemon (nbd-vram) that allocates VRAM using the CUDA driver API and serves it as a block device over a Unix socket. The Linux kernel's NBD driver connects to this socket, exposing /dev/nbdX as a swap device. The system includes scripts for connection/disconnection, power management (automatically disabling swap on battery), and proper handling of suspend/resume to avoid GPU-related deadlocks. Key features include memory locking to prevent the daemon from being swapped out, using PR_SET_IO_FLUSHER to avoid deadlocks under memory pressure, and multi-threaded request batching to amortize CUDA synchronization overhead. The solution works with any CUDA-capable NVIDIA GPU without requiring kernel modifications or NVIDIA's P2P API, which is restricted to professional GPUs.
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.
Jitendex is a C# rewrite of the build system for a free, offline Japanese-to-English dictionary. It is fundamentally a multi-stage ETL pipeline: raw dictionary archives (JMdict, JMnedict, Kanjidic2, KanjiVG, Tatoeba, CHISE) are imported into SQLite databases, processed into a unified dictionary model with patches, furigana, headwords, cross-references, and integrity checks, then exported for use in Yomitan and MDict. The README explicitly states the rewrite is under construction and not yet production-ready; the legacy Python system still produces published releases. Despite that caveat, the codebase is a serious software engineering effort rather than research code, with console entry points, dependency injection, unit tests, and a modular library structure.
Patina is a local-first desktop time tracking application built with the Tauri framework (React frontend + Rust backend). It automatically monitors foreground application and web usage, providing activity classification, data visualization through dashboards and heatmaps, productivity tools (Pomodoro timer, reminders), and data export/backup capabilities. The application emphasizes privacy with local-first data storage while offering optional remote backup via WebDAV. It features a modular architecture with clear separation between frontend/UI, backend/services, and platform abstractions, communicating through Tauri IPC.
ESBMC (Efficient SMT-based Bounded Model Checker) is a mature, open-source formal verification tool that automatically detects or proves the absence of runtime errors in C, C++, Python, Java/Kotlin (via Jimple), CHERI, and Solidity programs. It parses source code using language-specific frontends (Clang for C/C++, CPython parser for Python, Soot for Java), converts programs into a common GOTO intermediate representation, and performs bounded symbolic execution with SMT solving (Z3, Bitwuzla, CVC5, Yices, etc.). The tool checks for assertions, memory safety (buffer overflows, null pointers, use-after-free), arithmetic overflows, concurrency races, and user-defined contracts (requires/ensures/assigns). It supports advanced verification techniques including k-induction, loop invariant synthesis, incremental BMC, and quantifier reasoning. The architecture is modular: frontends produce GOTO programs, which are then processed by a series of analysis passes (pointer analysis, value-set analysis, loop unrolling, contract enforcement) before being encoded into SMT formulas. The solver backend is pluggable, with support for interactive solvers and experimental one-shot solvers (Mallob, NeuroSym). The repository includes an extensive regression test suite with thousands of small, self-contained test cases organized by language and feature, many with paired passing/failing variants to ensure soundness. Operational models for C standard library functions, C++ STL, Python standard library (including numpy), and SystemC are bundled as source code for SMT translation. Key entry points include the main ESBMC binary (built from `src/esbmc/`), the Clang C/C++ frontend (`src/clang-c-frontend/`), the Python frontend (`src/python-frontend/`), and the solver interfaces (`src/solvers/`). The tool is actively used in research and industry, has won 43 awards at SV-COMP and Test-Comp, and is supported by multiple funding agencies. External dependencies include Boost (program_options, filesystem), Clang/LLVM, and several SMT solvers.
The Universal Transition Shader is a Godot shader that provides a wide variety of transition effects (wipes, fades, masks, shapes, and clock wipes) with extensive customization options. It uses a grid system to allow for complex patterns like staggering, mirroring, and cell-based animations. The shader is self-contained and can be applied to any CanvasItem in Godot, making it a reusable tool for game developers and creators.
traefik-kop is a dynamic service discovery agent that bridges Docker containers and Traefik reverse proxy via a Redis store. It runs as a container or service with access to the Docker socket, monitors container events (and polls for missed events), extracts Traefik-relevant labels (with support for custom prefixes and namespaces), and writes the corresponding service configuration to Redis in a format consumable by Traefik's Redis provider. The application handles IP address resolution (including host IP, container network IPs, and user-specified overrides), port mapping from container to host ports, and supports features like load balancer merging across multiple nodes and Redis Sentinel for high availability. Built in Go, it leverages the Traefik library's Docker provider architecture but extends it to persist configuration to Redis instead of direct Traefik integration, enabling multi-host Docker environments to share a single Traefik instance for ingress.