Open-source alternatives to EntityComponentSystemSamples

Flecs is a high-performance entity component system framework and data-oriented programming library. It serves as a simulation engine core and game engine architecture tool, decoupling state from behavior by separating entities, components, and systems. The framework features a runtime reflection layer for dynamic data inspection and a built-in scripting system for defining entity behavior without recompilation. It also includes a network interface and REST API for remote simulation administration and state querying. The library covers a broad surface of simulation capabilities, including ar

Murder is an entity component system game engine designed for 2D game development. It provides a core framework for managing game objects through an ECS architecture and includes a dedicated 2D game editor for asset management and real-time property configuration. The engine features a specialized 2D rendering pipeline supporting pixel art, sprite slicing, and parallax effects. It includes a hierarchical A* pathfinding system for agent navigation and a comprehensive asset management system for serializing and loading game resources. The project covers a broad range of capabilities, including

The Source Engine SDK is a C++ game development kit and modding framework designed for creating game modifications and custom gameplay extensions for the Source engine. It provides a structured environment and a collection of source code and binaries required to build custom content for compatible titles. The kit serves as a toolset for C++ game engine programming, enabling the development of custom gameplay mechanics, new rulesets, and game modes. It includes the libraries and headers necessary to compile and build gameplay extensions and custom game content.

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

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

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

Entitas is a data-oriented Entity Component System framework for Unity. It is designed to separate game state into components and logic into systems, utilizing a data-oriented design to optimize CPU cache usage, memory usage, and processing speed. The framework includes a C# source code generator that automatically produces boilerplate classes, entity accessors, and context singletons to reduce manual coding. It also provides a Unity editor debugging tool for real-time runtime state visualization, system performance monitoring, and visual entity inspection. The system manages entity lifecycl

This project is a first-person shooter template for Unity that implements networked gameplay, weapon systems, and player traversal. It functions as a multiplayer system designed to synchronize movements and actions between a server and clients via a network transport layer. The project serves as an example of high-fidelity game rendering using the High Definition Render Pipeline to deliver authored content and advanced visual quality. It also demonstrates the use of an entity component system to organize game data and logic for optimized processing and execution performance. The implementati

ActionRoguelike is a third-person cooperative game project built with C++ and Unreal Engine. It functions as a networked application that utilizes replication architecture to synchronize character states and combat across multiple clients. The project implements a data-oriented performance framework that employs object pooling and asynchronous asset loading to optimize memory usage and frame rates. It features a behavior tree AI system combined with environment queries to drive autonomous NPC decision making and combat, alongside a binary serialization framework for saving actor variables and

Cyclone Physics is a three-dimensional rigid body physics engine designed for game development. It provides a framework for simulating the motion, rotation, and physical interactions of solid objects by applying fundamental laws of mechanics. The library utilizes discrete time integration to update object positions and velocities across fixed intervals. It manages complex scenes through a bounding volume hierarchy and employs impulse-based collision resolution to maintain momentum during contact. To handle simultaneous interactions, the engine uses an iterative velocity solver that repeatedly

FXGL is a 2D game engine and development framework designed for Java and Kotlin. It provides a structured environment for building cross-platform desktop games, integrating a central game loop with an entity component system and a JavaFX-based scene graph for rendering. The toolkit distinguishes itself by providing a comprehensive suite of integrated libraries for game AI pathfinding, physics collision resolution, and multiplayer networking via TCP and UDP protocols. It includes specialized systems for adaptive user interface design using global stylesheets and a data-driven asset management

Source Engine is a cross-platform game engine designed for the development and execution of interactive three-dimensional applications. It provides a framework for rendering complex environments and managing multiplayer networking, functioning as a middleware solution for hosting independent game servers. The engine distinguishes itself through a client-server authoritative networking model that enables direct player connectivity without reliance on external authentication or matchmaking services. It utilizes a data-driven asset pipeline and a component-based entity system to decouple engine

Entitas-CSharp is a data-oriented architectural framework for managing application state and logic in C# and Unity environments. It implements the Entity Component System pattern to separate raw data components from the logic systems that process them. The framework includes a code generator that automatically produces type-safe boilerplate classes and methods at build time. It also provides a visual state inspector for examining entities and components in real time within the Unity editor. The library covers data-oriented programming and game state debugging, utilizing a memory-efficient ap

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

EnTT is a C++ library designed for data-oriented design and entity component system architecture. It provides a framework for managing game objects and simulation states by separating entity data from logic, allowing for the efficient organization and manipulation of large collections of related data objects. The library utilizes sparse sets to store entities and components in contiguous memory, which facilitates cache-friendly iteration and constant-time lookups. It employs template metaprogramming for compile-time type reflection and type-erasure techniques to provide a unified interface fo

Mindustry is a cross-platform game engine and factory automation simulation that combines resource management with tower defense strategy. Players construct complex supply chains and automated networks to process materials while building defensive structures to protect a core from waves of hostile mechanical forces. The project utilizes a deterministic lockstep networking model to ensure simulation consistency across desktop and mobile devices. It is built on an entity-component-system architecture and a tile-based grid simulation, allowing for the efficient management of thousands of active

