Flecs is a high-performance Entity Component System (ECS) framework for games and simulations, written in C99 with a C++17 wrapper. It provides a data-oriented storage model where entities are stored in archetype tables with component columns, enabling cache-efficient iteration. The framework includes a powerful query language with support for relationships, inheritance, traversal, grouping, and sorting. It features an extensive addon system covering systems (pipelines), observers, prefabs, reflection/meta, JSON serialization, an embedded scripting language (Flecs Script) with async/await, a REST API with an HTTP server, statistics/metrics, alerts, and more. Flecs has zero external dependencies and is designed for lockless multi-core scheduling. It is used in commercial games and has a large ecosystem of examples and community bindings. Architecture: The library is modular with a core C API and optional addons compiled via preprocessor flags. The C++ API provides a fluent builder pattern for constructing entities, systems, queries, and observers. Key entry points include ecs_init/flecs::world for world creation, ecs_progress for running the game loop, ecs_insert for entity creation, ecs_system for defining systems, ecs_query for cached queries, and ecs_script for running Flecs Script files. Data flows involve creating entities with components, which are stored in tables; systems iterate over matching entities each frame; observers react to component changes; and the script engine allows runtime entity manipulation. External dependencies: None. Flecs is self-contained and uses only standard C library functions.
Genesis is a universal physics engine designed for robotics and physical AI simulation. It provides a unified multi-physics framework supporting rigid-body dynamics, finite element method (FEM), material point method (MPM), position-based dynamics (PBD), smoothed particle hydrodynamics (SPH), and incremental potential contact (IPC) coupling. The engine is GPU-accelerated via a custom compiler (Quadrants, forked from Taichi) and scales from single-CPU laptops to multi-GPU datacenters. It features differentiable simulation with gradient tape and manual backward passes, enabling end-to-end optimization through physics. The architecture follows a scene-entity-solver pattern with pydantic-based options for configuration, a plugin-based sensor system (cameras, IMU, tactile, lidar, etc.), and multiple rendering backends (rasterizer, raytracer, batch renderer). Robotics-specific features include URDF/MJCF/USD asset import, inverse kinematics, PD control, and reinforcement learning integration via rsl-rl. The codebase is well-structured with extensive tests, CI/CD pipelines, and a large set of examples covering manipulation, locomotion, deformables, fluids, and coupling scenarios. While the engine is primarily an application library, it also serves as a research platform for differentiable physics and novel simulation techniques.
ConcurrentSim.jl is a discrete-event process-oriented simulation framework for Julia, directly inspired by Python's SimPy. It provides a simulation engine where user-defined processes (implemented as coroutines via the ResumableFunctions.jl @resumable macro) yield events that are scheduled on a priority-ordered event heap. The framework offers a complete set of resource primitives for modeling limited-capacity congestion points: Resource (a lock-like container with capacity ≥1), Container (arbitrary capacity with continuous levels), Store (unordered collection with item filtering), QueueStore (FIFO), StackStore (LIFO), and DelayQueue (FIFO with configurable latency). Event operators (&, |) provide combinatorial AND/OR synchronization, and the framework supports both Float64 simulation time and wall-clock DateTime-based scheduling. The architecture is cleanly separated across modules: the Simulation environment manages the event heap, clock, and active process; a shared BaseEvent struct implements the callback mechanism; processes integrate with the event loop via a custom finite-state machine iterator from ResumableFunctions; resources build on a common trigger/dispatch abstraction in resources/base.jl. The codebase displays mature engineering practices: CI across Julia 1.10–1.12 plus nightly (Windows, macOS, Linux), automated static analysis via Aqua and JET, a 14-file test suite with doctests, a benchmark suite comparing old and new process implementations, and comprehensive documentation. It is the successor to SimJulia and one of the longest-lived Julia packages. The repository also contains three example notebooks, but these are legacy artifacts targeting Julia 0.6 (using deprecated APIs like put/release/srand) and should be considered historical rather than current usage guides.