ClassiCube is a Minecraft Classic-compatible multiplayer game client and launcher written in C. It implements a full voxel game engine: block world storage and rendering, player physics and collision, entity models, inventory, chat, texture packs, lighting (classic heightmap and fancy flood-fill), block physics (liquids, falling blocks, TNT), particles, and the Classic/CPE network protocol. A separate launcher subsystem fetches server lists, handles updates, downloads texture packs, and starts the game. The codebase is organized around an IGameComponent lifecycle (Init/Free/Reset/OnNewMap), a typed event system, and platform abstraction layers (Window_, Platform_, Graphics_, Audio_) that share the same API across dozens of desktop, mobile, web, and console targets ranging from modern Windows/Linux to PS1, Dreamcast, N64, and Amiga.
js-beautify is a dual-language (JavaScript and Python) library and CLI tool for reformatting JavaScript, CSS, HTML, and related code (JSON, JSX, etc.). It provides an extensive set of configurable options for brace style, indentation, line wrapping, templating language support, and more. Internally, it uses a modular architecture with shared core components (InputScanner, Pattern, Output) that are reused across language-specific beautifiers. The project includes a web demo at beautifier.io and CLI executables for both Node.js and Python. Despite being mature and widely used (9000+ stars), the codebase shows some technical drift: the web frontend relies on older libraries (RequireJS, jQuery, CodeMirror from CDN), and JavaScript/Python implementations require parallel maintenance. However, the core tokenizer and formatting logic is well-crafted and demonstrates solid engineering practices with composable patterns and extensive test coverage.
This is a desktop application built with Go and the Fyne GUI framework that manages updates for portable Chrome installations and Chrome++ (a Chrome enhancement tool). It provides a graphical interface to check for the latest Chrome versions across stable, beta, dev, and canary branches, download them using a multi-threaded downloader with resume support, and extract 7z archives. It also supports updating Chrome++ from GitHub releases, system tray integration with auto-update scheduling, proxy configuration, and localization (English/Chinese). The application communicates with Google's Omaha update protocol (via XML requests to tools.google.com) and a custom web service (chrome.noki.eu.org) to fetch version information. The codebase demonstrates solid engineering practices including data binding, concurrent downloads, and a clean i18n system using embedded TOML files.
Koi-UI is a Vue 3-based enterprise admin template built with Vite, TypeScript, and Element Plus. It provides a comprehensive set of UI components, layouts, and utilities for rapidly developing backend administration panels. The architecture follows a modular structure with separate concerns for routing (Vue Router), state management (Pinia), components, layouts, and business logic. Key features include permission-based UI rendering, multiple layout modes (vertical, horizontal, columns, etc.), runtime theme customization, internationalization, and reusable business components like dialogs, drawers, file uploads, and data tables. The template is designed to be extensible and serves as a foundation for building complex enterprise applications.
EFANNA is a header-only C++ library for approximate nearest neighbor (ANN) search. It builds an index combining a k-nearest neighbors graph and tree structures (KD-trees or hash tables) to enable efficient search on high-dimensional data. The library provides optimized distance computations with SSE/AVX intrinsics and a matrix class for SIMD-friendly data access. Key functionalities include index building, saving/loading indices, and performing ANN search via command-line examples or a MATLAB interface. The architecture is modular, with core algorithms in base_index.hpp and specialized index implementations in kdtreeub_index.hpp and hashing_index.hpp.
Rush is a multi-platform (Android, iOS, Desktop) lyrics viewer and sharing application built with Kotlin Multiplatform and Jetpack Compose. It fetches lyrics from Genius and LRCLIB, stores them locally via Room, and displays both plain and synced (LRC/TTML) lyrics with per-syllable highlighting. The app features a media listener that auto-detects the currently playing song, extensive customization options (themes, fonts, backgrounds, romanization for multiple languages), and a rich share card generator with nine distinct visual themes. Architecturally, it follows a clean modular structure (core, logic, ui) with Koin dependency injection, Ktor networking, and DataStore preferences, and includes Android-specific pro features (billing, analytics via PostHog) with FOSS variants that strip those dependencies.
Friendly Eats is an Android restaurant recommendation app that uses Firebase Firestore for real-time data synchronization and Firebase Authentication for user sign-in. The app features a main screen with a filterable and sortable list of restaurants, a detail view for individual restaurants, and the ability to add ratings. The architecture follows Android Jetpack guidelines with a single activity, multiple fragments, ViewModel for UI state, and the Navigation component for fragment transactions. Firestore queries are used to fetch and listen to restaurant data, with transactions ensuring data consistency when adding ratings.
POML (Prompt Orchestration Markup Language) is a developer toolchain for structured, reusable LLM prompt engineering. It provides an HTML-like markup language with semantic components, CSS-like styling, templating (variables, loops, conditionals), and multimodal data integration (PDFs, images, tables). The repository contains a core TypeScript/React SDK, a Python wrapper with OpenAI/LangChain/MLflow integrations, a VS Code extension (LSP, live preview, test command), and a Chrome browser extension for content extraction. It is packaged as CLI tools and libraries on npm and PyPI. Designed for building maintainable prompts in LLM applications, it also includes research artifacts (arXiv papers) and a tracing system for debugging prompt execution.
This repository is a reference Yocto/OpenEmbedded layer collection demonstrating the KISS (Keep It Simple, Stupid) principle for embedded Linux build systems. It provides a minimal but realistic setup for building bootable images for four fictitious products based on real development boards: BeagleBone Black (dogbonedark), STM32MP157A-DK1 (stompduck), NXP FRDM i.MX93 (freiheit93), and AMD ZynqMP Kria KD240 (krazymp). The architecture consists of a base distro layer (meta-kiss) with common recipes and machine-specific layers (meta-kiss-ti, meta-kiss-st, meta-kiss-nxp, meta-kiss-amd) that add board-specific configurations, bootloaders, kernel defconfigs, and firmware handling. The build process is orchestrated via kas configuration files or bitbake-setup, automatically fetching all required upstream layers (bitbake, openembedded-core, meta-arm, meta-openembedded, meta-xilinx). The repository serves as a teaching tool and starting point for companies wanting to create clean, maintainable Yocto setups without unnecessary complexity. It is not a standalone application but a build system configuration; its value lies in the patterns and practices it demonstrates rather than reusable code components.
This repository is a thin Node.js library that acts as a Protractor custom framework adapter, bridging Protractor and Cucumber.js. It relies on Serenity/JS to integrate testing across multiple Cucumber versions (1.x through 12.x) and Protractor 5/7. The core logic is in `index.js`, which delegates to `@serenity-js/protractor`'s `ProtractorFrameworkAdapter`. The `package.json` lists `@serenity-js/core`, `@serenity-js/cucumber`, and `@serenity-js/protractor` as runtime dependencies, with `cucumber` and `@cucumber/cucumber` as optional peer dependencies. The codebase is well-structured, with a comprehensive test suite that exercises every supported Cucumber version via a custom `multidep` test runner. The project is actively maintained (last commit 2026-05-13) and follows semantic release. However, it is a thin wrapper with limited standalone reusability outside of the Protractor–Cucumber ecosystem. The primary value is in providing backward compatibility and a unified interface for multiple Cucumber generations.
This repository implements a comprehensive toolkit for detecting and removing Google DeepMind's SynthID watermark from AI-generated images, primarily targeting Gemini models. It provides multiple bypass versions (V1–V4) that use pure signal-processing techniques—frequency-domain phase scrambling, JPEG degradation, elastic deformation, VAE round-tripping, and cross-color consensus codebook subtraction—to disrupt the embedded watermark while preserving visual fidelity. The codebase includes a drag-and-drop GUI, CLI tools, batch processing scripts, and a human-in-the-loop calibration workflow. It also contains extensive watermark investigation scripts that validated the watermark's presence in over 123,000 image pairs. While primarily an application (tool for watermark removal), it has a strong research character due to its analytical components and large-scale validation studies.
This is the TensorFlow Model Garden, a large monorepo of model implementations, training loops, and research code. The dominant character is an application/framework: it provides official TF2 model code under `official/`, a custom training library under `orbit/`, and a large body of research code under `research/` and `community/`. The codebase is not a single deployable service but a collection of training/eval/export scripts, model factories, config systems, and data pipelines. It uses Gin configs, dataclass-based configs, and a registry pattern to compose models, tasks, and data loaders. Tests exist across the repo, and CI workflows are present. The repository is hybrid in that it contains research-oriented experiments and data-processing code, but the core is a software framework for building and training TensorFlow models.
Open Tournament is a first-person shooter game built on Unreal Engine, inspired by classic arena shooters like Unreal Tournament and Quake. The game implements comprehensive systems for player movement, combat, AI, user interface, audio, and networking. It features a modular architecture using Unreal Engine's plugin system, with extensive use of the Gameplay Ability System (GAS), Enhanced Input, and replication for multiplayer functionality. The codebase shows thoughtful architectural design in several reusable systems, particularly in settings management, UI composition, messaging, and loading screen handling.
pyGIMLi is a mature open-source geophysical modelling and inversion library, implemented as a C++ core with Python bindings. It provides mesh generation, finite-element solvers, data containers, and high-level manager classes for methods such as electrical resistivity tomography (ERT), vertical electrical sounding (VES), frequency-domain electromagnetics (FDEM), magnetics, gravity, traveltime, and spectral induced polarization. The library is not a GUI application; it is a programmatic toolkit with Python entry points, example scripts, and a console-app pattern in some managers.
Seal is an Android application that serves as a graphical frontend for yt-dlp, enabling users to download videos and audio from a wide range of websites. Built with Kotlin and Jetpack Compose, it features a Material Design 3 interface with dynamic color theming. The app manages download tasks through a state machine, supports playlists, custom command templates, cookies, SponsorBlock integration, and extensive format selection. It relies on yt-dlp (via youtubedl-android), FFmpeg, and aria2c as external engines, and uses Room for local database storage, MMKV for preferences, and Koin for dependency injection. The architecture is a single-activity Compose Navigation app with a foreground download service. While the codebase is well-organized and actively maintained, it exhibits some technical drift (e.g., deprecated Accompanist WebView, minimal test coverage) and contains a few monolithic modules. Notable reusable components include a standalone color science library implementing CAM16/HCT, a backup/restore utility for database objects, and a custom motion system for Material Shared Axis transitions.
This repository is a boilerplate for building desktop applications using Electron, Vue 3, and Vite. It provides a pre-configured setup that includes a main process (handling application lifecycle and window creation), a preload script (securely exposing Electron and Node.js APIs to the renderer via contextBridge), and a renderer process (built with Vue and Vite). The project includes demos showing inter-process communication (IPC) and direct Node.js usage in the renderer. The architecture follows the standard Electron model, with the main process managing the application lifecycle and the renderer process running the Vue application. Vite is used as the build tool for all processes (main, preload, and renderer), leveraging vite-plugin-electron to handle Electron-specific build configurations such as sourcemaps, minification, and dependency externalization. The preload script exemplifies best practices by using contextBridge to expose only the necessary IPC methods, avoiding the security risks of enabling nodeIntegration or disabling contextIsolation. While the project is relatively simple and serves as a starting point, it contains several reusable patterns and configurations. Notably, the Vite configuration (vite.config.ts) demonstrates a non-obvious but effective way to set up Vite for Electron builds, including separate configurations for the main and preload processes. The preload script also contains reusable DOM utility functions (domReady and safeDOM) and a secure pattern for exposing Electron APIs. Overall, the boilerplate is well-structured, adheres to modern Electron and Vue practices, and provides a solid foundation for building Electron applications with Vue and Vite.
The Eleven is a full-stack prediction market platform for live football events, deployed on X Layer (chain 196) using Uniswap v4 hooks. The system is powered by 11 autonomous AI agent personas (e.g., IlRegista, IlBomber) that monitor live match data from API-Football or Football-Data.org, evaluate binary propositions (e.g., clean sheet, corners over, next goal), and create markets via a commit-reveal mechanism. Markets are implemented as PropMarketHook contracts deployed through a factory using CREATE2. Users can stake on outcomes gaslessly via EIP-3009 signatures relayed by the x402-facilitator service, and markets are resolved deterministically after match events. The monorepo (pnpm workspaces) contains five packages: `contracts` (Foundry-based Solidity), `agent` (TypeScript runtime with Prisma persistence), `web` (Next.js 15 dApp with RainbowKit, Three.js 3D pitch, and Farcaster Frame v2 integration), `x402-facilitator` (standalone npm package for gasless USDT0 transfers), and `mcp-server` (MCP bridge exposing market tools to AI agents). The architecture is event-driven: the agent's TickLoop polls matches, emits deltas, and triggers market creation/reveal/resolution skills. The web app provides a full dApp experience including a markets list, agent detail views, a status page, and documentation. Key reusable patterns include a generic proposition template system with ABI encoding/decoding, a CREATE2 salt miner for hook deployment, a commit-reveal skill with cryptographic safety, and a gasless staking flow that can be extracted for any EIP-3009-compatible token. The codebase is well-tested (172 web tests, 229 agent tests, 85 contract tests with 100% coverage on the hook) and actively maintained with CI/CD via GitHub Actions and Railway deployment.
Clipboard.js is a lightweight JavaScript library that provides a modern, no-Flash way to copy or cut text to the clipboard. It operates as a browser library, using event delegation via the `good-listener` package and the deprecated `document.execCommand` API. The core class `ClipboardJS` can be instantiated with a DOM selector, element, or NodeList, and it automatically listens for click events to trigger copy/cut actions based on HTML data attributes (`data-clipboard-text`, `data-clipboard-target`, `data-clipboard-action`). It also exposes static `copy()` and `cut()` methods for programmatic use, and emits custom `success` and `error` events. The library includes a fallback mechanism using a temporary textarea element for browsers that do not support selecting hidden elements. It is well-tested, has TypeScript definitions, and is distributed as a UMD bundle. The architecture is a simple monolith with a single entry point and isolated action modules.
This repository implements a WakaTime language server extension for the Zed editor. It consists of two Rust crates: a Zed extension (src/lib.rs) that manages downloading and launching the wakatime-ls language server and the wakatime-cli binary, and the language server itself (wakatime-ls/src/main.rs) that translates editor document events (open, change, save) into heartbeats sent to the WakaTime API via the external CLI. The extension uses Zed's extension API for lifecycle management and binary caching, while the language server is built with tower-lsp and tokio, providing robust async handling of LSP notifications. The architecture is a clean plugin-plus-LSP design where the extension is a thin orchestrator and the language server does the actual event processing and API communication. The codebase is well-structured, uses modern Rust patterns, and includes CI/CD configuration for cross-platform releases.
This is a personal dotfiles repository for macOS, maintained by a prominent Python developer. It provisions a complete development environment: zsh shell with oh-my-zsh and zplug plugin management, git configuration with the delta pager and custom aliases, VSCode settings and keybindings, Firefox/Zen browser privacy hardening via arkenfox overrides, Homebrew dependencies (formulae, casks, Mac App Store apps, VSCode extensions), macOS system defaults, skhd keyboard shortcuts, and a crontab-driven StreamDeck automation. Installation is orchestrated through dotbot: a bash `install` script invokes YAML step files (`steps/terminal.yml`, `steps/dependencies.yml`, `steps/vscode.yml`, `steps/streamdeck.yml`) that symlink configs and install dependencies in phases, with `|| true` so optional steps fail gracefully. Dependabot runs daily to keep the dotbot submodules current. Although classified as an application repo (it has CLI entry points and a provisioning pipeline), this is not a software application in the traditional sense — it is a configuration system with no runtime service or library API. The most technically interesting parts are the shell integrations. `config/zshenv` defines `_fzf_complete_realpath`, a content-aware fzf preview renderer that dispatches on input type: text files via bat, directories via tree, images via catimg, binaries via hexyl, and stdin via bat with syntax highlighting. `shell/.completions` builds on this with fzf-tab completion configs for make, man, killall, ls/cat/cd, and a custom zoxide completer that enables `z NAME<TAB>` (a usability gap in zoxide's native fzf integration). `shell/.functions` contains a Docker-based runner for Claude Code that persists the CLI binary and all auth/session state in named volumes while mounting the project at its host path, preserving per-project sessions and memory. The repo is actively maintained with recent commits, zero open issues, and zero security alerts. The toolchain is current (LLVM 21, OpenSSL 3, zen browser, uv). The WTFPL license makes reuse unrestricted. Reuse value is moderate: the fzf preview function, the fzf-tab zstyle templates, the containerized-CLI-agent pattern, and the USB-hotplug cron script all extract cleanly into other environments.