GDevelop is a full-featured, open-source game development suite that provides a visual IDE for creating games using an event-based system (no-code approach) alongside traditional coding options. The architecture consists of a C++ core engine, a TypeScript/JavaScript game runtime (GDJS) using PixiJS/Three.js for rendering, and a React/Electron-based IDE. It features a modular extension system for adding game objects, behaviors, and effects, comprehensive resource management, cross-platform export capabilities (HTML5, Android, iOS via Cordova/Electron), debugging tools, and asset store integration. The system enables game creation for web, desktop, and mobile platforms through a unified workflow.
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.
This repository is a large, modular C++ game engine with a fully integrated editor. The engine core provides a world/component architecture, reflection-driven serialization, resource management, a task system, and a render abstraction layer with DirectX 11 and Vulkan backends. Runtime features are delivered as plugins: Jolt physics, FMOD/MiniAudio audio, RmlUi UI, particle effects, animation graphs, AI navigation, procedural generation, terrain, and OpenXR support. The editor is a Qt-based multi-process application: a host editor process communicates with a separate engine process over IPC, mirroring document objects into a live world for preview and manipulation. Asset managers turn imported files such as meshes, textures, skeletons, animation clips, sound events, and UI documents into versioned engine resources. Sample game applications and extensive unit tests demonstrate the runtime API and provide a working baseline for engine consumers. The codebase is production-oriented rather than research-oriented: there are no notebooks, data pipelines, or ML artifacts. Instead, it is an application and framework monorepo with strong engineering discipline visible in its consistent component/manager patterns, plugin registration conventions, and resource lifecycle management. The custom RTTI/reflection system underpins serialization, editor property grids, undo/redo, and scripting, making the engine highly data-driven. However, the code is macro-heavy and some areas, especially editor plugins, repeat near-identical boilerplate patterns across many asset types. The project is actively maintained, with recent commits, CI workflows, and a large third-party dependency set that is mostly bundled in-tree; some bundled libraries and platform-specific paths show moderate drift but not abandonment.
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.