libGDX is a mature, cross-platform Java game development framework supporting Windows, Linux, macOS, Android, iOS (via RoboVM), and web browsers (via GWT). The codebase is organized as a multi-project Gradle build with a core module (gdx) providing platform-agnostic APIs for graphics (2D/3D), audio, input, file handling, math, utilities, scene2d UI, asset management, and tile maps. Platform-specific backends implement these interfaces using LWJGL3 (desktop), Android SDK, RoboVM (iOS), GWT (web), and a headless backend for testing. Extensions provide Box2D (2D physics), Bullet (3D physics), FreeType (font rendering), and development tools (texture packer, particle editor, font generator). The architecture uses interface-based abstraction with platform-specific implementations, enabling write-once-run-anywhere game development. The codebase demonstrates strong engineering practices: clean separation of concerns, extensive test coverage (unit tests + integration tests across backends), native code integration via JNI/SWIG for physics engines, and a comprehensive asset pipeline. Recent commits (2026) show active maintenance with modern Gradle, Java 17+ compatibility, and ongoing MetalANGLE backend development for iOS.
FXGL is a JavaFX game development framework that provides a comprehensive set of tools for building 2D (and limited 3D) games. It implements an entity-component system as its core architecture, complemented by dedicated systems for physics (embedded Box2D port), animation, particles, pathfinding (A*, DFS, maze/dungeon generation), UI, input handling, networking (TCP/UDP), localization, save/load, and dialogue editing. The framework exposes a fluent DSL (FXGL facade) for rapid game prototyping, along with a developer console and profiler. Major entry points include the GameApplication abstract class, the FXGL static API, EntityBuilder for entity creation, and AnimationBuilder for animations. Externally, it relies on JavaFX for rendering, Kotlin for DSL syntax, SDL2 for native controller input, and (via the intelligence module) headless browser or MediaPipe WebSocket servers for speech/gesture recognition. The codebase is modular across Maven submodules (fxgl-core, fxgl-scene, fxgl-io, fxgl-tools, etc.) and includes extensive sample applications demonstrating each feature. While most core systems are production‑ready, some areas (e.g., GLImageView, ForeignFunctionCaller) are explicitly marked as work‑in‑progress, and a few components like DFSPathfinder have incomplete implementations.
ppy/osu-framework is a high-performance, cross-platform game framework written in C#, primarily designed to power the rhythm game osu! but offering general-purpose 2D game development capabilities. The codebase provides a comprehensive suite of subsystems including a hardware-accelerated rendering pipeline (OpenGL/Veldrid), a sophisticated input handling system (mouse, keyboard, touch, tablet, joystick, MIDI), an audio engine built on BASS and FFmpeg, a rich animation and layout system, and a full-featured UI toolkit with containers, text rendering, and interactive controls. It employs Roslyn source generators to eliminate runtime reflection for dependency injection and input dispatch. The architecture is modular, heavily test-driven (thousands of unit and visual tests), and supports Windows, macOS, Linux, iOS, and Android through platform-specific host implementations. Despite its strong engineering, the codebase shows signs of ongoing migration to SDL3, dual rendering backends, and reliance on unmanaged native libraries that require periodic updates.
ggez is a lightweight, cross-platform 2D game framework for Rust, inspired by LÖVE. It provides a comprehensive set of subsystems for graphics, audio, input, filesystem, and timer management, all accessible through a central `Context` object. The framework abstracts over `winit` for windowing and events, `wgpu` for GPU rendering, `rodio` for audio playback, and `gilrs` for gamepad support. The architecture is modular, using sub-contexts (e.g., `GraphicsContext`, `AudioContext`) that can be individually accessed via `Has`/`HasMut` traits, allowing for custom context composition. The graphics pipeline supports 2D and optional 3D rendering (behind a feature flag) with shaders, meshes, images, instanced drawing, and text rendering via `glyph_brush`. The filesystem uses a virtual filesystem (VFS) layer with physical directories and zip archives, and configuration is handled via TOML serialization. Key entry points include `ContextBuilder` for initialization, `EventHandler` trait for the game loop (with `update`, `draw`, and input callbacks), and the `event::run()` function to start the application. Data flows are event-driven: user input is collected by `winit` and forwarded to the event handler, while rendering commands are batched and submitted to the GPU each frame. The framework also includes built-in coroutines for asynchronous tasks without futures. The repository contains over 40 examples demonstrating all major features, from simple drawing to complex 3D scenes and shader effects. ggez is actively maintained with a stable API, though some parts (e.g., 3D support, coroutine implementation) are less mature. The codebase demonstrates good engineering practices: builder patterns, resource caching, buffer sub-allocation, and a clear separation of concerns. It is suitable for hobby game development, educational projects, and rapid prototyping. The heavy reliance on evolving crates like `wgpu` and `winit` introduces some technical drift, but the framework keeps pace with updates.