Bazzite is a custom Fedora Atomic (Silverblue/Kinoite) operating system image optimized for gaming on desktops, handheld PCs (Steam Deck, ROG Ally, etc.), and HTPCs. It provides a SteamOS-like experience with pre-installed gaming tools (MangoHud, vkBasalt, OBS VkCapture), hardware support (OGC kernel, HDR/VRR, DisplayLink, per-device audio profiles), and a suite of system management utilities. The repository is not a traditional application but a build system for generating container images and ISOs. The architecture is container-native: images are built via Containerfile and GitHub Actions, with modular overlays for different variants (desktop, deck, nvidia) and desktop environments (GNOME, KDE). Key components include a justfile recipe library for user-facing configuration (ujust), systemd services, udev rules, RPM spec files with patches for upstream packages (BlueZ, UPower, Xwayland, MangoHud), and hardware detection scripts. The build process is fully automated via CI/CD, with image signing and attestation. The project is actively maintained with a large community and extensive hardware support.
OpenSheetMusicDisplay (OSMD) is a TypeScript library for rendering MusicXML sheet music in web browsers. It parses MusicXML files, builds an internal musical data model, and renders it to SVG or Canvas using a heavily customized fork of VexFlow. It is the de facto standard open-source library for this specific task in the JavaScript ecosystem, supporting an interactive cursor, transposition, braille music output, and a wide range of MusicXML features (slurs, ties, dynamics, tablature, percussion, repeats, etc.). The codebase is notable for its extensive test suite covering hundreds of edge cases in music engraving. The architecture follows a strict pipeline: MusicXML parsing (MusicSheetReader) -> Internal Model (MusicSheet, VoiceData) -> Layout Calculation (VexFlowMusicSheetCalculator, SkyBottomLineCalculator) -> Rendering (VexFlowMusicSheetDrawer, SvgVexFlowBackend). The primary strength is its unmatched domain coverage for MusicXML rendering in the browser. The primary weakness is its tight coupling to a vendored and heavily patched fork of VexFlow (src/VexFlowPatch/), which creates significant technical debt and makes upgrading the rendering engine difficult. The codebase shows signs of organic growth with a large central configuration object (EngravingRules) and some brittle pixel-based tests.
This repository implements a lightweight, self-hostable web service that serves SVG badges displaying GitHub profile view counts. The core logic is a single PHP entry point (`public/index.php`) that parses query parameters (username, label, color, style, base count, abbreviation flag), increments a view counter via a repository abstraction, and renders a badge image using the Poser library. The architecture follows a clean separation of concerns: value objects (`Username`, `Count`) enforce validation, a repository interface (`CounterRepositoryInterface`) abstracts storage, and a factory (`CounterRepositoryFactory`) selects between file-based or PDO-based persistence based on environment configuration. The file repository includes careful file locking to handle concurrent requests safely. The service is designed to be deployed via Docker with Nginx and PostgreSQL, but can also run with simple file storage for minimal setups. External dependencies are minimal and pinned via Composer. The code is well-structured, uses strict types, and demonstrates solid PHP engineering practices for a small service.
IT-Tools is a single-page application (Vue 3 + TypeScript + Vite) that provides a curated collection of over 80 client-side developer utilities. These utilities include hashing, encoding, formatting, conversion (JSON, YAML, TOML, XML, etc.), crypto (JWT, RSA, bcrypt), network tools (IP subnet calculator, MAC address lookup), text manipulation, and many others. All processing occurs entirely in the browser; there is no backend. The app is a monolith with lazy-loaded per-tool routes, using a custom UI component library (c-*) alongside Naive UI, Pinia for state, vue-i18n for translations, and VueUse composables. It is containerized (Docker) and can be self-hosted or used via the hosted version on Vercel/Netlify. The repository demonstrates a strong convention for tool definition, testing, and internationalization, though tool quality varies. It is not a data research or analytics project.
EdgeVPN is a decentralized peer-to-peer VPN built on libp2p. It creates private mesh networks by bootstrapping nodes via DHT, mDNS, and optional relays. A blockchain-like distributed ledger (pkg/blockchain) synchronizes network state—machine lists, services, DNS records, file announcements—across all nodes, with write-integrity enforced by signed entries and ownership modes. The VPN layer (pkg/vpn) creates a TUN interface and routes packets based on the ledger's machine table. Additional features include TCP service tunneling, HTTP proxy/egress, DNS resolution, file transfer, and an embedded React management dashboard (api/react-ui). The primary entry point is the CLI (cmd/app.go), which supports commands for starting the node, managing services, and accessing the API. The architecture is fully decentralized; there is no central server. External dependencies include libp2p for networking, Echo for the HTTP API, and standard Go libraries. The codebase demonstrates solid software engineering with functional options, modular packages, and integration tests, though some features remain experimental and test coverage is uneven.
This is an Ansible role and playbook collection that automates the hardened installation of the OpenClaw messaging gateway on Debian/Ubuntu Linux systems. It provisions a dedicated system user, installs Docker CE with UFW-based firewall and DOCKER-USER chain isolation, configures fail2ban and unattended-upgrades, sets up Node.js and pnpm, and installs OpenClaw either from npm (release mode) or from a Git checkout (development mode). The role does not configure the application or install its systemd service—those steps are left to the operator via `openclaw onboard --install-daemon`. It supports remote deployment via inventory and includes CI tests for syntax, linting, and integration. The codebase is well-structured, security-conscious, and actively maintained, though it does not contain independently extractable components suitable for reuse outside this project.
MultiMC is a mature, cross-platform desktop application written in C++/Qt that manages and launches multiple Minecraft instances. The code implements a complete launcher stack: instance creation/import/export and modpack management (Modrinth, Technic, ATLauncher, legacy FTB), Microsoft/Mojang account authentication via OAuth device flow, per-instance component profiles (Forge/Fabric/Quilt/NeoForge/LiteLoader), Java discovery/validation, asset/library download with an HTTP metacache and checksum validators, a composable launch pipeline, and a self-updater. The UI is organized around a Qt Widgets page/dialog system with global and per-instance settings pages and a custom instance grid view. The architecture is a conventional monolithic desktop application but is modularized internally into subsystems: tasks, network jobs, settings, metadata, auth, mod platforms, and UI pages. Main entry point is launcher/main.cpp, which boots Application and communicates through a centralized singleton; the command line supports --launch, --import, --server, --world, --offline, and single-instance peer forwarding. External dependencies include Qt 5, CMake, an extensive set of vendored libraries (katabasis for OAuth, classparser for Java class files, xz-embedded, hoedown, tomlc99, systeminfo), and remote services such as Mojang, Microsoft/Xbox Live, Modrinth, ATLauncher, Technic, Imgur, and paste.ee. The codebase is not a data pipeline; however it contains meaningful offline parsers (JSON, TOML, NBT, Java class files, INI) and test fixtures that are relevant to anyone working with Minecraft mod formats.
Jotty is a self-hosted, file-backed notes/checklists/Kanban productivity application built on Next.js App Router, React 19, and TypeScript. Data is stored as Markdown files with YAML frontmatter under a data/ directory: notes and checklists are flat files, users/sessions/settings are JSON files, and a SQLite relations database indexes wikilinks, backlinks, and mentions. The app provides rich TipTap-based editing (tables, Mermaid, code blocks, Excalidraw/draw.io), a Kanban board with timers and time tracking, the 'Brain' 2D/3D force-graph visualization of item relations, granular sharing with inherited permissions and public links, PGP/XChaCha note encryption, audit logging, OIDC/LDAP/MFA authentication, and an admin panel. A companion MCP server (mcp-server/) wraps the REST API for AI-agent integration. Architecture is a hybrid: server actions handle all mutations with a consistent auth, permission check, data operation, audit log, WebSocket broadcast flow, while a contract-driven REST API layer (defineRoute + Zod schemas + generated OpenAPI spec) exposes read/write operations for external clients. Concurrency is managed via per-item lanes and single-flight helpers to protect flat-file writes. The frontend is client-heavy with many feature components (Notes, Checklists, Kanban, Brain, Admin) built on a reusable global UI kit (Modal, Input, Dropdown, Cards, Toasts) and Zustand/context providers. The codebase shows genuine engineering care: 100+ test files including dedicated security suites for path traversal, cross-user UUID access, shell injection, and actor spoofing; atomic file writes; timing-safe API key comparisons; and path fencing wherever user input touches the filesystem. However, it is a large monolith with notable debt: SHA-256 (unsalted) password hashing, shell-out grep/sed utilities for search and frontmatter extraction, duplicated client/server utilities, legacy migration paths, and scattered type casts. The maintenance trajectory is active (frequent releases, tags, CI workflows), and the code is valuable to study for its server-action conventions, permission model, and security hardening despite the sprawl.
SLRP is a rotating open proxy multiplexer that automatically discovers, validates, and rotates proxies from dozens of online sources. It runs as a single Go binary with an embedded Web UI and provides both a REST API and an MITM HTTP/HTTPS proxy endpoint. Internally, it uses a modular architecture with components for source scraping, proxy checking, pool management, request history recording, and IP geolocation. It features a custom query language for filtering proxy pool, history, and blacklist data, and includes a code generator to create type-safe dataset accessors from Go struct definitions. The system persists state to disk and can be configured via YAML or environment variables.
vue-promised is a small Vue library that removes boilerplate around rendering asynchronous state. It exposes two public APIs: `usePromise`, a composition-api function that watches a promise (or a Ref to one) and returns reactive refs for `data`, `error`, `isPending`, `isResolved`, `isRejected`, and `isDelayElapsed`; and `Promised`, a component that renders `pending`, `default`, `rejected`, or `combined` scoped slots based on that state. Both are built on `vue-demi`, so the same package works with Vue 2 (with @vue/composition-api) and Vue 3. In production the code solves two real problems: stale async updates are discarded by comparing the currently watched promise to the promise that settled (an identity check rather than a cancellation token), and a configurable `pendingDelay` prevents loading spinners from flashing on fast requests. Old resolved data is preserved while a new promise is pending, so UIs can render "refreshing" states without losing previous content. The implementation is deliberately small: the entire runtime is `src/usePromise.ts` and `src/Promised.ts`, with tests covering slot rendering, delay timing, timeout cancellation, and promise cancellation. The repository is a library rather than an application or data pipeline. It includes a docs Vite app, API Extractor config for d.ts rollup, size-limit checks, and CI with unit tests. Dependencies have been partially modernized, but the npm package has remained at 2.2.0 since 2021 and some test tooling (Vitest 0.31, Prettier 2.8, TypeScript 5.0) lags current releases, giving the project a medium technical drift.
rspirv is a Rust workspace providing comprehensive SPIR-V module processing functionality. It includes a core library (rspirv) with a low-level data representation (DR) for raw instructions and a higher-level structured representation (SR) with type-safe indices. The project also features a binary parser, an assembler, a disassembler CLI (rspirv-dis), and a code generator (rspirv-autogen) that derives Rust types from the official SPIR-V JSON grammar. The parser supports custom consumers via the Consumer trait, enabling streaming or custom processing. The builder (dr/build) allows programmatic construction of SPIR-V modules. The lift module converts from DR to SR, bridging the two representations. The codebase is heavily auto-generated from the SPIR-V specification, ensuring spec compliance, but this also introduces risks of drift if the grammar submodule is not updated. The project is actively maintained with CI/CD pipelines, and the multi-crate workspace is designed for both library reuse and standalone tool usage.
apkeep is a Rust command-line application for downloading Android APK packages from Google Play, F-Droid, and APKPure. It accepts single app IDs or CSV batch lists, optionally with version fields, lists available versions in plaintext or JSON, and downloads in parallel with configurable concurrency and sleep throttling. Google Play is the default source and uses the gpapi crate with OAuth/AAS/AUTH token flows, device profiles, split APKs, OBB additional files, and DexMetadata. F-Droid downloads are backed by cryptographically verified repository indexes (CMS/X.509 fingerprint and SHA-256 digests) with ETag caching; APKPure is deliberately gated behind an explicit danger-acknowledgment flag. Architecturally this is a modular async CLI: src/main.rs handles clap parsing, CSV parsing, ini config loading, and dispatch; each backend in src/download_sources exposes download_apps and list_versions and uses futures_util::buffer_unordered for bounded concurrency with indicatif progress bars. The code is readable and well separated, but it has no test suite, leans heavily on unwrap/process::exit for error handling, and repeats the three-retry download pattern in every source. The strongest engineering is in the F-Droid index verification and cache logic, which is non-obvious and hard to get right.
NippleJS is a vanilla virtual joystick library for touch and mouse interfaces, designed for mobile games, remote controls, and interactive web applications. The core library in `packages/nipplejs/` provides a lightweight, dependency-free joystick with three modes (dynamic, semi, static), multitouch support, and extensive event-driven APIs. The architecture is built around a Factory singleton managing Collections, each of which manages multiple Joystick instances. The library is written in TypeScript, with thorough unit tests and Playwright end-to-end tests covering event accuracy, mode behavior, cleanup, and edge cases. The repository also includes a documentation site built with Astro, featuring five interactive game demos that showcase library features, along with a monorepo structure for tools and tests. While the core library is modern and well-tested, some tooling (ESLint 8, Husky v4) and the workspace Yarn version mismatch indicate minor technical drift.
Reall3dViewer is a high-performance 3D Gaussian Splatting (3DGS) web viewer built on Three.js. It streams and renders large-scale point cloud scenes (up to 150M points) at interactive frame rates across desktop and mobile devices. The viewer supports multiple input formats including PLY, SPLAT, SPX (proprietary high-compression format), SPZ, SOG, and GLB with the KHR_gaussian_splatting extension. Its architecture is event-driven and modular, with a central event system (Events.ts), dedicated loaders for each format, web workers for parallel data fetching and sorting, and a texture management pipeline that handles LOD tile streaming, frustum culling, and adaptive quality levels. Beyond basic viewing, the repository provides a full suite of interactive features: measurement and annotation tools (distance, area, point labels, 3D tags, circle plans), a map viewer (Reall3dMapViewer) with GIS basemap integration, a first-person/third-person player mode with physics (rapier3d), weather effects (rain, snow), audio-driven text overlays, and a fly-through camera path system. The code is published as an npm package (@reall3d/reall3dviewer) and includes comprehensive demo pages with scene configuration JSON files. While primarily an application library, the project also exhibits data/research characteristics through its custom SPX format specifications, advanced compression techniques (WebP, gzip, xz, zstd), and spherical harmonics support up to degree 3. The source code demonstrates high engineering craftsmanship in areas like GLSL shader modularization, WebAssembly integration for format parsing, and efficient web worker communication patterns. However, there are some maintenance risks including a large monolithic event constant file (200+ auto-incremented integers), hardcoded demo URLs, and a build script that embeds worker code as base64, which complicates debugging. No automated tests are present.
This repository implements an end-to-end 3D object generation application that takes natural language descriptions and produces 3D mesh models (GLB format). It orchestrates three generative AI models: an LLM (Qwen3 or Llama) for scene planning, a diffusion model (SANA Sprint) for 2D image generation, and Microsoft TRELLIS for 3D generation. The system presents a Gradio web interface for user interaction and includes a Blender addon for direct import of generated assets. It supports two deployment modes: native PyTorch models (for local development) and NIM containers (for scalable inference). Key architectural patterns include a singleton GPU memory manager that coordinates model loading/unloading across VRAM-constrained GPUs, a guardrail service for content safety, and a conditional service abstraction that transparently switches between native and NIM backends based on configuration. The repository is well-structured with modular UI components and comprehensive installation scripts, though it is Windows-only and has complex event chains in the main UI file. The code is actively maintained with recent commits and pinned dependencies, but the heavy reliance on patched versions of TRELLIS and a specific Gradio version introduces some maintenance risk.
This repository implements a modern Automatic Number Plate Recognition (ANPR) pipeline as a production-ready application. It ingests images (via HTTP upload or WebSocket stream), runs detection using the `fast-alpr` library (YOLO-based ONNX model), performs OCR with `fast-plate-ocr`, applies post-processing (confusion-pair correction, Turkish plate format parsing, temporal majority voting), optionally tracks vehicles via an IoU-based multi-object tracker, and stores only HMAC-SHA256 hashed plate texts for privacy compliance. The system is exposed through a FastAPI REST API with WebSocket support and a HTMX web UI, plus a Typer CLI for inference and server management. It is containerized with Docker and publishes to PyPI and GHCR. The repository also contains a legacy directory (`legacy/`) with a complete YOLOv5 training pipeline for license plate detection, but that code is explicitly unmaintained and serves as historical reference only. The modern codebase is actively maintained, well-tested, and demonstrates strong software engineering practices including protocol-based abstractions, structured logging, Prometheus metrics, and privacy-by-design persistence.
This repository is the official documentation website for the Remnawave proxy management panel, built on Docusaurus 3. It provides comprehensive installation guides, feature documentation (e.g., HWID device limits, Telegram OAuth, webhooks), client configuration details, SDK references (Go, Python, TypeScript), and curated community projects ('Awesome Remnawave'). The site supports multiple languages (English, Russian, Persian, Chinese) and includes custom React components for displaying client cards, project galleries, release entries, and stats. It also integrates with Scalar for interactive API docs and uses Caddy as the web server. The codebase consists entirely of documentation content and static site infrastructure; the actual panel backend is maintained in a separate repository. The site is well-organized and regularly updated, though some sections (e.g., client list, SDK version table) rely on manual maintenance and may drift.
Jpom is a production-grade, self-hosted DevOps platform built with Java (Spring Boot) and Vue 3. It adopts a server-agent architecture: a central server manages multiple agent nodes via HTTP/WebSocket, enabling remote project deployment, process lifecycle management, script execution, Docker container orchestration, SSH command dispatch, and real-time log monitoring. The server provides a web UI and REST API for configuration, while agents execute operations locally. The codebase is modular, with clear separation into `server`, `agent`, `common`, `storage-module`, and `sub-plugin` modules, plus a Vue frontend with internationalization (i18n) support. Key features include CI/CD build pipelines (Git/SVN), artifact distribution ('outgiving'), trigger tokens for webhook automation, role-based access control with workspaces, database-backend abstraction (H2, MySQL, PostgreSQL), and a plugin system for extensibility (Git, SVN, Docker, encryption, email, webhook). The architecture demonstrates strong engineering practices: SPI-based plugin loading, annotation-driven validation and permission checks, a layered service model with database-agnostic storage, and comprehensive WebSocket handling for real-time features. The codebase is actively maintained with frequent releases and a detailed changelog. While some modules show code duplication (e.g., `SocketSessionUtil` in server and agent) and a number of test files are exploratory or stale, the overall design is clean, the plugin system is genuinely reusable, and the storage abstraction layer (H2, MySQL, PostgreSQL) is a highlight for multi-dialect support. This is a solid implementation of a complex distributed management tool, suitable for teams needing a self-hosted alternative to commercial CI/CD or server management platforms.
This repository is a comprehensive collection of recipes from the Chinese fast-food chain Laoxiangji (Home Original Chicken), presented as a static documentation website built with VitePress. The content is derived from the company's official dish traceability report and organized into categories such as stir-fries, soups, steamed dishes, and drinks. The site features auto-generated indexes and navigation based on the file system, with custom scripts for build automation. It serves as a reference for cooking enthusiasts and a demonstration of organizing large content sets with a static site generator. The repository is primarily a content-driven documentation site with minimal application logic, but includes reusable build infrastructure.
OSINT Brazuca Regex is a CLI tool and curated dataset of regular expressions for detecting Brazilian and global PII/OSINT-relevant patterns. The scanner (`osint_regex_scan.py`) applies the dataset to files, directories, or stdin, supporting multi-threading, text extraction from documents (PDF, DOCX, XLSX, RTF, EPUB) via stdlib or optional `pypdf`/`pdftotext`, and noise filtering (blob masking, line length limits). Output formats include terminal, CSV, JSON, or raw values. The dataset is split into two JSON files (Brazil-specific and general), merged at load time, and includes patterns for CPF, CNPJ, credit cards, crypto wallets, API credentials, and more. The repository also includes a build script (`build.py`) for managing the split/merged dataset. Core functionality requires only Python 3.12+ stdlib, with optional dependencies for extended PDF support and encoding detection.