Open-source alternatives to FlaxEngine

Ogre is a high-level 3D rendering engine designed for creating games, simulations, and visualizations without requiring low-level graphics API code. It functions as a framework for real-time 3D graphics processing, providing a physically based renderer to simulate lifelike surfaces and lighting. The engine includes specialized systems for skeletal animation to control character movement and a terrain generation system for producing large textured landscapes. These features are supported by automatic levels of detail and distance-based mesh management to maintain performance. The project cove

Stride is a C# game engine and 3D rendering engine used for building three-dimensional games and virtual reality applications. It functions as a comprehensive framework and development kit for creating immersive experiences within a managed code environment. The project includes a developer GUI framework for building internal debugging tools and utility panels. It also serves as a 3D physics simulator for calculating rigid body dynamics and collision detection within a scene. The engine covers environmental scene rendering and project scaffolding workflows. It provides tooling for game devel

Panda3D is a cross-platform game engine and 3D graphics rendering system developed for Python and C++. It functions as a comprehensive framework for building interactive 3D applications, providing a real-time physics simulator and a specialized 3D asset pipeline tool. The engine distinguishes itself by combining a high-performance C++ core with interoperable Python language bindings. It utilizes a scene graph architecture to organize 3D objects and provides a pipeline-based asset conversion system to optimize models and textures for runtime loading. Its capability surface includes low-level

LumixEngine is a high-performance C++ 3D game engine designed for building interactive 3D applications. It is built on a data-oriented component system that organizes objects in contiguous memory blocks to maximize CPU cache performance. The engine features a dynamic binary plugin architecture for loading external modules at runtime and an embedded scripting virtual machine that exposes internal logic for external control without recompilation. Computational workloads are managed via a task-based parallel execution model that distributes jobs across multiple processor cores. The framework in

This project is an open-source 3D game engine designed for building high-fidelity games, simulations, and cinematic environments. It functions as a robotics simulation platform with native integration for ROS 2 to model robot controllers and sensors. The engine features a multi-threaded Forward+ physically based renderer that supports hardware-accelerated ray tracing and global illumination. The system is built on a modular extension architecture using Gems to add or replace features without modifying core binaries. It includes a native SDK for AWS cloud integration, enabling IAM authenticati

Defold is a cross-platform game engine and integrated development environment used to create 2D and 3D games for desktop, mobile, and web targets. It combines a game development IDE for asset and scene management with a multi-platform build system and a scripting environment based on Lua. The engine includes a specialized headless runtime for hosting game servers and performing automated testing without a graphical interface. It supports native engine extensions, allowing custom low-level code to be integrated into the core to expand functionality beyond the standard scripting interface. The

whs.js is a WebGL 3D game engine and extensible application framework used to create interactive 3D experiences and browser-based games. It provides a simplified abstraction layer over low-level WebGL rendering to manage cameras, lighting, and the overall 3D environment. The framework utilizes a modular 3D scene graph to organize objects into a hierarchical system of components. It integrates multithreaded physics simulation by using web workers to run calculations in parallel with the main render loop. The system includes a modular plugin architecture that allows for the extension of base a

This project is a high-performance 3D game engine implementation written in C++. Its primary purpose centers on game engine development and retro game preservation, allowing for the study and compilation of original source code from a classic title. The engine utilizes a custom asset pipeline that integrates 3D models and scene data from Maya via a specialized export plugin. It is designed to be compiled across Windows, Linux, and macOS through a platform-specific build abstraction. Technical capabilities cover real-time OpenGL rendering, state-based game logic, and binary resource packaging

Urho3D is a cross-platform 3D game engine written in C++. It uses a component-based scene graph to compose game objects from nodes and attached components, separating transforms from behaviors for modular design. The engine integrates AngelScript and Lua scripting for game logic, uses the Bullet library for physics simulation, and renders scenes with OpenGL or Direct3D through forward, deferred, or light pre-pass pipelines with customizable render passes and shadow mapping. The engine distinguishes itself with a built-in visual scene and UI editor for composing 3D worlds and interface layouts

The GoldSrc game engine is a 3D game framework and first-person shooter engine designed for building and running interactive software. It functions as a moddable game framework, providing a system for creating custom game rules and content through client-side code and shared libraries. The project includes a game engine SDK and development tools for compiling custom game logic into dynamic link libraries. This modular structure allows for the development and distribution of game modifications on Windows and Linux platforms.

Phaser is a cross-platform 2D web game engine and framework designed for creating interactive experiences that run on desktop and mobile web browsers. It serves as a GPU-accelerated rendering library and WebGL graphics engine for building two-dimensional games using HTML5 Canvas and WebGL. The engine features a dual-backend rendering pipeline that allows developers to switch between rendering paths. It distinguishes itself through high-performance graphics capabilities, including GPU-driven sprite batching for large-scale image management, a dynamic lighting system with self-shadows, and the

This project is a high-level 3D graphics engine designed to render complex, hardware-accelerated environments within web browsers. It provides a comprehensive abstraction layer that manages scene graphs, cameras, and lighting, mapping high-level scene definitions onto low-level graphics APIs. By decoupling these definitions from specific hardware targets, the engine ensures consistent performance across diverse browsers and devices. The framework distinguishes itself through a robust architecture that includes a unified math library for high-frequency spatial calculations and a physically bas

Hazel is a C++ game development framework and 3D graphics rendering engine designed for building high-performance interactive software. It provides a foundational architecture that enables the construction of desktop applications through native hardware acceleration. The project includes a dedicated game engine editor that allows for the design and testing of interactive 3D and 2D scenes within a unified environment. This editor utilizes an immediate mode interface to maintain synchronization with the engine state, while a hardware-agnostic abstraction layer handles rendering commands across

