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.
A monorepo providing `@pixiv/three-vrm`, a library for loading, controlling, and rendering VRM (Virtual Reality Model) avatars in three.js. It implements VRM 1.0 and partial VRM 0.0 specifications, handling humanoid bone mapping, facial expressions, eye gaze control (lookAt), first-person mesh culling, spring bone physics simulation, node constraints (aim, roll, rotation), and MToon toon material rendering. The library is structured as a collection of GLTFLoader plugins that parse VRM extensions from `.vrm` files. Core modules include `VRMLoaderPlugin` (orchestrating sub-plugins), `VRMCore` (humanoid, expressions, lookAt, firstPerson), `VRMSpringBoneManager` (verlet physics), `VRMNodeConstraintManager` (topological sort for constraints), and `MToonMaterial`/`MToonNodeMaterial` (custom shader/material for toon rendering). Both WebGL and experimental WebGPU renderers are supported. The codebase includes thorough examples, CI/CD, and compatibility shims for multiple three.js revisions (r123 through r180).
ChaosTools.jl is a Julia library providing tools for analyzing nonlinear dynamics and chaotic behavior. It offers functionality for calculating Lyapunov exponents, detecting chaos via methods like GALI and the 0-1 test, analyzing predictability, finding fixed points and periodic orbits, estimating signal periods, analyzing rare events through return time statistics, and performing dimensionality reduction. The package is designed to work with DynamicalSystems.jl and can be used as a standalone package or as part of the broader DynamicalSystems ecosystem. The architecture follows a modular organization with functions grouped by topic (chaos detection, dimensionality reduction, periodicity, etc.), leveraging Julia's multiple dispatch and type system for clean, reusable code.
This repository is the official collection of Godot Engine demo projects, maintained by the Godot Foundation. It contains hundreds of self-contained, runnable demo projects that showcase specific engine features across 2D, 3D, audio, GUI, networking, XR, mobile, compute shaders, and editor plugins. Each demo is a standalone Godot project with its own project.godot, scenes, scripts, and assets. The repository serves as both a learning resource for developers and a testbed for engine capabilities. While not a single application, it demonstrates a wide range of game development patterns and engine APIs. Notable highlights include a generic state machine implementation, a 2.5D node system, a virtual joystick for touch input, a custom logger with UI integration, and a JSON-driven dialogue system. The codebase is actively maintained with recent commits, low technical drift, and consistent use of modern Godot 4.x APIs.
Kaiju Engine is a full-featured 2D/3D game engine written in Go, backed by Vulkan for rendering. It includes a built-in editor that runs as a game within the engine, providing workspaces for stage management, shader design, render graph editing, terrain painting, and content browsing. The engine core handles entity management, physics (custom Graviton engine with rigid bodies, constraints, and collision detection), audio (SoLoud via CGo), networking (UDP with reliability), UI (custom HTML/CSS markup engine with flexbox/grid layout), asset pipeline (glTF, FBX, textures, fonts), and cross-platform support (Windows, Linux, macOS, Android). The editor adds undo/redo history, action system with key bindings, Lua scripting, a Web API, and a plugin system. The codebase is a monorepo with heavy use of Go build tags for platform-specific code and feature flags.
PhySO (Physical Symbolic Optimization) is a Python library for symbolic regression using deep reinforcement learning, with a strong emphasis on physics-informed constraints such as dimensional analysis. It discovers closed-form analytical expressions from data, supporting both single-dataset symbolic regression (SR) and multi-dataset class symbolic regression (Class SR) where the same functional form is shared across realizations with per-dataset free constants. The core architecture consists of a token-based program representation (reverse Polish notation), a custom LSTM-based policy network, a modular prior system (hard/soft length, physical units, nesting limits), and an efficient batch execution engine with optional parallel free-constant optimization. The library provides high-level entry points (`physo.SR()` and `physo.ClassSR()`), configuration presets, and a toolkit for expression manipulation and random generation. It includes extensive benchmarking infrastructure (Feynman and Class benchmarks), demos for real-world problems (e.g., Milky Way streams, US tariffs), and unit tests. External dependencies include PyTorch, NumPy, SymPy, pandas, scikit-learn, and matplotlib. While primarily a software library for symbolic regression, it is deeply research-oriented with benchmark result CSVs and analysis scripts, giving it a hybrid application/research character.
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.
Cocos Creator engine runtime is a cross-platform 2D/3D game engine framework written in TypeScript and C++. It provides a component-entity architecture with scene graph, rendering pipelines (forward/deferred/custom), physics (PhysX, Bullet, Box2D, builtin), animation (marionette state machine, pose graph, Spine, DragonBones), audio, UI, particle systems, and asset management. The engine is designed to be used with the Cocos Creator editor but can run standalone. It abstracts platform-specific APIs (graphics, input, audio, system) behind a common interface, supporting Web, iOS, Android, Windows, macOS, Linux, and various mini-game platforms. Key entry points include the Director, Scene, Node, Component, and the rendering pipeline. External dependencies include graphics APIs (Vulkan, Metal, GLES, WebGPU), physics libraries (PhysX, Bullet, Box2D), and scripting engines (V8, SpiderMonkey, JavaScriptCore).
CrystalEngine is a full-featured, cross-platform game engine with an integrated editor, built from scratch in C++. It features a custom Vulkan/Metal rendering backend with a directed acyclic frame graph for render pass scheduling, a physically-based rendering pipeline with IBL and shadow mapping, and a modular architecture with dynamic module loading. The engine includes a comprehensive asset pipeline (import, compression, serialization), a job system for parallelism, and a physics integration via Jolt. A notable aspect is the dual UI framework: the older CrystalWidgets (CSS-styled) and the newer Fusion framework (declarative, property-based), both used in the editor. The editor provides dockable windows, property editors, material editing, scene outliner, and asset browser. The codebase demonstrates strong engineering with clean abstractions (RHI, RPI, frame graph, job system) but shows signs of ongoing migration (two UI frameworks) and some incomplete features. It is actively maintained and suitable for learning or extending a modern game engine architecture.
BabylonToolkit is a comprehensive game development framework built on Babylon.js, providing a Unity-like scripting system with entity-component architecture. It includes a runtime library (babylon.toolkit.js) with components for scene management, physics (Havok), navigation (Recast/Detour), animation blending, tweening, object pooling, trigger volumes, custom shader materials, and UI export from Unity. The toolkit also offers editor plugins for Unity and Unreal exporters, shader material examples, and VSCode snippets for rapid prototyping. External dependencies include Babylon.js, Havok Physics, Recast/Detour, and Unity Editor. The architecture is a library with a central SceneManager and ScriptComponent lifecycle, plus optional shader plugins. Key entry points are the runtime script and the Unity exporter pipeline. The code shows high craftsmanship in areas like custom shader materials and tweening, but has risks of duplication in shader code and reliance on large binary Unity packages.
YapAnimator is a physics-based animation library for iOS, tvOS, and macOS, written in Swift 3.1. It provides a generic `YapAnimator<T>` class that animates any value conforming to the `Animatable` protocol by decomposing it into an array of doubles and applying spring physics integration with a fixed 1/240s timestep. The library includes a convenience layer (`YapAnimatedLayer`) attached to `CALayer` via associated objects, enabling one-liner animations of layer properties like position, bounds, opacity, transform, etc. The core engine runs on a display link (CADisplayLink on iOS/tvOS, CVDisplayLink on macOS) and manages all active animators. The repository is explicitly archived and no longer maintained, with Swift 3.0/3.1 dependencies and no updates since 2017.