Flecs v3.1
A fast entity component system (ECS) for C & C++
Loading...
Searching...
No Matches
Flecs

Version MIT Documentation actions Discord Chat

Flecs is a fast and lightweight Entity Component System that lets you build games and simulations with millions of entities (join the Discord!). Here are some of the framework's highlights:

  • Fast and portable zero dependency C99 API
  • Modern type-safe C++11 API that doesn't use STL containers
  • First open source ECS with full support for Entity Relationships!
  • Fast native support for hierarchies and prefabs
  • Code base that builds in less than 5 seconds
  • Runs in the browser without modifications with emscripten
  • Cache friendly archetype/SoA storage that can process millions of entities every frame
  • Supports entities with hundreds of components and applications with tens of thousands of archetypes
  • Automatic component registration that works out of the box across shared libraries/DLLs
  • Write free functions with queries or run code automatically in systems
  • Run games on multiple CPU cores with a fast lockless scheduler
  • Compiles warning-free on 8 compilers on all major platforms, with CI running more than 5000 tests
  • Integrated reflection framework with JSON serializer and support for runtime components
  • Unit annotations for components
  • Powerful query language with support for joins and inheritance
  • Statistics addon for profiling ECS performance
  • A web-based dashboard (demo, code) for inspecting entities, running ECS queries and monitoring games:

To support the project, give it a star 🌟 !

What is an Entity Component System?

ECS is a way of organizing code and data that lets you build games that are larger, more complex and are easier to extend. Something is called an ECS when it:

  • Has entities that uniquely identify objects in a game
  • Has components which are datatypes that can be added to entities
  • Has systems which are functions that run for all entities matching a component query

For more information, check the ECS FAQ!

Documentation

Performance

For a list of regularly tracked benchmarks, see the ECS Benchmark project.

Show me the code!

C99 example:

typedef struct {
float x, y;
} Position, Velocity;
void Move(ecs_iter_t *it) {
Position *p = ecs_field(it, Position, 1);
Velocity *v = ecs_field(it, Velocity, 2);
for (int i = 0; i < it->count; i++) {
p[i].x += v[i].x;
p[i].y += v[i].y;
}
}
int main(int argc, char *argv[]) {
ECS_COMPONENT(ecs, Position);
ECS_COMPONENT(ecs, Velocity);
ECS_SYSTEM(ecs, Move, EcsOnUpdate, Position, Velocity);
ecs_set(ecs, e, Position, {10, 20});
ecs_set(ecs, e, Velocity, {1, 2});
while (ecs_progress(ecs, 0)) { }
}
FLECS_API bool ecs_progress(ecs_world_t *world, ecs_ftime_t delta_time)
Progress a world.
#define ECS_SYSTEM(world, id, phase,...)
Declare & define a system.
Definition: system.h:131
ecs_id_t ecs_entity_t
An entity identifier.
Definition: flecs.h:220
struct ecs_world_t ecs_world_t
A world is the container for all ECS data and supporting features.
Definition: flecs.h:229
ecs_entity_t ecs_new_id(ecs_world_t *world)
Create new entity id.
#define ECS_COMPONENT(world, id)
Declare & define a component.
Definition: flecs_c.h:120
ecs_world_t * ecs_init(void)
Create a new world.

Same example in C++11:

struct Position {
float x, y;
};
struct Velocity {
float x, y;
};
int main(int argc, char *argv[]) {
ecs.system<Position, const Velocity>()
.each([](Position& p, const Velocity& v) {
p.x += v.x;
p.y += v.y;
});
auto e = ecs.entity()
.set([](Position& p, Velocity& v) {
p = {10, 20};
v = {1, 2};
});
while (ecs.progress()) { }
}
void each(Func &&func) const
Iterate over all entities with components in argument list of function.
flecs::entity entity(Args &&... args) const
Create an entity.
The world.
Definition: world.hpp:113
flecs::system system(flecs::entity e) const
Upcast entity to a system.

Projects using Flecs

If you have a project you'd like to share, let me know on Discord!

Territory Control

https://store.steampowered.com/app/690290/Territory_Control_2/

Sol Survivor

https://nicok.itch.io/sol-survivor-demo

The Forge

https://github.com/ConfettiFX/The-Forge

Equilibrium Engine

https://github.com/clibequilibrium/EquilibriumEngine

Gravitas

https://thepunkcollective.itch.io/gravitas

After Sun

https://github.com/foxnne/aftersun

Tower defense (open source demo)

https://www.flecs.dev/tower_defense/etc (repository)

Procedural City (open source demo)

https://www.flecs.dev/city (repository)

Resources

Resources provided by the community :heart:

Flecs around the web

Flecs Hub

Flecs Hub is a collection of repositories that show how Flecs can be used to build game systems like input handling, hierarchical transforms and rendering.

Module Description
flecs.components.cglm Component registration for cglm (math) types
flecs.components.input Components that describe keyboard and mouse input
flecs.components.transform Components that describe position, rotation and scale
flecs.components.physics Components that describe physics and movement
flecs.components.geometry Components that describe geometry
flecs.components.graphics Components used for computer graphics
flecs.components.gui Components used to describe GUI components
flecs.systems.transform Hierarchical transforms for scene graphs
flecs.systems.physics Systems for moving objects and collision detection
flecs.systems.sokol Sokol-based renderer
flecs.game Generic game systems, like a camera controller

Language bindings

The following language bindings have been developed with Flecs! Note that these are projects built and maintained by helpful community members, and may not always be up to date with the latest commit from master!