cannon.js is a JavaScript 3D physics engine designed for calculating rigid body dynamics and collisions in three-dimensional space. It functions as a rigid body dynamics engine that models mass, friction, and velocity to determine object movement, while providing a mathematical framework for applying physical constraints and joints. The engine supports a variety of collision volumes, including spheres, boxes, convex polyhedrons, heightfields for terrain simulation, and complex triangle meshes. It provides tools for identifying intersections between these shapes and calculating the exact areas

Flowgram.ai is a workflow development framework for building AI workflow platforms. It provides a visual drag-and-drop canvas for constructing workflows, an Entity-Component-System (ECS) based document model for structuring workflow nodes as a tree, and a node-based form engine for managing configuration forms with built-in rendering, validation, side effects, and error handling. The framework also includes a workflow execution engine that parses directed graph workflows and runs nodes step by step with state tracking and array iteration. The framework distinguishes itself through a layered r

Rapier is a cross-platform physics engine and rigid body dynamics solver designed for 2D and 3D simulations. It functions as a collision detection system and a robotics simulation framework, providing a consistent API for calculating physical interactions across different environments. The engine distinguishes itself with specialized robotics capabilities, including a toolkit for importing URDF and STL models to control multibody chains. It supports precise mechanical movement through inverse kinematics calculations and the application of PID controllers for dynamic body control. The simulat

Piccolo is a mini game engine designed for building small-scale games with cross-platform support. It compiles and runs on Windows, macOS, and Linux from a unified codebase, and includes an editor integration for live editing and debugging. The engine uses a component-based entity system with data-oriented design, storing component data in contiguous arrays for cache-friendly iteration. It features a fixed timestep game loop that decouples simulation updates from rendering frame rate, and provides a physics debug overlay that renders visual shapes from simulation data synchronized with the ed

This is a web-based 3D game engine designed for creating high-performance interactive experiences on web and mobile platforms. It functions as a real-time graphics renderer and physics engine, utilizing a component-based scene graph to organize entities and their properties for three-dimensional rendering. The engine includes a visual scene editor that allows for the design of environments through a graphical interface, which then exports these assets as executable code. Its broader capabilities cover real-time graphics rendering for 2D and 3D elements, physical world simulation for object c

Orillusion is a WebGPU 3D rendering engine designed for high-fidelity scenes and visual effects in the browser. It functions as a GPU compute framework for parallel mathematical operations and a physically-based rendering graphics pipeline for realistic materials and surfaces. The system also includes a web-based 3D animation toolkit for driving skeletal animations and interpolating vertex positions. The engine is distinguished by its use of an entity component system for scene logic and a macro-based shader generation system that creates multiple shader variants. It optimizes performance thr

s&box is a game development platform built on Valve's Source 2 engine, integrating the .NET runtime as a first-class scripting and gameplay logic layer. It provides a full-featured visual editor that combines asset management, level design, and code editing into a single workflow, enabling developers to create and edit games within a modern editor environment. The platform distinguishes itself through a managed-native interop bridge that allows C# code to interact directly with native Source 2 systems for high-performance communication, alongside a hot-reload scripting system that supports li

Flame is a 2D game engine for Flutter and Dart. It provides a component-based game framework for managing entities and their lifecycles through a hierarchical architecture, alongside a dedicated system for game asset management and input handling. The engine distinguishes itself through a specialized integration layer for external physics engines to handle rigid body dynamics and collision detection. It also features a high-performance task model that uses isolates to offload heavy computations and prevent main thread blocking. The framework covers a broad range of capabilities including vis

The Forge is a low-level toolkit for building high-performance graphics engines and applications across desktop, mobile, and console platforms. It provides a cross-platform engine framework and a dedicated shader compiler that translates a single source into target-specific languages for various graphics APIs and hardware. The project includes a GPU memory and resource manager that utilizes unified root signatures for resource binding, alongside a ray tracing rendering pipeline that implements hardware-accelerated ray and path tracing queries. State management is handled through a high-perfor

Citybound is an open-source multiplayer city simulation game and collaborative urban planner. It provides a shared digital space where multiple users co-manage city growth, design infrastructure layouts, and develop urban environments in real time. The project functions as a collaborative city builder, allowing players to plan and evolve a virtual city together. Changes made to the urban environment are reflected immediately for all connected participants within the shared simulation. The system utilizes an entity-component simulation to manage urban behavior and a shared-world coordinate sy

Babylon.js is a JavaScript game engine and real-time graphics renderer designed for creating interactive three-dimensional visuals and applications. It functions as a web-based 3D framework and WebGL engine that enables the deployment of high-performance 3D content across various web platforms and devices. The project provides tools for web-based 3D game development, real-time graphics rendering, and the creation of browser-based interactive visualizations. It also supports the development of WebXR virtual and augmented reality experiences using standard web technologies. The framework cover