Runtipi is a self-hosted homeserver orchestrator: a web-based control plane for installing, updating, backing up, and managing Docker Compose applications on a single server. In production it runs as a NestJS backend, a React frontend, and a shared TypeScript schema package, with PostgreSQL as the primary datastore, RabbitMQ for asynchronous job queues, Dockerode for container control, and Traefik as the reverse proxy and TLS/forward-auth gateway. The app-store model clones external git repositories containing app manifests and compose definitions, then validates and renders them through a dynamic form system. The architecture is a monolithic backend organized around modules for app lifecycle, marketplace, app stores, backups, auth, links, settings, and i18n; long-running operations are executed through a command/handler pattern with per-app async mutexes and schema-validated RabbitMQ event queues.
This repository, NVIDIA-NeMo/Skills, is a production-grade framework for evaluating, training, and serving large language models (LLMs), with a strong emphasis on reasoning (math, code, proofs), tool calling, and speech tasks. It provides a CLI (`ns`) that orchestrates distributed pipelines for synthetic data generation, model inference across multiple backends (vLLM, SGLang, TensorRT-LLM, Megatron, OpenAI-compatible APIs), evaluation on 80+ benchmarks (e.g., AIME, SWE-bench, MMLU, BFCL), and reinforcement learning (GRPO, PPO, SFT). The architecture is built around reusable abstractions: configurable dataset preparers, prompt templates, metric collectors, inference servers, code execution sandboxes, and MCP-based tools, all integrated with Slurm/Ray cluster management. While the core is an application toolkit, it also contains numerous research recipes (e.g., OpenMathReasoning, SHERLOC, Nemotron-IMO-TTS) that exemplify its use in generating training data and reproducing published results. The codebase is well-structured with unit tests, GPU integration tests, and Slurm CI, though some components have hardcoded paths and dependencies that limit portability outside NVIDIA's infrastructure.
EldoraUI is a React UI component library built on the shadcn/ui registry pattern, providing a collection of animated, design-focused components for Next.js applications. The repository includes a documentation site (Next.js, Fumadocs, MDX) that showcases components, blocks (pre-built landing page sections), and templates. The library offers a wide range of components: text animations, device mockups (MacBook Pro, iPhone, iPad, Safari browser), background effects (3D globe, hacker background, photon beam), interactive cards, marquee scrolls, and more. Components are distributed via a CLI (npx eldoraui add) using the shadcn registry schema, allowing users to copy source code directly into their projects. The codebase demonstrates strong use of modern frontend patterns (Radix UI primitives, motion animations, Tailwind CSS v4, TypeScript strict mode) and is organized as a pnpm monorepo with Turbo pipelines for building and testing.
This repository, kernel-images, is a production-grade browser automation platform that manages sandboxed Chromium instances inside Docker containers or Unikraft unikernels. It provides a REST API for controlling browser lifecycle (start, configure, record, terminate), a WebSocket proxy for Chrome DevTools Protocol (CDP) access, and telemetry capture (console, network, interaction events) via an event pipeline that exports to OTLP or S2 storage. The system supports headful and headless modes, with a Vue.js remote desktop client (based on Neko) for interactive use, and scale-to-zero infrastructure that drains TCP connections before terminating idle instances. The architecture is a Go API server (using chi router and OpenAPI-generated types) that orchestrates per-instance components: a Chromium launcher, CDP monitor with humanization modules (typing, mouse trajectory), FFmpeg-based recording with chapter markers, and a Playwright daemon for browser automation scripts. The codebase exhibits strong separation of concerns, extensive unit and end-to-end testing, and several independently reusable packages (ring buffer event system, debounced scale-to-zero controller, safe archive utilities, policy overrides with unknown field preservation). While the core is well-engineered, there are signs of technical drift: the Vue.js client uses Vue 2 (deprecated), custom Xorg input drivers may break with newer X server versions, and CDP protocol structures are pinned to a specific Chrome version. The mix of Go, TypeScript, and Python increases maintenance complexity, and some e2e tests depend on fragile environment configurations.
This repository implements a cycle-accurate NES/Famicom console on FPGA, targeting the MiSTer platform. The core is written in Verilog/SystemVerilog with some VHDL, integrating a 6502 CPU (T65 core), PPU with composite video output, APU with expansion audio support, and dozens of cartridge mappers (MMC1-5, VRC1-7, FDS, Namco163, Sunsoft, etc.). It provides a complete hardware video/audio pipeline including scanlines, gamma correction, scandoubling, HQ2x scaling, and HDMI output. The system supports save states, cheat codes, zapper light gun, multiplayer adapters, and the Family BASIC keyboard. The codebase is well-structured with a modular mapper interface and a generic savestate bus pattern, though it is tightly coupled to the MiSTer platform (Cyclone V FPGA, HPS interface). It is an actively maintained core in the MiSTer ecosystem, with frequent releases and community contributions.
Cage is a minimal Wayland kiosk compositor that runs a single application maximized, built on the wlroots library. It manages outputs, seats, input devices, and supports both XDG shell and XWayland surfaces. The compositor handles multi-monitor configurations (extend or last-only mode), idle inhibition, virtual keyboards/pointers, and cursor shape management. It is designed for kiosk use cases where user interaction is restricted to the running application. The codebase is written in C11 and uses the Meson build system. It follows a modular architecture with separate modules for output management, seat/input handling, view abstraction, and shell-specific implementations (XDG and XWayland). The view system employs a clean interface pattern (cg_view_impl) for polymorphism, allowing different surface types to be managed uniformly. The compositor integrates deeply with wlroots, leveraging its scene graph, output layout, and protocol implementations. Cage serves as a practical reference for building wlroots-based compositors, demonstrating proper initialization, event handling, and cleanup patterns. It includes CI configuration for multiple compilers and static analysis. The project is actively maintained with a focus on stability and adherence to Wayland protocols.
Ruplacer is a command-line tool written in Rust for finding and replacing text in files. It supports literal string, regex, and case-preserving replacements, and provides a diff-like output of changes. The tool respects .gitignore, allows filtering by file type, and can operate in a dry-run mode. The architecture is modular, with separate modules for argument parsing, console output, directory traversal, file processing, and the core replacement logic. The replacement logic is particularly notable for its use of the strategy pattern to handle different matching algorithms in a uniform way.
This repository is the official source for "The Swift Programming Language" (TSPL), Apple's book on Swift, published at docs.swift.org. It is not a conventional runtime application or data pipeline; it is a documentation source tree in Apple's DocC format, containing markdown chapters for a guided tour, the language guide, the formal reference manual, revision history, and supporting static assets. The repo's only executable code lives in bin/, where small shell, awk, and Swift scripts handle publication workflows such as grammar extraction, beta banner insertion, preflight validation, and legacy URL redirect generation. The architecture is a content catalog (TSPL.docc/) plus a set of publication scripts. The documentation itself is unusually well-crafted for technical writing: semantic line breaks for clean diffs, swifttest code blocks that are validated against the compiler, formal BNF grammar blocks, consistent cross-referencing via <doc:...> links, and a detailed style guide. The bin/ directory contains the only software components; these are small, mostly self-contained, and focused on the specific book publication process. There is no unit test suite or CI pipeline for the content, but correctness is supported by embedded test directives and a manual preflight script. Classification is forced into "application" because the repository has no data/research characteristics. In practice it is a technical documentation repository with build-script components. Reuse value is concentrated in the standalone redirect generator, the grammar extraction awk script, and the DocC documentation patterns—not in application logic. The content is actively maintained and tracks current Swift versions, though a few scripts are brittle and some redirect mappings are marked as incomplete.
FirebaseUI-Android is an open-source library providing pre-built UI components for Firebase Authentication, Realtime Database, Cloud Firestore, and Cloud Storage. It is a multi-module Android library published on Maven Central. The primary module, `firebase-ui-auth`, has been rewritten in Jetpack Compose with Material 3, offering a high-level composable (`FirebaseAuthScreen`) and a Kotlin DSL for configuration. It supports 12+ identity providers (Google, Facebook, Email, Phone, Apple, etc.), multi-factor authentication (SMS/TOTP), credential linking, anonymous upgrade, and email link sign-in. The `firebase-ui-database` and `firebase-ui-firestore` modules provide RecyclerView adapters with paging support (AndroidX Paging 3) for displaying Firebase data. The `firebase-ui-storage` module integrates with Glide for loading images from Firebase Storage. A demo app and end-to-end tests against the Firebase Auth Emulator are included. Architecturally, the library is split into separate Gradle modules: `auth`, `database`, `firestore`, `storage`, `common`, and `lint`. The auth module uses Kotlin coroutines, StateFlow, and a sealed class state machine (`AuthState`) to manage authentication flows. The database/firestore modules are older Java-based implementations using lifecycle-aware adapters and observable arrays. The library maintains a version catalog (libs.versions.toml) with modern dependencies (Kotlin 2.4.10, AGP 9.3.0, Compose BOM 2026.06.01). Key entry points include `FirebaseAuthScreen` (Compose), `FirebaseAuthUI` (singleton for sign-out/delete/auth state), `AuthFlowController` (Activity-based alternative), `FirebaseRecyclerAdapter`/`FirestoreRecyclerAdapter`, and `FirebaseImageLoader` (Glide integration). The primary data flows involve Firebase SDKs for authentication, database listeners, and image loading. The library is designed to be embedded in host Android apps, handling complex auth flows with minimal developer effort. The codebase demonstrates strong craftsmanship in the auth module’s state machine and Compose UI, but shows signs of technical drift due to mixed UI generations (legacy XML layouts alongside new Compose), some deprecated API usage (e.g., `fetchSignInMethodsForEmail`, `startActivityForResult`), and incomplete localizations. The database/firestore modules are mature but use older patterns. Overall, the library is well-structured and actively maintained, with a beta version (10.0.0-beta04) indicating ongoing development.
Orchestra is a mature, composable WPF application framework for building line-of-business desktop applications on .NET (net8.0-windows through net10.0-windows). It provides a complete shell infrastructure including splash screens, about dialogs, crash recovery, keyboard shortcut customization, changelog viewers, status bars, busy indicators, and recently-used item management. The framework is built on top of Catel (MVVM, IoC, logging) and integrates with Orc.* libraries for theming, controls, and system information. It offers two shell variants: a Ribbon.Fluent shell using Fluent.Ribbon for rich ribbon UIs, and a TaskRunner shell for simpler task-oriented interfaces. The architecture is modular and service-oriented, with all major features exposed via interfaces (e.g., IShellService, IStatusService, IKeyboardMappingsService) and registered through Microsoft.Extensions.DependencyInjection. The core library (Orchestra.Core) contains the foundational services, while shell-specific packages (Orchestra.Shell.Ribbon.Fluent, Orchestra.Shell.TaskRunner) provide concrete implementations. The framework also includes a shared shell library with recovery services, progress bars, and configuration management. Key entry points include the ShellService for application lifecycle orchestration and the ApplicationInitializationServiceBase for custom startup logic. External dependencies include Catel (7.x), Fluent.Ribbon (11.x), ControlzEx, and several Orc.* packages (Orc.Theming, Orc.Controls, Orc.LogViewer, Orc.SystemInfo). The build system is powered by Cake scripts with support for multiple installer formats (InnoSetup, MSIX, Velopack), code signing, and CI/CD integration. The repository also includes example applications demonstrating both shell variants and a comprehensive test suite with public API verification. Data flows are primarily user-driven: application startup triggers splash screen, configuration loading, shell creation, and keyboard mapping initialization. User interactions (closing, keyboard shortcuts, status updates) are handled through service abstractions. The framework manages local user data (configuration backups, changelog snapshots, recently used items) but does not process external datasets or analytics.
Hippy is a cross-platform mobile application framework developed by Tencent that enables developers to build native mobile apps using JavaScript with React or Vue. It provides a JS driver layer that communicates with native renderers on Android, iOS, OpenHarmony, and Web via a bridge system. The architecture is modular: a DOM layer manages the virtual tree and layout (using Taitank or Yoga), native renderers create platform-specific UI components, and a virtual file system (VFS) handles resource loading. The framework includes a full devtools backend implementing Chrome DevTools Protocol for debugging, performance monitoring, and DOM inspection. Key entry points include the JS bootstrap (hippy.js), native engine managers (HippyEngine on Android, HippyBridge on iOS), and the JS framework adapters (hippy-react, hippy-vue, hippy-vue-next). External dependencies include V8, Hermes, JSC, or JSH JavaScript engines, and platform-specific SDKs (AndroidX, UIKit, ArkUI). The codebase is large and actively maintained, with multiple renderer implementations and both Vue 2 and Vue 3 support, though some duplication and deprecated code exist.
openlibrary-client is a reference Python client library for the Open Library API, maintained by the Internet Archive. It provides object-oriented models for books, authors, editions, works, and covers, wrapping the REST endpoints behind a simple client class. The library supports cookie-based authentication, read/fetch operations, and write operations such as creating new works and editions. It also includes utilities for parsing MARC dump lines and validating book import schemas, making it useful beyond simple API access.
coreaudio-rs is a Rust library providing safe, zero-cost bindings to Apple's CoreAudio API, with particular focus on Audio Unit functionality. The library wraps the complex C API in Rust abstractions that maintain type safety and memory safety while preserving performance. It enables Rust developers to work with audio input/output, audio processing, and hardware interaction on Apple platforms (macOS, iOS, tvOS, visionOS). The architecture follows a modular library design with core functionality in src/, platform-specific helpers in src/audio_unit/macos_helpers.rs, and comprehensive examples demonstrating usage patterns. The library relies on the objc2 crate family for Objective-C interoperability and bitflags for flag management. Data flows involve audio buffers moving between hardware devices and AudioUnit instances through callback mechanisms, with configuration flowing from Rust definitions to the CoreAudio API. Entry points include the main library interface in src/lib.rs, the AudioUnit constructor and methods in src/audio_unit/mod.rs, and platform-specific initialization helpers. The examples directory provides practical demonstrations of audio playback, input/output streaming, and advanced audio unit configuration.
This repository is an Electron desktop application that boots a genuine Windows 95 installation inside the v86 x86 emulator. The main process coordinates window creation, menus, settings, and file serving, while the renderer runs the emulator and a React-based Windows 95-styled UI. The guest OS is fully functional, and the app provides integration features such as a host-folder SMB share, clipboard synchronization via the VMware backdoor protocol, guest TCP relay through the host network, and a custom DNS shim so the old OS can reach modern services. The architecture is a classic Electron main/renderer split. The main process handles lifecycle concerns: windows, menus, IPC, settings persistence, auto-update, and a small HTTP file server that delivers web content to the guest. The renderer is where most of the interesting work happens: it embeds v86, manages disk images and saved states, and hosts several reverse-engineered network subsystems, including a read-only SMB1/CIFS server, NetBIOS framing, NBNS responses, and a TCP relay. A guest agent (W95TOOLS.EXE) runs inside Windows 95 to synchronize the clock, map the SMB drive, and bridge the clipboard. The codebase is a mix of carefully engineered TypeScript modules and large vendored/minified emulator code. The custom protocol implementations are genuinely impressive and relatively self-contained, though they are tightly coupled to v86's bus architecture and Windows 95's quirks. Building and releasing the app depends on private disk-image artifacts, a patched v86 fork, and a custom guest toolchain, making full reproduction from source impractical for outsiders, but the app itself is stable and actively maintained. Overall, it is a strong example of combining an emulator project with a polished desktop UI and clever protocol engineering.
This is a React-based single-page application that converts Excalidraw drawings into animated SVGs. It provides both an editing mode (using the Excalidraw library) where users can configure animation order and duration per element, and an animate mode where the resulting SVG is rendered with playback controls (play/pause/step/reset). The core animation logic is implemented using SMIL (SVG animations), patching SVG elements with `animate`, `animateMotion`, and `textPath` elements. Users can load drawings from files, libraries, or shareable URLs. The app also exports to SVG and WebM (via screen capture). It is published as an npm package for programmatic use, exposing `animateSvg`, `getBeginTimeList`, and export utilities. The codebase is modern (React 19, TypeScript, Vite) and includes comprehensive testing with Playwright. Architecturally, it operates as a client-side SPA with two views (edit and animate) and a toolbar for loading/playback/export.
Pipelight is a Rust-based CLI tool for defining and running automation pipelines. It allows users to create pipelines using TOML, YAML, HCL, or TypeScript configurations, trigger them via git hooks or file system changes, and monitor their execution. The architecture follows a modular design with separate crates for CLI parsing, workflow execution, configuration casting, process management, and utilities. Key features include process detachment for background execution, output capture for post-execution inspection, git hook integration, and file watching capabilities. The project demonstrates strong engineering practices with comprehensive error handling, cross-platform considerations, and thoughtful UX design for terminal interactions.
envio is a Rust CLI tool for managing environment variables in encrypted profiles. It creates, edits, imports, exports, and deletes profiles stored as `.envio` files in a project's `.envio/profiles` directory. The profiles can be plaintext or encrypted using passphrase (Argon2id + XChaCha20Poly1305), symmetric key (base64-encoded 32-byte key + XChaCha20Poly1305), or GPG (delegates to the system `gpg` CLI). The tool integrates with the OS keyring to store encryption keys and provides both a command-line interface and a TUI (beta) built with ratatui. The architecture cleanly separates library code (profile, cipher, env map) from binary code (CLI, TUI, prompts). The library is reusable for other Rust projects needing profile-based encrypted env management, though cipher types are somewhat coupled to the crate's error types. The encryption implementations demonstrate solid security practices (Argon2id password hashing, XChaCha20Poly1305 AEAD with streaming). The CI/CD pipeline builds for multiple platforms and generates shell completions and man pages at compile time. The project lacks unit tests in the visible source tree, which is a notable gap.
weDocs is a WordPress plugin that adds comprehensive documentation and knowledge base management to any WordPress site. It registers a hierarchical 'docs' custom post type with a parent-section-article structure, allowing users to create, organize, and display documentation with modern editor blocks (search, grid, sidebar, table of contents, breadcrumbs, reading progress, etc.) and Elementor widgets. The plugin provides a full-featured React-based admin dashboard for managing docs, FAQs, and settings, including drag-and-drop reordering, inline editing, migration from BetterDocs, AI-powered content generation (via OpenAI, Anthropic, Google Gemini), and analytics (view counting, helpfulness votes). It follows a freemium model with pro features gated behind license checks and preview overlays. The codebase demonstrates strong engineering practices: extensive E2E tests with Playwright, modular PHP classes, reusable block controls and shared UI components, and efficient REST API endpoints with aggregate SQL queries. However, it has some code duplication (e.g., duplicate commonControls in two directories), reliance on experimental WordPress APIs, and large inline CSS/JS in PHP render outputs, which prevent it from being exceptional. Overall, it is a well-maintained, production-ready plugin with reusable patterns suitable for other WordPress block plugins.
This is a Redmine plugin that allows administrators to define custom Ruby scripts that execute on lifecycle events (before_save, after_save, before_destroy, after_destroy, etc.) for various Redmine objects such as Issue, User, Group, Project, Attachment, TimeEntry, Version, WikiContent, and more. It uses Rails monkey-patching (prepend) to inject callbacks into Redmine models and controllers, and executes user-defined scripts via `instance_eval` in the context of the observed object. The plugin provides a web UI for managing workflows, supports import/export via XML, and includes a custom mailer for sending emails from workflows. It is well-structured, has comprehensive tests, localization support, and CI integration. The codebase is mature and actively maintained, targeting Redmine 6.x and Rails 8.1.
This repository is the JetBrains Godot Support plugin, a multi-language IDE extension for IntelliJ IDEA and Rider that provides comprehensive GDScript language intelligence, scene editing, debugging, and project integration for the Godot game engine. It consists of several modules: a Kotlin-based GDScript language plugin with custom lexer/parser, PSI, annotations, inspections, refactoring, formatting, code completion, and LSP client; a C# debugger worker that allows inspecting Godot scenes during debugging with optimized bulk-fetch strategies; a C++ native addon (GDExtension) for bidirectional communication between the IDE and Godot editor; a PHP toolchain to generate SDK metadata from Godot's official XML documentation; and .NET ReSharper components for C# Godot project support. The plugin uses JetBrains' PolySymbols framework for unified symbol resolution and has an extensive test suite covering parsing, type inference, inspections, and debugger integration. While deeply integrated with JetBrains platform APIs and generated code, the debugger worker's child-chunking algorithm and SDK fingerprinting utility are well-crafted, self-contained components that could be reused in other contexts. The codebase is actively maintained with regular commits, but relies on several internal/experimental APIs and snapshot dependencies, posing moderate technical drift risk.