Muzei is a live wallpaper application for Android that automatically refreshes the user's home and lock screen with artwork on a daily schedule. The system is built around a well-designed plugin architecture (muzei-api) that allows artwork to be sourced from curated feeds, the user's local photo gallery, single images, or third-party providers. The Android client features a custom OpenGL rendering engine (GLWallpaperService) for smooth transitions and visual effects like blur, dim, and greyscale overlays. A companion Android Wear app syncs the current wallpaper to smartwatch complications. The project also includes a web backend (Google App Engine, Python 2.7) that serves the curated artwork feed, manages an archive of past wallpapers, and provides an admin interface for scheduling. While the Android codebase is actively maintained and demonstrates strong engineering practices with several reusable components (e.g., cloud storage library, SVG path parser, GPU blur renderer), the web backend shows significant technical drift, relying on an EOL Python runtime and outdated JavaScript dependencies. The lack of visible unit tests is a notable gap for an application of this complexity.
melonDS is a Nintendo DS and DSi emulator implemented in C++ with a Qt/SDL frontend. The core provides cycle-accurate emulation of the ARM9/ARM7 CPUs (with both an interpreter and JIT backends for x86_64 and AArch64), 2D/3D GPU (software and OpenGL), SPU, DMA, cartridge slot (retail, homebrew, R4), DSi-specific hardware (AES, NAND, camera, I2C, DSP), Wi-Fi with libslirp user-mode networking, and GDB remote debugging. The architecture separates platform-independent emulation logic from OS-specific frontend and audio/video output via a well-defined Platform abstraction. The codebase is large and includes vendored third-party libraries (libslirp, Teakra DSP, FatFs, tiny-AES-C, xxhash, blip-buf, toml11) and borrowed components from Dolphin and DuckStation projects. Reusable patterns include a consistent savestate serialization scheme, FIFO templates, efficient bitfield utilities, and a register cache for JIT compilation. Maintenance is active with regular commits and CI across Windows, macOS, Linux, and BSD, though some areas (DSi emulation, netplay) have TODOs and commented-out code indicating ongoing development.
picom is an X11 compositor that provides desktop visual effects such as window shadows, fading, blur, rounded corners, and animations. It is a fork of Compton and serves as a lightweight compositing manager for X11 window managers. The system is built around a modular architecture with pluggable rendering backends (XRender and OpenGL), a damage-based incremental renderer, a window tree manager, and a custom animation scripting engine. Key entry points include the main session initialization in `src/picom.c`, the event loop driven by libev, and the backend initialization. Data flows begin with X11 events (e.g., window creation, property changes) processed by the event handler, which updates the window tree and triggers damage computation. The renderer then builds a list of backend commands from window layers, applies damage culling, and presents the final image via the selected backend. External dependencies include X11 libraries (xcb, xlib, xrender, xdamage, xcomposite, xpresent, xrandr), libconfig for configuration, libev for event handling, pixman for region operations, and optional OpenGL, dbus, and pcre2. The project is actively maintained with a comprehensive test suite and CI/CD pipelines.
Spout2 is a mature, production-grade C++ SDK and library for real-time GPU texture sharing between Windows applications. It supports sharing OpenGL, DirectX 9, DirectX 11, and DirectX 12 textures across processes, primarily used in creative coding, VJing, projection mapping, and live video workflows. The architecture centers on a sender/receiver pattern backed by named shared memory for metadata and NVIDIA WGL_NV_DX_interop or DirectX staging textures for GPU-to-GPU transfer. Multiple API layers exist: a full OpenGL interop class (SpoutGL), DirectX-only wrappers (SpoutDX, SpoutDX9, SpoutDX12), and a C-compatible DLL (SpoutLibrary). The SDK includes extensive example projects for Win32, openFrameworks, Cinder, and DirectX tutorials. Core utilities—SpoutSharedMemory, SpoutFrameCount, SpoutCopy, SpoutUtils—are well-encapsulated and demonstrate strong systems programming skill. However, the codebase shows signs of age: heavy reliance on Windows registry, conditional compatibility layers for legacy 2.006 mode, duplicate header copies across tutorial folders, and manual resource management. Technical drift is medium due to dependence on NVIDIA-specific GPU interop and DirectX 9/11, though the library remains functional on modern Windows with active maintenance and a responsive issue tracker.
Razix is a multi-platform 3D game engine built in C++ with a focus on modern graphics APIs (Vulkan, DirectX 12, OpenGL). It features a custom rendering hardware interface (RHI), a frame graph system for efficient render pass scheduling, an entity-component system (ECS) for scene management, and a built-in editor with ImGui integration. The engine includes a Lua scripting system, physics integration via Jolt Physics, and a comprehensive memory management layer with custom allocators. Despite its ambitious scope and active development, the codebase exhibits a mix of well-engineered subsystems and areas of legacy code (e.g., LIMBO_STATE). The project provides testing frameworks for both engine core and graphics pipelines, and maintains a dedicated game project ('Tanu') as a showcase.
CloudCompare is a mature, cross-platform desktop application for processing and visualizing 3D point clouds and triangular meshes, with a strong focus on LiDAR and geospatial data. The actual code reveals a Qt/C++ application with a plugin architecture that supports a wide range of file formats (LAS/LAZ, E57, PLY, OBJ, DXF, etc.) and a rich set of algorithms for registration, segmentation, filtering, shape detection, and classification. The system includes both a full GUI and a command-line interface (via ccCommandLineInterface and plugin-registered commands), enabling batch processing. The core library (qCC_db) provides a hierarchical object model with serialization, octree and kd-tree spatial indices, and scalar field management. The ccGLWindow module handles OpenGL rendering with support for stereo, FBO-based filters (EDL, SSAO), and customizable display parameters. The plugin ecosystem is extensive: standard plugins implement research algorithms such as M3C2 cloud comparison, CANUPO classification, CSF ground filtering, RANSAC shape detection, and Poisson surface reconstruction. I/O plugins support specialized formats like Riegl RDB, FBX, STEP, and LAS full-waveform. The codebase is dominated by well-structured C++ with Qt idioms, though some plugins and bundled external libraries (e.g., dxflib, qhull, RANSAC_SD) show varying maintenance patterns. Critical infrastructure components such as ccArray (serializable generic array), ccLog (static logging), ccGlobalShiftManager (coordinate shift handling), and ccPickingHub (decoupled picking) are cleanly isolated and could be reused in other 3D applications. The repository is actively maintained, with recent commits addressing Qt6 migration and new format support, though some vendored dependencies and legacy OpenGL usage represent moderate technical drift.
flow5 is a comprehensive desktop application for preliminary aerodynamic analysis and design of 2D airfoils, 3D aircraft configurations, and sailing vessels. It implements multiple potential-flow solvers: XFoil for viscous 2D analysis, and 3D panel methods (VLM, LLT, QuadPanel) coupled with wake models and boundary-layer corrections. The application provides a full-featured GUI built on Qt with OpenGL 3D views, interactive geometry editors (splines, NURBS, STL, OpenCASCADE), and extensive plotting capabilities. It supports batch analysis, scripting, and CAD import/export. The architecture is a modular monolith separating core computational library (flow5-lib), I/O serialization (flow5-io-lib), and the Qt application (flow5-app) with three main modules: XDirect (foils), XPlane (aircraft), and XSail (boats/sails). While the codebase shows professional engineering craftsmanship with well-defined abstractions for panel methods, splines, and task threading, it suffers from technical debt including global static state, code duplication between libraries, and experimental/test components intermingled with production code.
This repository is an Android library for GPU-accelerated real-time image and video processing, named 'android-gpuimage-plus' (CGE engine). It provides a comprehensive set of OpenGL ES shader-based filters (brightness, contrast, hue, saturation, vignette, sketch, liquify, color mapping, LUT, etc.) and a filter chain pipeline for applying multiple effects. The library supports camera preview with live filters, video playback with effects, and video recording to MP4 using an optional FFmpeg backend. It includes a demo application (cgeDemo) showcasing all features, including image editing, camera capture, video player, and face tracking (stub). The architecture is a Java/Kotlin API layer with JNI wrappers to a native C++ core that manages OpenGL ES contexts, shader programs, and frame buffer objects. External dependencies include OpenGL ES 2.0/3.0, optional FFmpeg (version 3.4.8), and Android Camera1/CameraX APIs. The library is published as an AAR artifact with variants for different page sizes (4KB and 16KB) and optional video module.
The Doomsday Engine is a modular game engine and source port for classic FPS games (Doom, Heretic, Hexen, Doom64) with client-server architecture. It provides enhanced rendering (OpenGL), audio systems, GUI frameworks, networking, and scripting capabilities. The engine supports extensibility via plugins and includes tools like Amethyst for documentation processing. The codebase shows strong separation of concerns with distinct libraries for core functionality, game logic, rendering, and UI. While actively maintained, it exhibits technical drift due to platform-specific conditionals, legacy code sections, and complex dependency management.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.
g3nd is the official demo/showcase application for the g3n Go 3D game engine. It is a single Go binary that presents a windowed GUI (built on the engine's own immediate-mode GUI system) with a categorized demo tree. Users select demos that exercise the engine's capabilities: glTF/glb loading, PBR materials, animations (skinning, morph targets), audio (OpenAL), particle systems, post-processing shaders, and GUI widgets (tables, trees, sliders, form boxes, dock layouts). The application registers demos via Go's `init()` side-effect pattern: each demo package imports itself and calls `app.DemoMap["category.name"] = &struct{}{}`. The core `App` struct manages the scene graph, camera, orbit controls, and per-frame `Update` dispatch. The repository also vendors a large set of test assets (glTF sample models, Blender files, audio, textures) under `data/`. The architecture is a classic Go application: `main.go` imports all demo packages for their registration side effects, then delegates to `app.Create().Run()`. The `app` package owns the window, GUI, and demo lifecycle. Each demo implements a minimal `IDemo` interface (`Start`, `Update`, `Cleanup`). The `util` package provides reusable GUI helpers (file selectors, light meshes). The demos are grouped by category: animation, audio, experimental physics, geometry, GUI, light, loader, material, other, shader, texture. The code is idiomatic Go with clean separation, but some demos are marked experimental and the engine dependency is a pseudo-version that may drift.
ffmpeg-concat is a Node.js CLI tool and library for concatenating video files with OpenGL-based transitions. It extracts frames from input videos using ffmpeg, applies GLSL transitions between consecutive frames using headless-gl, and transcodes the result to MP4. The architecture is modular with separate modules for frame extraction, transition rendering, audio handling, and final encoding. Key entry points are lib/index.js (library API) and lib/cli.js (command-line interface). The system relies on ffmpeg as a system dependency and wraps it with fluent-ffmpeg for Node.js integration. The code demonstrates solid engineering practices with clear separation of concerns, proper error handling, and test coverage. However, the dependency ecosystem shows signs of age - many packages date to 2018-2019, and the Travis CI configuration uses outdated Node.js versions. The OpenGL-based transition system is the core innovation, allowing complex visual transitions that would be difficult to implement with ffmpeg filter graphs alone. This is a practical tool for video editors and developers needing programmatic video concatenation with visual effects. It's not a research project or data pipeline - it's a production-ready library with CLI support.
This repository contains the source code for the Poseidon game engine, which powers the remastered version of Arma: Cold War Assault (CWR). It is a large, monolithic C++20 codebase with a modular subsystem architecture covering graphics (OpenGL 3.3), audio (OpenAL), networking (UDP with custom transport), input (SDL), AI, world simulation, UI, and asset management. The engine supports dedicated servers, modding via PBO archives, and a scripting language (SQF/SQS). The repository also includes a suite of CLI tools (PBO packing, image conversion, model inspection, etc.), a Blender addon for importing P3D models, and Rust components for a master server and test harness (Trident). Extensive unit tests (Catch2) and fuzz harnesses are provided. The codebase is a locked snapshot with no active development, but it demonstrates high craftsmanship in areas like custom containers, memory management, and network protocol design. However, it suffers from technical debt including heavy use of preprocessor macros, global state, and platform-specific conditionals.
This repository is a C# port of the Three.js 3D library, providing a comprehensive 3D graphics framework for .NET applications. It implements a scene graph architecture with Object3D hierarchy, supporting geometries, materials, cameras, lights, and various loading mechanisms for 3D models and textures. The library offers multiple rendering backends (OpenTK/OpenGL and Silk.NET) and includes extensive example applications demonstrating features like physically-based rendering, post-processing effects, animation systems, and camera controls. The codebase shows good separation of concerns in core mathematical utilities and event systems, though suffers from some duplication between rendering backends and inconsistent patterns in examples.
Lightspark is an open-source Flash player implementation written in C++. It operates as both a standalone desktop application (using SDL2 and OpenGL/Cairo for rendering) and a browser plugin via PPAPI and NPAPI. The codebase implements ActionScript 3 (AVM2) and ActionScript 1/2 (AVM1) runtimes, supporting a broad range of Flash APIs including display, audio, video, networking, text, and filters. It includes a custom test runner framework with recorded input event playback for deterministic regression testing. The project is structurally well-organized with platform abstraction layers (paths, directory iteration, event loops, threading), but many Flash API classes remain stubs (emitting 'not implemented' warnings). Third-party dependencies are heavily vendored (pugixml, nanovg, imgui, cpptrace, cereal, etc.), some of which are outdated. Given the deprecated nature of Flash technology, the codebase exhibits significant technical drift despite occasional updates.