This is a card game application based on the 三国杀 (Three Kingdoms Kill) game engine. It features multiple game modes including guozhan (main mode), boss battles, chess, connect, doudizhu, stone, tafang, and versus modes. The application has a rich extension system that allows users to add new cards, characters, skills, and game content through isolated packages. The architecture separates concerns effectively with dedicated systems for game events, audio management, character definitions, and skill execution. Built with Vue.js and TypeScript, it supports web, mobile (via Capacitor), and desktop (via Electron) platforms. The asset organization is exceptionally well-structured with thousands of audio files categorized by type (card, skill, voice, effect) and gender variants, demonstrating careful attention to detail in resource management.
Granite is a Vulkan-based real-time 3D rendering engine and application framework developed by Hans-Kristian Arntzen. It provides a comprehensive, modular library for building interactive graphics applications, including a high-level Vulkan abstraction, a declarative render graph with automatic resource management, scene loading (glTF, custom JSON), a full post-processing pipeline (TAA, SMAA, FXAA, HDR, bloom, SSAO, SSR), clustered and volumetric lighting, mesh shaders, and GPU-driven rendering. The framework also includes cross-platform audio (WASAPI, PulseAudio, Oboe) with DSP, video encoding/decoding via FFmpeg, a physics system (Bullet), a UI widget system, an entity-component system, and a flexible filesystem abstraction with network VFS support. The codebase is production-quality with advanced Vulkan feature usage, extensive tests, and tools for asset processing. While the author explicitly discourages external contributions, the repository remains actively maintained and showcases high craftsmanship in graphics engineering.
Fyrox is a large, mature Rust game engine delivered as a multi-crate workspace, plus a full visual scene editor (fyroxed) and a project manager. The codebase implements a complete runtime stack: 3D/2D rendering through OpenGL or wgpu backends, a scene graph with dynamic node types, physics integration via Rapier, an animation system with ABSM state machines, a sound engine with HRTF and DSP effects, a custom UI toolkit, and an async resource loading framework. The editor is built on the engine's own UI and uses plugin architecture, command-based undo/redo, inspector property editors, gizmos, tilemap tools, and asset browsers. Entry points include the public `fyrox` facade crate, `editor-standalone/src/main.rs` for the editor binary, `project-manager/src/main.rs` for project management, and example applications in `examples/` and `fyrox-sound/examples/`. Architecturally, the engine is a library plus a desktop application rather than a service. It relies heavily on a custom reflection and serialization stack (`Reflect`, `Visit`, type UUIDs, builder patterns) that powers scene persistence, asset hot-reloading, and editor inspectors. The primary data flow is asset-to-scene: resource loaders read files (FBX, glTF, RGS, RON, audio, textures), construct typed resources through UUID-driven constructor containers, and insert them into the scene graph; the renderer then converts scene nodes into GPU data via deferred rendering, caches, and visibility/occlusion systems. Plugin/script hot-reload is supported for dynamic loading of game code. External dependencies include winit for windowing, Rapier for physics, nalgebra for math, wgpu/OpenGL for graphics, and OS audio backends. The codebase is generally well-engineered, with clear subsystem boundaries, reusable builder APIs, and an unusually deep custom infrastructure for an open-source engine. However, it carries notable maintenance risk: two graphics backends must stay in sync, parts of the editor are tightly coupled to engine internals, several modules contain unsafe transmutes or deliberate leaks, and the custom derive macros and serialization format require careful versioning. Dependency drift exists, including old `syn`/`darling` versions in `fyrox-core-derive` and unresolved backend feature gaps such as missing wgpu occlusion queries. Overall this is a strong, active codebase with several genuinely reusable components, but not an exceptionally polished one.
musikcube is a cross-platform, terminal-based music player and streaming server written in C++. It consists of a core library (`musikcore`) with a plugin-based architecture for decoders, encoders, audio outputs, DSP, and data streams. The project includes three distinct front-ends: a terminal UI (`musikcube`) built on a custom curses++ framework, a native Windows UI (`musikwin`) using a custom Win32 wrapper, and an Android remote client (`musikdroid`) written in Kotlin. The server plugin enables remote control and audio streaming via WebSocket and HTTP. The core manages a SQLite-backed music library with indexing, metadata extraction (via TagLib), and playlist management. Audio playback supports gapless and crossfade transitions, visualizers, and an equalizer. The system is designed for extensibility through a well-defined SDK interface set, allowing third-party plugins for decoders, outputs, and DSP. The codebase is mature (copyright 2004-2023) and shows signs of organic growth, with heavy vendored third-party dependencies and platform-specific code. While not architecturally pristine, it demonstrates solid engineering, a clean plugin API, and reusable UI frameworks.
This repository provides an alternate firmware for the Ornament & Crime (O_C) Eurorack module, running on a Teensy 4.0 microcontroller. It implements a modular audio processing platform where individual 'engines' (synthesizers, drum machines, effects, sequencers, CV generators, and utilities) are compiled as separate .bin files and dynamically loaded via the udynlink linker. The firmware features a 128x64 OLED UI, two encoders/buttons, MIDI I/O, CV/gate handling, and a modulation routing system. The codebase is a hybrid of custom engine code and extensively vendored third‑party DSP libraries from Mutable Instruments (plaits, rings, marbles, peaks, streams, braids), open303 (TB‑303 emulation), MSFA (DX7 FM synthesis), SAM (text‑to‑speech), soundpipe, Faust‑generated models, and others. The architecture is monolithic with a plugin‑style engine API (setup/process/draw), and the build system uses a custom shell script and Python tools. While the API is explicitly marked as unstable and the code contains some hacks (e.g., #define private public), the DSP components are of high craftsmanship and many are reusable in other audio projects. The project is actively maintained by a single developer and has a small but engaged community.