Fyrox is a Rust-based game engine for building both 2D and 3D games, designed as a native engine with no runtime dependencies. It compiles directly to native code for Windows, macOS, Linux, and WebAssembly, providing direct hardware access through the Rust programming language. The engine is built around an entity-component-system architecture that organizes game objects as entities with attached components processed by modular systems. Its graph-based scene management represents game scenes as directed acyclic graphs of nodes with transform hierarchies and property inheritance, while a paral

Halley is a modular C++ game engine designed for building cross-platform interactive applications. Its core identity is defined by a hardware-abstraction graphics pipeline for consistent rendering across different operating systems and an entity-component-system architecture that separates game state from processing logic. The framework features a hot-reloading development environment that allows updating application logic and assets at runtime without requiring a full process restart. It also includes a multiplayer networking framework based on an asynchronous messaging system to manage real

GB Studio is a visual integrated development environment and game engine for creating 8-bit games for Game Boy hardware. It functions as a retro hardware ROM compiler that transpiles graphical logic into native Z80 assembly and binary images compatible with original handhelds and emulators. The project serves as a cross-platform build tool, generating both native hardware ROMs and web-compatible builds from a single project source. It utilizes a drag-and-drop interface for game logic and scene design, allowing for the creation of game mechanics and asset placement without writing low-level ma

Ren'Py is a cross-platform game engine and interactive storytelling tool built around a Python-based scripting engine. It is designed for creating visual novels and branching narrative games, where player choices determine story paths and character interactions. The engine provides a complete development framework for building narrative-driven experiences, from simple dialogue trees to complex life simulation games. The engine distinguishes itself through a comprehensive set of integrated systems that handle the full lifecycle of interactive storytelling. Its script-based story engine compile

Bevy is a cross-platform game engine and framework built in Rust, designed for creating interactive simulations and graphical applications. It utilizes a data-oriented entity-component-system architecture to manage game state, organizing data into contiguous memory blocks to facilitate high-performance processing and massive parallelization of entities. The engine distinguishes itself through a modular plugin architecture and a system-based task scheduler that automatically parallelizes logic by analyzing data access patterns. By employing reactive change detection and deferred command buffer

GDevelop is a no-code game engine designed for building interactive 2D applications through a visual scripting environment. It allows users to define game logic and object interactions using a graphical interface of conditions and actions, eliminating the need for traditional programming. The platform functions as a cross-platform creator, enabling the export of projects to web, desktop, and mobile environments from a single codebase. The engine is built on a modular game development extension framework that supports the creation and sharing of reusable behaviors and logic components. Develop

This project is an open-source game engine designed as a collaborative platform for building and distributing interactive software. It provides a shared environment for developers to coordinate contributions and manage the development of game mechanics through collective maintenance. The engine utilizes a distributed version control workflow to track granular code changes and manage feature integration across teams. By employing modular architecture, the system allows for the independent development of core game components, facilitating scalable gameplay features and structured collaboration.

Boardgame.io is a framework for developing turn-based, multiplayer games for the web. It functions as a game engine and orchestrator that manages the complexities of state synchronization, player turn order, and rule enforcement across a distributed network of clients. The framework utilizes pure functions to handle state transitions, ensuring that game logic remains predictable and consistent for all participants. By structuring game flow into hierarchical phases and turn-based segments, it automates transitions and enforces rules, preventing illegal moves while maintaining a synchronized vi

This project is a WebGL 3D game engine and comprehensive suite of tools for rendering high-performance 3D graphics and interactive scenes in the browser using WebGL and WebGPU. It provides a dedicated WebXR framework for building augmented and virtual reality experiences that run directly in a web browser. The engine includes a specialized Gaussian splatting renderer for displaying 3D point-cloud data to create photorealistic environmental captures. It utilizes a glTF asset pipeline to load and stream compressed 3D models and textures for efficient asset delivery. The system covers real-time

jynew is a 3D RPG game engine and development framework designed for building three-dimensional role playing games. It provides a comprehensive suite of tools for scene editing, game logic scripting, and the creation of 3D environments. The project features a specialized 3D asset management pipeline for importing and aligning models and animations, including specific tools for weapon attachment and rendering. It includes a dedicated combat system editor for defining battle encounters, skill effects, and combat grids with real-time synchronization. Additionally, it provides a game modding fram

Kaiju is a general purpose 2D and 3D game engine built with the Go programming language and the Vulkan graphics API. It serves as a cross-platform game framework for deploying interactive applications to Windows, Linux, Mac, and Android. The engine includes an integrated game editor for composing scenes, managing assets, and designing shaders within a visual workspace. It provides a dedicated shader designer workspace that supports real-time hot-reloading, allowing visual changes to be seen instantly without restarting the application. The framework covers a broad range of production systems

Ant is a modular game engine framework designed for building interactive 3D experiences. It provides a core runtime infrastructure that supports the integration of independent, reusable functional packages to extend engine capabilities. The engine features a specialized ahead-of-time asset pipeline that transforms raw 3D models, textures, and shaders into optimized binary formats. By utilizing pre-computed memory-mapped layouts, the system minimizes runtime processing overhead and improves loading speeds for game assets. Development is supported by a scriptable world editor that allows for s

This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

LWJGL is a cross-platform library that provides Java bindings to native APIs for graphics, audio, compute, windowing, and input. It enables Java applications to access low-level hardware-accelerated capabilities such as OpenGL and Vulkan rendering, OpenAL 3D audio, OpenCL GPU compute, and GLFW windowing and input handling. Under the hood, LWJGL dynamically resolves native function pointers at runtime, loads platform-specific shared libraries, and uses generated JNI bindings to bridge Java and native code. It offers explicit memory management through direct buffer access and stack-allocated me