Open-source alternatives to Defold

OpenRA is an open-source game engine designed for the development and modernization of real-time strategy titles. It provides a modular framework that allows developers to build standalone games or total conversion modifications by leveraging a trait-based entity composition system. The engine is built to support both the preservation of classic strategy games and the creation of new experiences, offering cross-platform compatibility and a flexible architecture for defining game rules and unit behaviors. The engine distinguishes itself through a configuration-driven approach where game logic,

FlaxEngine is a cross-platform game engine and development kit designed for creating high-fidelity 2D and 3D games. It functions as a programmable framework that supports the use of C# and C++ for building interactive experiences. The project includes a high-speed graphics rendering engine capable of producing professional visual assets and detailed three-dimensional scenes. It provides a pipeline for compiling and exporting project files across various operating systems using native software development kits and toolchains.

Cocos Engine is a cross-platform game engine designed for building high-performance 2D and 3D interactive experiences for web, mobile, and desktop platforms. It features a multi-backend rendering engine and a 2D and 3D physics simulator, utilizing a core architecture that combines a C++ runtime for performance with TypeScript for game logic scripting. The engine distinguishes itself through a multi-platform deployment system that packages projects for native operating systems and instant-play web ecosystems. Its graphics system supports multiple APIs, employing physically based rendering and

tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res

gdext provides a set of language bindings for writing high-performance native game logic in Rust for the Godot 4 engine. It serves as a framework for creating native engine extensions and custom classes via the GDExtension library, allowing developers to extend core engine functionality without recompiling the engine source code. The project includes a dedicated Rust WebAssembly toolchain to compile native logic into modules for execution in web browsers. This system supports WebAssembly-compatible compilation with specific configurations for web threading and module debugging. The toolkit c

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

godot-cpp is a C++ binding library and development kit for creating high-performance extensions and custom nodes for the Godot engine. It provides the necessary headers and framework to implement complex game logic and low-level systems using native code. The project enables the development of GDExtension plugins, allowing native libraries to be loaded into the engine without requiring a full recompilation of the core software. It facilitates the creation of custom engine extensions through a system of native bindings that map C++ classes and methods to the internal engine database. The fram

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

vcmi is an open-source game engine for Heroes of Might and Magic III that recreates the gameplay, logic, and rendering of the original strategy game. It serves as a cross-platform game runtime supporting Windows, Linux, macOS, Android, and iOS, providing a turn-based strategy simulator for strategic world map navigation and tactical combat. The project is built as a moddable game framework, featuring a data-driven modding system and a sandboxed Lua scripting integration. These allow for the definition of custom gameplay logic, spell effects, and the addition of new factions, characters, and a

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

LÖVE is a cross-platform game engine and framework for developing two-dimensional games using the Lua programming language. It provides a 2D graphics API for rendering shapes, images, and sprites across multiple desktop and mobile platforms. The framework enables the development of a single codebase that can be deployed to Windows, macOS, Linux, Android, and iOS. It utilizes a Lua-based scripting interface to control internal engine systems. The project covers 2D game development, mobile game development, and cross-platform game deployment.

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

Bud is a full-stack web framework for Go that functions as a scaffolding engine and code generation tool. It automates the creation of directory structures, controllers, and glue code to streamline the development of web applications. The framework utilizes a transpiler-based approach to produce application boilerplate and provides a development environment featuring hot reloading and local server management. It enables the compilation of applications into single, standalone binaries with support for cross-platform compilation across different operating systems and architectures. The system

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

Paper.js is an HTML5 Canvas vector graphics library and scripting framework used for creating and manipulating 2D shapes and paths. It functions as a vector animation framework and a headless vector graphics engine, allowing for the execution of graphics operations in both browser and server-side environments. The project features a dedicated SVG import and export engine to convert between native vector items and the SVG format. It includes a specialized boolean path operation toolkit for uniting, subtracting, and intersecting vector paths to create complex geometric shapes. The library cove

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

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

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

WickedEngine is a C++ 3D game engine and framework designed for building high-fidelity three-dimensional applications and graphics projects. It features a modern graphics renderer that implements current standards to produce complex geometry and lighting across different hardware. The engine includes a standalone visual scene editor for designing environments and configuring properties without writing code. It also provides an integrated Lua scripting environment to manage runtime logic and automate engine tasks. The framework covers 3D graphics rendering and application development, includi

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

Matrix is a suite of mobile application performance management and analysis tools. It provides a plugin-based monitoring system for capturing crashes, lags, and memory leaks, alongside a static binary auditor for reducing installation package size and a bytecode instrumentation tool for performance tracking. The project distinguishes itself through native memory debugging and a SQLite query linter that identifies inefficient database patterns. It employs native interception techniques to detect memory leaks and heap corruption without requiring source code recompilation, and uses a custom run

Turbulenz Engine is a cross-platform game engine and HTML5 framework designed for rendering graphics and simulating physics across desktop, mobile, and web environments. It functions as a WebGL graphics engine and a web-based physics engine, providing the necessary tools to build 2D and 3D games that run within browsers. The project includes a real-time multiplayer framework that synchronizes game states and player interactions between multiple users via server-side communication. This allows for the coordination of both real-time and asynchronous turn-based actions to maintain a consistent s

Ebiten is a cross-platform 2D game engine and framework for the Go programming language. It provides a hardware-accelerated 2D renderer and a multi-input handling library to develop two-dimensional games with a single codebase. The engine is designed for broad deployment, allowing applications to be compiled and run across desktops, mobile devices, web browsers, and gaming consoles. It distinguishes itself by integrating custom shader programming for specialized visual effects and providing haptic feedback control for mobile devices and gamepads. The framework covers core game development ca

This project is a procedural content generation toolkit designed for the Godot engine. It provides a collection of algorithmic techniques and modular tools for dynamically spawning game assets, map layouts, and emergent systems in both 2D and 3D environments. The framework distinguishes itself by offering specialized systems for both large-scale world construction and granular asset assembly. It supports the creation of expansive terrains and infinite worlds through noise-based distribution and shader-rendered biomes, while simultaneously providing modular systems to generate unique combat eq

MonoGame is a cross-platform game engine and framework built for the C# language and .NET ecosystem. It provides a development environment for creating 2D and 3D games that run across multiple operating systems and hardware platforms. The project serves as an open-source implementation of the XNA game studio API. It includes a dedicated game asset pipeline to convert raw art and sound files into optimized formats for efficient engine loading. The framework provides a hardware-abstraction layer to maintain a consistent interface for graphics and input across different devices. Its capabilitie

MonoGame is a cross-platform game framework and C# game engine designed for the development of interactive software. It provides a unified environment for building games that run across desktop, mobile, and console platforms using a single codebase. The framework functions as a 2D graphics rendering library, offering tools to apply custom shaders and visual effects to game assets. It utilizes a graphics abstraction layer to map drawing commands to platform-specific APIs, ensuring consistent rendering across diverse hardware. The engine manages hardware-level tasks such as input handling, aud

Cocos2d-x is a high-performance C++ game development framework designed for building and deploying interactive applications across mobile, desktop, and web platforms. It functions as a cross-platform game engine that utilizes an entity-component system to manage object lifecycles, behaviors, and spatial relationships within a unified codebase. The engine is distinguished by its specialized 2D graphics rendering pipeline, which is optimized for hardware-accelerated performance when displaying sprites, particle effects, and skeletal animations. It provides developers with low-level access to gr