A fast entity component system (ECS) for C & C++

Overview

flecs

CI build codecov Discord Chat Try online Documentation

Flecs is a fast and lightweight Entity Component System with a focus on high performance game development (join the Discord!). Highlights of the framework are:

  • Fast to compile & integrate in any project with zero-dependency core that is written entirely in C99
  • Provides (SoA) access to raw component arrays for optimal cache efficiency and vectorization
  • Archetype-storage with unique graph-based design enables high performance entity mutations
  • Flexible API primitives allow for efficient implementation of prefabs, runtime tags and entity graphs
  • Supports advanced queries that are entirely evaluated offline to eliminate searching from the main loop
  • Lockless threading design allows for efficient execution of systems on multiple threads
  • A dashboard module for tracking application metrics (see below for repository link):

Screen Shot 2020-12-02 at 1 28 04 AM

What is an Entity Component System?

ECS (Entity Component System) is a design pattern used in games and simulations that produces fast and reusable code. Dynamic composition is a first-class citizen in ECS, and there is a strict separation between data and behavior. A framework is an Entity Component System if it:

  • Has entities that are unique identifiers
  • Has components that are plain data types
  • Has systems which are behavior matched with entities based on their components

Documentation

See Docsforge for a more readable version of the documentation.

Example

This is a simple flecs example in the C99 API:

typedef struct {
  float x;
  float y;
} Position, Velocity;

void Move(ecs_iter_t *it) {
  Position *p = ecs_column(it, Position, 1);
  Velocity *v = ecs_column(it, Velocity, 2);
  
  for (int i = 0; i < it.count; i ++) {
    p[i].x += v[i].x * it->delta_time;
    p[i].y += v[i].y * it->delta_time;
    printf("Entity %s moved!\n", ecs_get_name(it->world, it->entities[i]));
  }
}

int main(int argc, char *argv[]) {
  ecs_world_t *ecs = ecs_init();
    
  ECS_COMPONENT(ecs, Position);
  ECS_COMPONENT(ecs, Velocity);
    
  ECS_SYSTEM(ecs, Move, EcsOnUpdate, Position, [in] Velocity);
    
  ecs_entity_t e = ecs_set(ecs, 0, EcsName, {"MyEntity"});
  ecs_set(ecs, e, Position, {0, 0});
  ecs_set(ecs, e, Velocity, {1, 1});

  while (ecs_progress(ecs, 0)) { }
}

Here is the same example but in the C++11 API:

struct Position {
  float x;
  float y;
};

struct Velocity {
  float x;
  float y;
};

int main(int argc, char *argv[]) {
  flecs::world ecs;

  ecs.system<Position, const Velocity>()
    .each([](flecs::entity e, Position& p, const Velocity& v) {
      p.x += v.x * e.delta_time();
      p.y += v.y * e.delta_time();
      std::cout << "Entity " << e.name() << " moved!" << std::endl;
    });

  ecs.entity("MyEntity")
    .set<Position>({0, 0})
    .set<Velocity>({1, 1});

  while (ecs.progress()) { }
}

Building

The easiest way to add Flecs to a project is to add flecs.c and flecs.h to your source code. These files can be added to both C and C++ projects (the C++ API is embedded in flecs.h). Alternatively you can also build Flecs as a library by using the cmake, meson, bazel or bake buildfiles.

Custom builds

The Flecs source has a modular design which makes it easy to strip out code you don't need. At its core, Flecs is a minimalistic ECS library with a lot of optional features that you can choose to include or not. This section of the manual describes how to customize which features to include.

Software Quality

To ensure stability of Flecs, the code is thoroughly tested on every commit:

  • 40.000 lines of test code, for 18.000 lines of framework code
  • More than 1600 testcases
  • Over 90% code coverage

The code is validated on the following platforms/compilers:

  • Windows
    • msvc
  • Ubuntu
    • gcc 7, 8, 9, 10
    • clang 8, 9
  • MacOS
    • gcc 10
    • clang 9

The framework code and example code is compiled warning free on all platforms with the strictest warning settings. A sanitized build is ran on each commit to test for memory corruption and undefined behavior.

Performance is tracked on a per-release basis, with the results for the latest release published here: https://github.com/SanderMertens/ecs_benchmark

API stability

API (programming interface) stability is guaranteed between minor releases, except in the rare case when an API is found to be an obvious source of confusion or bugs. When breaking changes do happen, the release notes will mention it with potential workarounds.

ABI (binary interface) stability is not guaranteed inbetween versions, as non-opaque types and signatures may change at any point in time, as long as they don't break compilation of code that uses the public API. Headers under include/private are not part of the public API, and may introduce breaking changes at any point.

It is generally safe to use the master branch, which contains the latest version of the code. New features that are on master but are not yet part of a release may still see changes in their API. Once a feature is part of a release, its API will not change until at least the next major release.

Modules

The following modules are available in flecs-hub. Note that modules are mostly intended as example code, and their APIs may change at any point in time.

Module Description
flecs.meta Reflection for Flecs components
flecs.json JSON serializer for Flecs components
flecs.rest A REST interface for introspecting & editing entities
flecs.player Play, stop and pause simulations
flecs.monitor Web-based monitoring of statistics
flecs.dash Web-based dashboard for remote monitoring and debugging of Flecs apps
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.components.http Components describing an HTTP server
flecs.systems.transform Hierarchical transforms for scene graphs
flecs.systems.sdl2 SDL window creation & input management
flecs.systems.sokol Sokol-based renderer
flecs.systems.civetweb A civetweb-based implementation of flecs.components.http

Useful Links

Supporting Flecs

Supporting Flecs goes a long way towards keeping the project going and the community alive! If you like the project, consider:

Thanks in advance!

Issues
  • Faster table sorting for queries.

    Faster table sorting for queries.

    This PR implements #731

    Heavily work in progress, the implementation is going to take some time so this PR is for additional discussions and tracking progress.

    I will squash commits later if needed.

    opened by bazhenovc 18
  • Entities do not get deleted when registering OnRemove system

    Entities do not get deleted when registering OnRemove system

    By @teksoc-1:

    When doing some test cases of deleting entities and having OnRemove systems registered with components of the deleted entities, the entities seem to not get deleted, and will see them again next iteration. If I do not register OnRemove systems, the entities get deleted as expected, however, when the OnRemove Systems are applied ( and respectively called as expected ), the entities do not get deleted.

    bug 
    opened by SanderMertens 16
  • Improve cmake quality

    Improve cmake quality

    • added cmake compile options
    • added cmake compile warnings
    • raised cmake version to 3.5
    • rewritten cmake code to be more idiomatic
    • added files manually to improve IDE functionalities
    opened by rawbby 15
  • V2 wishlist (post your requests / ideas!)

    V2 wishlist (post your requests / ideas!)

    Flecs v2 will be released in the near future, and I wanted to do a give everyone an opportunity to share ideas / improvements that they would like to see. V2 is a breaking change, which lets me fix some things I can't do in a minor release.

    The v2 branch: https://github.com/SanderMertens/flecs/tree/v2_in_progress

    Also consider joining Discord where a lot of the discussion is taking place: https://discord.gg/MRSAZqb

    opened by SanderMertens 12
  • Multi Thread Crash

    Multi Thread Crash

    @SanderMertens Can you please confirm this - when applying multi thread execution via ecs_set_threads(), seeing a crash in ecs_schedule_jobs() from a null dereference of 'table' in line 182.

    Note - not using bake, but rather using ecs_os_set_api() per documentation if not using bake; previously this was working with my set up - thinking this may have been recently introduced in one of the recent fixes? Using the same test code as was previously used for creation/deletion of multiple entities.

    bug 
    opened by teksoc-1 12
  • Improve documentation

    Improve documentation

    Topics to cover:

    • Design goals
    • Naming conventions
    • Error handling
    • Memory management
    • Debugging
    • Common patterns
    • Good practices
    • System signatures
    • System stages
    • System ordering
    • Automatic system invocation
    • Manual system invocation
    • Periodic systems
    • Reactive systems
    • Manual systems
    • Tasks
    • System API
    • Modules
    • Shared components
      • Prefab
      • Singleton
      • Container
      • System
    • Builtin components
    • Initializing entities
    • Data structures
    • Internals
    • Staging
    • Threading
    opened by SanderMertens 11
  • An error is reported when compiling CPP example using vs2015

    An error is reported when compiling CPP example using vs2015

    An error is reported when compiling CPP example using vs2015, such as: flecs-2.4.4\include\flecs/cpp/iter.hpp(61): error C2512: “std::is_empty<_Ty>”: No suitable default constructor is available

    bug 
    opened by Zachary9079 10
  • Event Based Systems Design Approach

    Event Based Systems Design Approach

    Describe the problem you are trying to solve. @SanderMertens The while ( ecs_progress() ) construct works well when you continuously are wanting to perform work (i.e. animation/simulation), however in the event that an iteration does not match any systems, subsequent calls to ecs_progress will not (ever) introduce any changes into the environment (unless you introduce a change outside of the ecs_progress() pipeline). Conceptually the goal is to leverage the ecs_progress() pipeline as long as work is being performed (systems matched), and throttle back when systems are no longer matched, yet provide a way for N Event Based Systems to asynchronously fire an event and trigger the ecs_progresss() pipeline again (which may introduce new Event Based Systems).

    Describe the solution you'd like Looking for a solution that will spin ecs_progess() until work is no longer being performed (no systems matched), or ecs_quit() called ... and then perhaps an ecs_wait_for_event() like call that blocks until some Event Based System that is asynchronously running fires an event (new entity for example) and subsequently spins ecs_progress() as long as work is being performed. This of course requires some sort of registration of Event Based Systems that can be run asynchronously outside of the periodic ecs_progress() pipeline.

    enhancement 
    opened by teksoc-1 10
  • Question/Thoughts?: Module Unload - Systems Unregister

    Question/Thoughts?: Module Unload - Systems Unregister

    @SanderMertens In the context of dynamically loading a module, when unloading the module from memory, would like to unregister the associated systems that were previously registered by the respective module. One example use case that this would facilitate, is dynamically 'upgrading' a module ( unloading the old one, and importing the new one ). Understood there is probably some hefty business logic in supporting this, but perhaps a System Unregister like API or leveraging ecs_delete() to take the appropriate actions if the entity is a system? Thoughts?

    enhancement will take a while 
    opened by teksoc-1 10
  • Implement system scheduling parameters

    Implement system scheduling parameters

    Currently when using threads, Flecs splits up the workload of a system into multiple jobs by assigning each job total_matched_entities / thread_count entities. It does this for every system not in EcsOnLoad and EcsOnStore.

    This design is an all-or-nothing approach, and typically an application has systems that can either be ran on N threads or one thread. To let the scheduler know how it should schedule systems, an application should be able to provide scheduling parameters.

    This could be done through an EcsSchedulingParams component, which could look something like this (design not yet finalized):

    ECS_SYSTEM(world, Sys, EcsOnUpdate, Position, 
       SYSTEM.EcsSchedulingParams = {.bind_to_threads = [0, -1]);
    

    In the above example, 0 could refer to the main thread, a non-zero value to a worker thread, and -1 could refer to all worker threads. Additionally, applications could specify whether a system shared threads with other systems, and whether a system wants to run without any other systems running.

    enhancement 
    opened by SanderMertens 9
  • Accessing parent entity during triggers leads to unexpected results.

    Accessing parent entity during triggers leads to unexpected results.

    Describe the bug In my code base, adding a custom relation to an entity leads to a crash reported here with 1 screenshot ( https://discord.com/channels/633826290415435777/689025747909607434/884915189735129100 ) A more simple reproduce of ChildOf corruption that does not crash, but yields incorrect program state is listed below, it does not even involve custom relation.

    To Reproduce

    struct MyStruct {
        int Field;
    };
    void SanityTest(flecs::world &ECS) {    
        ECS.trigger<const MyStruct>().event(flecs::OnRemove).iter([&](iter &Iter){
            for(auto Index : Iter) {
                auto Entity = Iter.entity(Index);
                auto Parent = Entity.get_object(flecs::ChildOf);
                printf("Destroying %s son of %s", Entity.name().c_str(), Parent ? Parent.name().c_str() : "<noone>");
            }
        });
        
        auto Entity = ECS.entity("Entity").add<MyStruct>();
        auto OtherEntity = ECS.entity("OtherEntity");
        ECS.scope(Entity, [&]() {
            auto Child2 = ECS.entity("Child2").add<MyStruct>();
            auto InnerChild = ECS.entity("InnerChild").child_of(Child2).add<MyStruct>();
        });
        
        
        Entity.destruct();
        OtherEntity.destruct();
    }
    

    Expected behavior Destroying InnerChild son of Child2 Destroying Child2 son of Entity Destroying Entity son of

    Actual behavior Destroying InnerChild son of Entity Destroying Child2 son of Entity Destroying Entity son of

    Additional context It repros with both OnAdd and OnRemove, but replacing .child_of with .scope prevents the repro from occurring. My idea is that it has something to do with table transitions when custom relations are involved, but I can't really explain the difference between .child_of and .scope in that case, maybe state is already corrupted before even creating the InnerChild.

    opened by Hexlord 8
  • Retrieve shared pair's object  of a prefab from an instance

    Retrieve shared pair's object of a prefab from an instance

    When adding a pair to a prefab (i.e prefab.add<R, A>()), using get_object<R>() from an instance doesn't return the entity matching A.

    Here is a example :

    #include <iostream>
    #include <flecs.h>
    
    struct R{}; // Relation
    struct A{}; // An object
    
    int main(int, char* [])
    {
        flecs::world ecs;
        auto object     = ecs.component<A>();
        auto prefab     = ecs.prefab().add<R, A>();
        auto instance   = ecs.entity().is_a(prefab);
    
        std::cout << prefab.has<R>(flecs::Wildcard) << "\n"; // true;
        std::cout << (prefab.get_object<R>() == object) << "\n"; // true;
        std::cout << instance.has<R>(flecs::Wildcard) << "\n"; // true;
        std::cout << (instance.get_object<R>() == object) << "\n"; // false; Could this be true ?
        std::cout << (instance.get_object<R>() == 0) << "\n"; // true;
    }
    

    Two solutions :

    1. get_object allows to return the entity
    2. Add the ability to add non-shared pair to prefab, i.e override<R,A>()
    enhancement 
    opened by TBlauwe 0
  • Stack overflow with two acyclic relations in opposite directions

    Stack overflow with two acyclic relations in opposite directions

    I created an acyclic relation, and use is with child of, but in reverse order:

    flecs::world world;
      flecs::entity relation = world.entity("relation").add(flecs::Acyclic);
    
      auto a = world.entity("a");
      auto b = world.entity("b");
      a.child_of(b);
      b.add(relation, a);
    

    this made my code crash with stack overflow Looks like my custom relation interferes with child_of, but I do not understand why

    bug will take a while 
    opened by bbdb68 4
  • std::vector and other STL types are not supported by reflection

    std::vector and other STL types are not supported by reflection

    try to create a Component with an std::vector member

    struct Component
     {
          std::vector<double> data;
     };
    

    registering the meta api works fine, but a runtime you get

    error: flecs.c: 22716: missing EcsMetaType for type std.vector<double,class std::allocator<double> >'
    
    enhancement 
    opened by bbdb68 0
  • Can't build samples on Visual Studio 2015

    Can't build samples on Visual Studio 2015

    The library compiles properly with Visual Studio 2015, but simple samples like examples/cpp/hello_world/src/main.cpp won't compile with vs2015.

    The code:

    #include "flecs.h"
    
    #include "stdafx.h"
    
    // Component types
    struct Position {
        double x;
        double y;
    };
    
    struct Velocity {
        double x;
        double y;
    };
    
    // Tag types
    struct Eats { };
    struct Apples { };
    
    int main(int, char *[]) {
        // Create the world
        flecs::world ecs;
    
        // Register system
        ecs.system<Position, Velocity>()
            .each([](Position& p, Velocity& v) {
            p.x += v.x;
            p.y += v.y;
        });
    
        // Create an entity with name Bob, add Position and food preference
        auto Bob = ecs.entity("Bob")
            .set(Position{ 0, 0 })
            .set(Velocity{ 1, 2 })
            .add<Eats, Apples>();
    
        // Show us what you got
        printf("%s's got: [%s]\n", Bob.name().c_str(), Bob.type().str().c_str());
    
        // Run systems twice. Usually this function is called once per frame
        ecs.progress();
        ecs.progress();
    
        // See if Bob has moved (he has)
        const Position *p = Bob.get<Position>();
        printf("Bob's position is {%f, %f}\n", p->x, p->y);
    }
    

    The compiler errors:

    1>d:\testflecs\testflecs.cpp(38): error C2672: 'flecs::entity_builder<flecs::entity>::add': no matching overloaded function found
    1>d:\testflecs\testflecs.cpp(38): error C2977: 'flecs::entity_builder<flecs::entity>::add': too many template arguments
    1>  d:\devel\vortextoolkit\3rdparty\flecs\x64_win32_vc14\include\flecs\flecs.hpp(1249): note: see declaration of 'flecs::entity_builder<flecs::entity>::add'
    1>d:\testflecs\testflecs.cpp(41): error C3536: 'Bob': cannot be used before it is initialized
    1>d:\testflecs\testflecs.cpp(41): error C2228: left of '.name' must have class/struct/union
    1>  d:\testflecs\testflecs.cpp(41): note: type is 'int'
    1>d:\testflecs\testflecs.cpp(41): error C2228: left of '.c_str' must have class/struct/union
    1>d:\testflecs\testflecs.cpp(41): error C2228: left of '.type' must have class/struct/union
    1>  d:\testflecs\testflecs.cpp(41): note: type is 'int'
    1>d:\testflecs\testflecs.cpp(41): error C2228: left of '.str' must have class/struct/union
    1>d:\testflecs\testflecs.cpp(48): error C2228: left of '.get' must have class/struct/union
    1>  d:\testflecs\testflecs.cpp(48): note: type is 'int'
    1>d:\testflecs\testflecs.cpp(48): error C2059: syntax error: ')'
    1>d:\testflecs\testflecs.cpp(41): warning C4473: 'printf' : not enough arguments passed for format string
    1>  d:\testflecs\testflecs.cpp(41): note: placeholders and their parameters expect 2 variadic arguments, but 0 were provided
    1>  d:\testflecs\testflecs.cpp(41): note: the missing variadic argument 1 is required by format string '%s'
    

    Steps to reproduce the behavior

    1. checkout master
    2. build and install with visual studio 2015
    3. create a new vs2015 project with examples/cpp/hello_world/src/main.cpp file
    4. Compile

    Expected behavior All the samples should compile on visual studio 2015

    Notes

    • Other samples involving queries from v2.4.8 to 2.4.0 won't compile with Visual Studio 2015 (see comment here https://github.com/SanderMertens/flecs/issues/474)
    • The samples compiles properly with vs2019.
    enhancement portability 
    opened by guilms 7
  • Add support for enums with custom integer types

    Add support for enums with custom integer types

    Describe the bug Unsure if this is a bug or a feature request:

    The following snippet compiles and triggers a heap corruption runtime check on MSVC

    enum class ETest : uint8_t
    {
        A, B
    };
    int main()
    {
        
        flecs::world ecs;
    
        ecs.component<ETest>();
        ecs.entity().set<ETest>(1);
        return 0;
    }
    

    Expected behavior I don't think the above should be allowed to compile?

    enhancement will take a while 
    opened by BHolman-LBI 2
Releases(v3.0.2-beta)
  • v3.0.2-beta(Jul 2, 2022)

    This release will be almost functionally equivalent to the initial Flecs v3 release, but is tagged before v3 renaming (see https://github.com/SanderMertens/flecs/discussions/728).

    Use this release if you want to use v3 features, but want to hold off on fixing breaking changes as a result of renaming.

    If you are upgrading from an older (v2) release, see this discussion for a list of breaking changes when upgrading: https://github.com/SanderMertens/flecs/discussions/466

    Source code(tar.gz)
    Source code(zip)
  • v2.4.8(Nov 19, 2021)

    This version includes the following bugfixes:

    • Fix index in query table cache when table is unmatched
    • Fixed group_by signature

    This version includes the following improvements:

    • Add const variants to flecs::ref

    Known issues: https://github.com/SanderMertens/flecs/issues/569 https://github.com/SanderMertens/flecs/issues/701

    Source code(tar.gz)
    Source code(zip)
  • v2.4.7(Sep 18, 2021)

    This version includes the following bugfixes:

    • fixed issue where OnSet system would trigger for the wrong wildcard pair
    • fixed issue where observer would trigger for the wrong wildcard pair
    • fixed issue where observer would trigger for the wrong entity

    Known issues:

    • UnSet systems with wildcards only trigger for one matching component (addressed in v3)

    Note that this is a v2 release that is behind master! Only use this if you cannot migrate to v3 or need API stability

    Source code(tar.gz)
    Source code(zip)
  • v3.0.1-alpha(Aug 27, 2021)

    This is the first v3.0 alpha release. This release gets rid of deprecated features, simplifies the API and code structure, and has a number of internal improvements. For a list of changes, see: https://github.com/SanderMertens/flecs/discussions

    This is the first of a number of v3.0 alpha releases that may have breaking API changes. If you need a stable API, use the last stable 2.4 release: https://github.com/SanderMertens/flecs/releases/tag/v2.4.6

    Known issues:

    • cmake file for examples needs to be updated
    Source code(tar.gz)
    Source code(zip)
  • v2.4.6(Aug 27, 2021)

  • v2.4.5(Aug 27, 2021)

    This version includes the following improvements:

    • Added comment to amalgamated file to remove flecs_STATIC when using as DLL

    This version includes the following bugfixes:

    • Fix issue with moving filters in C++ API
    • Fix issue with creating snapshots from stage
    • Fixed std::is_empty() typo in C++ iterator code
    Source code(tar.gz)
    Source code(zip)
  • v2.4.4(Aug 20, 2021)

    This version includes the following improvements:

    • Added overview diagram to quickstart

    This version includes the following bugfixes:

    • Fix issue with using term() after arg() in filter builder
    • Fix memory leak when registering entity twice for the same alias with ecs_use
    Source code(tar.gz)
    Source code(zip)
  • v2.4.3(Aug 18, 2021)

    This version includes the following improvements:

    • Include tracing level 1 by default in release builds
    • Added function (ecs_tracing_color_enable) to disable colors in tracing

    This version includes the following bugfixes:

    • Fixed issue with queries and large numbers of terms
    • Fixed issue with registering namespaced components with explicit ids (entity::component<T>)
    • Fixed issue with emplace on entities with non-trivial component destructors
    • Fixed issue that prevented enabling tracing in release mode
    Source code(tar.gz)
    Source code(zip)
  • v2.4.2(Aug 16, 2021)

    This version includes the following improvements:

    • Enabled filter builder to create filters with any number of terms

    This version includes the following bugfixes:

    • Fixed issue with creating filters with more than 8 terms
    • Fixed issue with creating filter & term iterators from a stage
    • Fixed issue with using ecs_get_object (and ecs_get_parent) from stage
    Source code(tar.gz)
    Source code(zip)
  • v2.4.1(Aug 15, 2021)

    This version includes the following bugfixes:

    • Fixed issue with resolving shared component entity when entity has more than one base
    • Fixed issue with getting switch case when in staged mode
    Source code(tar.gz)
    Source code(zip)
  • v2.4.0(Aug 13, 2021)

    Finally! 🎉

    The highlights of the release are:

    • The first feature-complete implementation of entity relationships in any ECS framework
    • Removal of dependency on STL data structures, improving compile times & reducing API footprint
    • New sokol-style creation functions in C API for entities, components, queries, systems and more
    • New fluent-style builder classes in C++ for creation of queries, systems and more
    • A new and improved query DSL (domain specific language) with full support for custom relationships
    • Improved features for responding to events with triggers & observers
    • A novel search data structure for archetypes & relations which speeds up things across the board:
      • Filters evaluate much faster, even though they can be much more complex than before
      • Improved speed of matching tables to queries
      • Operations like ecs_get, ecs_has and get_object are now constant time
      • Improved performance of scope iterators
      • Improved performance of fetching components from base entities & instantiating from base entities
      • Improved performance of ecs_lookup family of functions

    Breaking changes: This release introduces a number of minor breaking changes when compared with the last 2.3.2 release. A non-exhaustive lists of breaking changes is provided here and may be extended later:

    • The EcsName component is changed to an EcsIdentifier relation which is instantiated with EcsName and EcsSymbol tags
    • Component destructors are now called on the source component after moving between archetypes
    • The ecs_get_object function no longer accepts a component to find an object for a relation, but an index to find the nth object for a relation
    • The group_by callback signature have been modified to allow for a context
    • The system/query APIs have been updated to a fluent-style builder pattern
    • The C++ API no longer uses STL data structures, which in practice means that code that relied on functions returning an std::string may have to be updated.
    • Most legacy syntax constructs of the query DSL have been removed
    • Removal of CHILDOF and INSTANCEOF roles (use the builtin ChildOf and IsA relations instead)
    • include and exclude filter fields are no longer supported (use new filter API)
    • entity::each(Func&&) now expects a function that accepts a flecs::id instead of a flecs::entity

    This was a large release! A few random facts:

    • Flecs met its first sponsorship goal! ❤️
    • 380 commits since the last release
    • Over 2200 commits since the beginning of the project
    • The Discord server grew to almost 600 users 🎉
    • Close to 400 new stars were added to the project ⭐
    • A little more than a year has passed since the first v2.0 release
    • Almost a 100 closed PRs and issues in this release alone:
      • PRs contributed by @randy408, @aganm, @mason-bially, @ikrima, @SpaceIm, @Hexlord, @shanehyde, @Zalron, @nasso and @Wesxdz
      • Issues opened by @SpaceIm, @JonSnowbd, @randy408, @artgreen, @mjjq, @Hexlord, @codylico, @BHolman-LBI, @jtferson, @shanehyde, @cshenton, @Josid88, @jon-turney, @Jarodwr, @HenryFalconerIO, @tedajax, @Zalron, @domdom, @KenthJohan and @zaklaus
      • Thanks everyone! 🙏

    I'm skipping the full list of features/improvements/bugs for now as it's a lot, may add it later.

    For the next 2 - 3 months the master branch will be used to migrate to the v3 APIs. If you need API stability, stay on the last v2 release until the official v3 release. There will be intermediate releases that allow for a more gradual upgrade path to the new v3 APIs.

    Source code(tar.gz)
    Source code(zip)
  • v2.3.2(Feb 23, 2021)

    This release introduces a breaking change to fix C++ component registration. The symbol member of the EcsName (or flecs::Name) component now requires an allocation. If you explicitly assign members to the EcsName component (using get_mut, not using set) you will have to update your code.

    Another change that was introduced to fix component registration is that the symbol member of the EcsName component for a module now always contains the fully qualified path to the entity. Previously this value contained the C or C++ typename, but this caused issues with module interop between C and C++. If your code relied on looking up modules by their C typename and not the fully qualified name, code will have to be updated.

    This release contains the following improvements:

    • replace iostream with initializer_list (C++ API, thanks @ikrima!)
    • ensure entity::m_id is initialized to 0 (C++ API, thanks @ikrima!)
    • use ecs_os_malloc instead of new (C++ API, thanks @ikrima!)
    • remove superfluous copies of lambda functions (C++ API, thanks @ikrima!)
    • add CHANGELOG (thanks @ikrima!)

    This release contains the following bugfixes:

    • fix matching for queries with shared componnents when base entity is deleted
    • fix various issues with component registration in C++
    • fix issue with setting target FPS on Apple M1 (thanks @prime31!)
    • fix issues with CMake file (thanks @SpaceIm!)
    • fix crash when creating & deleting queries
    • guarantee that id returned by new_component_id is unused
    Source code(tar.gz)
    Source code(zip)
  • v2.3.1(Feb 3, 2021)

    This version contains the following improvements:

    • Improved lerp example
    • Added OS API example C++ (thanks @mcmlevi!)
    • Upgraded cmake buildfiles (thanks @rawbby!)
    • Clarified text in README describing API/ABI stability

    This version contains the following bugfixes:

    • Fix crash when using overlapping UnSet systems
    • Fix issue with passing incorrect row to UnSet systems
    • Added .hpp files to cmake install
    • Fixed issue with using get_mut with traits
    Source code(tar.gz)
    Source code(zip)
  • v2.3.0(Jan 18, 2021)

    Highlights:

    • Big performance improvements & reduced memory usage for applications with lots of tables, such as when using hierarchies
    • Component enabling/disabling allows for quick component mutations without moving entities between archetypes
    • New statistics addon for retrieving metrics from running world (replaces stats module)

    Thanks to @randy408, @sh-dave, @kevinresol, @jasonliang-dev and @Alexandre-P-J for submitting PRs! 🎉

    Thanks to @ikrima and @jtferson for writing two awesome testimonials on using Flecs with Unreal Engine 4 🙏 :

    • https://bebylon.dev/blog/ecs-flecs-ue4/
    • https://jtferson.github.io/blog/flecs_and_unreal/

    Thanks to the new Flecs sponsors ❤️ :

    • @Zifkan
    • @TFlippy
    • @Hexlord

    Breaking changes:

    • calling ecs_get for a tag will no longer return NULL, but will assert
    • statistics module is removed in favor of easier to use statistics addon
    • unused table_offset member is removed from iterator

    Deprecated features:

    • ecs_entity() macro is now deprecated, use ecs_typeid()

    This version includes the following features:

    • Direct access addon, which provides fast access to underlying storage
    • Added singleton API to C++ world class
    • Added orphaning for subqueries, which allows an application to check if a parent query still exists
    • Added ecs_get_typeid function to get the component id for traits
    • The type used for time keeping is now customizable
    • New statistics addon for retrieving metrics from running world
    • Added get_parent function that accepts entity/tag
    • Added component enabling/disabling
    • Added support for sorting on shared components

    This version includes the following improvements:

    • Improved ecs_delete performance (reduced entity index accesses from 2 to 1)
    • C & C++ code compiles warning-free with more warning flags, for more compiler versions & more platforms
    • Improved error messages when application passes invalid entity id
    • Made include paths relative so source code is easier to integrate with bazel
    • Fixed typos in documentation
    • Improve error message when trying to add 0 as base entity (using ECS_INSTANCEOF)
    • Add check for conflicting source modifier in OR expressions
    • Extended documentation, added new examples and fixed typos
    • Removed dead/redundant code
    • Improved performance of ecs_get
    • Add sanitizer & custom builds to CI, remove Travis CI builds
    • Don't add Name component when provided name for entity is NULL
    • Allow flecs::system instances to be (re)created from entity id
    • Added godbolt "try online" badge to README
    • Improve allocation strategy of vector datastructure
    • Improved performance for checking if entity id is a number
    • Added missing query functions to C++ API for sorting
    • Improved performance of table creation by two orders of magnitude
    • Reduced memory footprint of table graph by a factor 60
    • Added example to demonstrate world merging with direct access API
    • Added more inline documentation for datastructures
    • Added assert when trying to instantiate child as instance
    • Improve errors when invalid operation is invoked on iterator
    • Throw assert when invoking ecs_modified on entity that does not have the component
    • Allow for type lookups in systems, as long as the type already exists
    • Add return types to ecs_defer_begin and ecs_defer_end to obtain defer status of world
    • Remove redundant table_offset member from ecs_iter_t
    • Improved portability of POSIX OS API example

    This version includes the following bugfixes:

    • Fixed issues with subqueries and query rematching
    • Corrected wrong return type of ecs_column_size (was ecs_entity_t, is now size_t)
    • Add missing \0 when appending to application buffer with strbuf datastructure
    • Fixed crash when instantiating an empty prefab
    • Fixed issue with shared tags and queries using each() in the C++ API
    • Fixed issue with instantiating empty child table
    • Fixed issue with ecs_bulk_new and traits
    • Fixed issue when using ecs_entity_str with small buffers
    • Fixed bug when adding trait to entity with switch
    • Fixed name conflicts in amalgamated source
    • Fixed path lookup in ecs_import
    • Fixed EXPORT macro's in OS API examples
    • Fixed issue with restoring worlds that have recycled ids
    • Added missing EXPORT macro's to API functions
    • Fixed assert after deleting entities from restored world
    • Removed obsolete assert from ecs_modified
    • Added missing statement to finalize system in C++
    • Fixed issues with removing case values
    • Fixed issues in C++ API with implicit component registration
    • Fixed assert when removing from switch list
    • Fixed bug where obtaining type from entity would generate a new entity id
    • Fixed incorrect description of ecs_delete in manual
    • Fixed issues with custom builds
    Source code(tar.gz)
    Source code(zip)
  • v2.2.0(Oct 12, 2020)

    Highlights:

    • Big performance improvement for operations called from systems
    • Entity liveliness tracking (entities are now annotated with a generation)
    • New APIs for deferring operations, singletons and simpler system callbacks (C++)

    Deprecated features:

    • The action method in C++ should no longer be used for systems. Use iter instead.
    • EcsSingleton and flecs::Singleton are deprecated. Use new singleton API instead
    • The is_shared function in the flecs::iter class is deprecated. Use is_owned instead.

    Breaking changes

    • Query columns that are not owned are now [in] by default. This may cause the API to throw an assert (in C++) or ecs_is_readonly to return a different value (in C). To fix issues caused by this change, add const to the column type, or annotate the column with [inout] or [out].
    • Doing an operation on a deleted entity id may now throw an assert.

    Thanks to @ikrima, @randy408 and @nbrk for submitting PRs! 🎉

    This version includes the following features:

    • Add ecs_clear API which removes all components without deleting the entity
    • Keep track of entity lifecycle with generation counting
    • New type role that enables automatic overriding of components for base/prefab entities
    • Create an alias for entity/component names to shorten string-based queries
    • New API for deferring actions
    • New staging implementation that uses deferred actions for better performance
    • Added ecs_is_alive which tests if an entity has been deleted
    • Added ecs_exists which tests if an entity id is currently in use (ignoring generation)
    • Add new singleton API
    • Add macro's for defining global component variables in C

    This version includes the following improvements:

    • Recursively delete child entities when deleting a parent
    • Add function to enable tracing to C++
    • Add time_scale function to C++
    • Disallow overwriting component lifecycle actions
    • Improved checks for invoking operations on non-initialized classes
    • Improvements to C++ flecs::vector wrapper
    • Introduces iter() which is an easier to use alternative to action()
    • Added simplified FOR syntax for trait queries
    • Add is_owned to iterator class in C++
    • Treat empty structs in C++ as tags
    • Allow dereferencing shared column with [0] in C++
    • Add enabled() function to entity class
    • Queries now prefetch column types so there is no accidental table creation when iterating
    • Make [in] default for columns that are not owned
    • Add function to get column by name
    • Detect registering component with a different name in C++

    This version includes the following bugfixes:

    • Fix issues when application includes stdbool
    • Don't crash if system is redefined with NULL signature
    • Fix issues with registering builtin components in C++
    • Fix issues with re-registering entities with the same name
    • Fix bug where child would sometimes be created for the wrong parent
    • Add missing ANY modifier to C examples
    • Fixed issue with registering components across translation units
    • Add assert when ecs_merge is called when world is progressing
    • Fixed issue where moving world could cause double destruction in C++
    • entity::set no longer takes const rvalue which prevented moves
    • Fixed bug where moving an entity would sometimes call destruct on the wrong component
    • Don't automatically add ctor if other lifecycle actions are NULL
    • ecs_os_api_strdup incorrectly used ecs_os_api_malloc instead of overrided malloc
    • Only resolve entity as numeric id if the entire string is a number
    • Fix including alloca header in FreeBSD
    • Fixed incorrect parsing of trait expression with SHARED modifier in signature
    • Fixed bug with obtaining shared trait columns
    • Fixed bug with querying for component trait
    • Ensure that owned component is never passed to shared column and vice versa
    • Fixed bug with rematching queries that have optional fields
    • If a prefab was an instance from a base prefab, the children of the base would not be created as prefabs
    • Deleting a table in the table graph did not update edges of connected tables
    • Queries were sometimes registered twice with the same table
    • Fixed crash when attempting to delete empty child table
    • Remove query from table administration when unmatching
    • Parent entity was not deleted from child tables administration when deleted
    • Removed assert when attempting to remove a key from an empty map
    • Fix bug where is_monitored bit would not be transferred when moving / swapping an entity
    • Fixed component names memory leak in C++ API
    Source code(tar.gz)
    Source code(zip)
  • v2.1.2(Sep 5, 2020)

    This version includes the following features:

    • No new features

    This version includes the following improvements:

    • Queries can now select for components to which a trait has been applied (TRAIT | MyTrait > *)
    • Add unsafe_column to C++ API for accessing component data of unknown type at compile time
    • Add [] operator to flecs::vector
    • Add more functions to C++ iterator to access underlying fields
    • Add fast paths to table functions (improves performance)
    • Add support for global component/tag/entity handles in C
    • Add flecs::type_id<T>() for getting the identifier of a type

    This version includes the following bugfixes:

    • OnSet systems registered themselves with components in expression vs. matched components
    • Fix issues related to component lifecycle actions & traits
    • Invoke move when moving entity between tables
    • Invoke move when reallocating table columns
    • Invoke move when deleting an entity (move last entity into deleted index)
    • Component actions were not registered for implicitly registered components
    • Fix bug with redefining namespaced components in a different world
    Source code(tar.gz)
    Source code(zip)
  • v2.1.1(Sep 1, 2020)

  • v2.1.0(Aug 31, 2020)

    Highlights:

    • Big usability improvements to the C++ API
    • Improved performance when compared to 2.0 (~18%)
    • Switchable tags which allow for easy implementation of state machines
    • Subqueries

    Breaking changes This release introduces a breaking change to the ecs_bulk_new* APIs which was necessary to fix a memory leak. The new API now returns a pointer to an array of entity ids, vs. the entity id of the first created entity.

    This version includes the following features:

    • Implicit component registration in C++ API
    • Switchable tags (allows for building fast state machines)
    • Subqueries (queries that are matched against the tables of their parent queries)

    This version includes the following improvements:

    • Add type agnostic get/get_mut/modified/has functions to C++ API
    • Add trait functions to C++ API
    • Allow for specifying the signature in the flesc::query constructor
    • Increased addressing space for type roles
    • Add convenience functions to flecs::entity class for working with roles
    • Allow querying for individual traits
    • Add has_childof and has_instanceof to C++ API
    • Moved private classes in C++ API to separate namespace
    • Removed all bake code from flecs core
    • Added OS API examples
    • Added support for triggers to C++ API
    • Moved change tracking from systems to queries
    • Add ecs_query_next_w_filter
    • Added a FAQ (https://github.com/SanderMertens/flecs/blob/master/docs/FAQ.md)
    • New sparse set implementation
    • Add fast path to table operations, improving performance
    • Fixed name clashes with other libraries in OS API struct
    • Added more sections and diagram to the manual
    • Added support for AND & OR type flags in signatures
    • Improved exporting types from a module
    • Improved C++ API where world can be used as factory

    This version includes the following bugfixes:

    • Fixed issue with get_mut in C++ API
    • Fixed issue with correctly registering components when using pointer types in queries
    • Fixed issue where a cached pointer in a reference could become invalid
    • Fixed uninitialized value in query sorting function
    • Fixed issue where record_ptrs array would not be allocated with correct size in writer API
    • Fixed uninitialized value during cleanup
    • Fixed numerous memory leaks
    • Fixed duplicate entries in stage
    • Fixed issue where query would not detect a change in the data
    • Fixed issue with optional components in C++ API
    • Fixed C++ snapshot examples
    • Fix issue where system name would not be copied in C++ API
    • Fixed namespacing issue with nested modules in C++
    • Fix issue with ECS_ALIGN macro and signed integers
    • Fix issue with registering components across multiple worlds in C++
    • Fixed issue where repeated bulk operation could cause out of memory errors
    Source code(tar.gz)
    Source code(zip)
  • v2.0.0(Aug 3, 2020)

    This is the first Flecs v2.0 release. This release contains many new features, performance improvements and bug fixes. For a full overview of the changes, see the migration guide: https://github.com/SanderMertens/flecs/blob/master/docs/MigrationGuide.md

    To get up to speed on the v2.0 features, see the quickstart: https://github.com/SanderMertens/flecs/blob/master/docs/Quickstart.md

    For a more in-depth description of the features, see the manual: https://github.com/SanderMertens/flecs/blob/master/docs/Manual.md

    Source code(tar.gz)
    Source code(zip)
  • v2.0.4-beta(Jun 25, 2020)

    This is a pre-release of v2.0. Do not use this release for production code. Bugs are to be expected. The purpose of this release is to help existing users migrate from v1.0 to v2.0.

    This is a beta release, indicating that the public API for v2.0 is stable, unless indicated otherwise. Any headers under include/flecs/private are not part of the public API, and may be changed by patch & minor releases. Behavior changes may still occur as bugs are fixed and features are completed.

    This release has the following new features:

    • Add ability to iterate scope with filter
    • Add ecs_get_child_count function
    • Allow for creating filtered snapshots & blobs by providing an iterator
    • Add ecs_set_time_scale function

    This release implements the following improvements:

    • Allow parsing type expressions without asserting on error
    • Rename query sorting functions to sort_by and group_by
    • Improve test coverage
    • Remove inconsistencies in signatures between os API malloc, calloc and alloca
    • Remove variable masking warnings
    • Cleanup unused system declarations
    • Reorganize headers and source files to make it clearer which parts of the code are required, optional and part of the public API
    • improve file organization
    • fix cmake build

    This release addresses the following issues:

    • Fix issue that could cause crash in map implementation
    • Fix issue where OnSet system could trigger on columns that are not owned
    • Remove references to UT_ macro's from bake.util
    • Replace TRUE and FALSE with true and false
    • Fix issue where new_from_path would add CHILDOF | 0 for entity in root

    For a list of changes between v1 and v2 see the migration guide

    Known issues:

    • OnSet systems are not invoked for tables created while staged
    • OnSet systems are not invoked when an overridden component is removed
    Source code(tar.gz)
    Source code(zip)
  • 2.0.3-alpha(Jun 17, 2020)

    This is a pre-release of v2.0. Do not use this release for production code. Bugs are to be expected. The purpose of this release is to help existing users migrate from v1.0 to v2.0.

    This code has not been as rigorously tested as a normal release, and documentation is not up to date.

    This release addresses the following issues, amongst others:

    • Implement namespacing
    • Split core up into separate modules and utilities
    • Add header documentation
    • Fix issue with ecs_deactivate_systems
    • Fix issues with multithreading

    For a list of changes between v1 and v2 see the migration guide

    For a list of changes between v1 and v2 see the migration guide

    Known issues:

    • OnSet systems are not invoked for tables created while staged
    • OnSet systems are not invoked when an overridden component is removed
    Source code(tar.gz)
    Source code(zip)
  • v1.3(Jun 23, 2020)

    This is the last v1 release. New applications should start with Flecs v2.

    This version includes the following features:

    • Port several functions from C to C++ API
    • Add overloads for world::add & world::remove
    • Add function to count inactive systems

    This version includes the following improvements:

    • Add periodic system example for C API
    • Enforce that 'action' is last method called when constructing system in C++
    • Enable staging when invoking ecs_run
    • Store table_count in ecs_rows_t
    • Added task examples
    • Added target_include_directories to cmake file

    This version includes the following bugfixes:

    • Fix duplicate type definitions
    • Fix bug where column count of 0 caused out of memory
    • Fix sources list for meson build file
    • Fix mismatching return types for get/set_target_fps
    • Fix alignment issue with ecs_vector_t
    • Fix bug with passing CONTAINER column into reactive system
    • Remove invalid assert from ecs_import_from_library
    • Fix issue with using OWNED / SHARED in a reactive system
    • Fix issue where a disabled system could become enabled again
    • Fix dangling pointer to world in entity::type()
    • Fix issue where merge could happen twice
    • Don't merge manual system when auto_merge is false
    • Fix crash when deleting parent
    • Fix issue where ecs_run would use filter where it shouldn't
    Source code(tar.gz)
    Source code(zip)
  • v1.2(Jan 6, 2020)

    This version includes the following features:

    • A C++11 API (#115)
    • Snapshots (#7)
    • Blob serialization & deserialization (#114)
    • On demand systems (#82)
    • System on enable/activate callbacks (#83)
    • Filter-based iteration over entities (#117)
    • An introspection API for improved debugging . (#100)
    • A new statistics module (replaces old stats API, #88)
    • A command-line debug console (https://github.com/flecs-hub/flecs-systems-console)
    • A new prometheus module for server-side monitoring (https://github.com/flecs-hub/flecs-systems-prometheus)

    This version includes the following improvements:

    • Improved error messages when system signature parsing fails (#90)
    • Many new examples (#55)
    • Cleanup of flecs header, moved supporting functions to api_support.h (#116)
    • Work with older versions of CMake (#87)

    This version includes the following bugfixes:

    • Fix issue with using singleton as parent entity (#81)
    • Fix issue where manual systems are not correctly activated (#86)
    • Fix issue with NOT operator in combination with FromEntity columns (#89)
    • Fixed memory leak in ecs_chunked_t datastructure (#95)
    • Fix issue where ECS_MODULE would take address of temporary variable (#98)
    • Fix issue when get_parent is called while iterating (#97)
    • Fix leak in on demand administration (#104)
    • Fix leaking system signatures (#103)
    • Add strdup to OS API, remove uses of strdup in code (#106)
    • World time now starts counting when application starts vs. 0

    This version adds the following functions:

    • ecs_add_entity
    • ecs_remove_entity
    • ecs_has_entity_owned
    • ecs_count_w_filter
    • ecs_is_readonly
    • ecs_table_type
    • ecs_table_column
    • ecs_filter_iter
    • ecs_snapshot_filter_iter
    • ecs_filter_next
    • ecs_set_system_status_action
    • ecs_snapshot_take
    • ecs_snapshot_restore
    • ecs_snapshot_copy
    • ecs_snapshot_free
    • ecs_reader_init
    • ecs_snapshot_reader_init
    • ecs_reader_read
    • ecs_writer_init
    • ecs_writer_write
    • ecs_type_remove
    • ecs_type_match_w_filter
    • ecs_type_index_of
    • ecs_enable_console
    Source code(tar.gz)
    Source code(zip)
  • v1.1(Oct 7, 2019)

    This version includes the following features:

    • Add API for bulk insertion of data (#60)
    • Add API for bulk deletion (#33)
    • Add API for bulk add/remove (#67)

    This version includes the following improvements:

    • Allow for direct access to table columns in systems (#59)
    • Remove compiler warnings in strict mode (#70)
    • Make EcsOnLoad phase unstaged, allowing for faster insertion of data (#74)
    • Add optional example, improve documentation

    This version includes the following bugfixes:

    • Fix crash when calling ecs_quit from worker thread (#61)
    • Fix crash when calling ecs_new_w_count from worker thread (#61)
    • Fix crash when dimensioning table with columns that have size 0 (#60)
    • Fix bug where on some platforms the OS API struct was stored in RO memory, causing a crash (#68)
    • Fix bug when _ecs_field is called with a 0 size (#75)
    • Fix bug when creating a system that only has an OWNED or SHARED column (#78)
    Source code(tar.gz)
    Source code(zip)
  • v1.0(Aug 25, 2019)

    The first official Flecs release!

    This version includes the following features:

    • A super fast archetypes-based ECS implementation in C99
    • Expressive system queries with support for many operators and ways to subscribe for data
    • Group systems with Flecs features
    • Component sharing (see: inheritance)
    • A web-based dashboard (see: flecs-systems-admin)
    • Hierarchies [BETA] (see: hierarchies)
    • Multithreading [BETA]
    • ... and much, much more! See the manual for more details.
    Source code(tar.gz)
    Source code(zip)
Owner
Sander Mertens
Sander Mertens
Fast C++ implementation with JSI binding of MD5 for React Native

react-native-quick-md5 Brazingly fast C++ implementation with JSI binding of MD5 for React Native. Confirmed that it's 10x faster than using spark-md5

Takuya Matsuyama 73 Jun 13, 2022
This is a fast module to probing an area in a 2d plane for physic objects

Godot AreaProber 2D Checking for neighbour colliders made easy AreaProber allows you to probe for colliders anywhere in your 2D game's world, no need

Strauji 8 Feb 14, 2022
A C++ implementation of Fast Simulation of Mass-Spring Systems

Fast Mass-Spring System Simulator A C++ implementation of Fast Simulation of Mass-Spring Systems [1], rendered with OpenGL. The dynamic inverse proced

Samer Itani 146 Jun 22, 2022
RGL - 3D visualization device system for R using OpenGL

RGL - 3D visualization device system for R using OpenGL INTRODUCTION The RGL package is a visualization device system for R, using OpenGL or WebGL as

null 58 Jun 20, 2022
3D Solar System Scene

This was my Computer Graphics' project. In this i used OpenGL and Glut to create a 3D Solar System Scene. Its without textures and wrapping. Just the most basic functionalities.

Hassan Shahzad 7 Jun 20, 2022
runcat system tray on Linux (using libappindicator)

runcat-tray Is a runcat port for Linux using libappindicator

Yongsheng Xu 17 Jun 2, 2022
Implementation of light baking system for ray tracing based on Activision's UberBake

Vulkan Light Bakery MSU Graphics Group Student's Diploma Project Treefonov Andrey [GitHub] [LinkedIn] EARLY STAGES OF DEVELOPMENT Project Goal The goa

Andrei Treefonov 5 May 24, 2022
A modern, feature-rich single header C++ interface system for GLFW

A modern, feature-rich single header C++ interface system for GLFW

Vortex 3 Dec 27, 2021
Simple console tool to get all the information from DXGI and Direct3D 12 on current system

D3d12info Simple console tool to get all the information from DXGI and Direct3D 12 (D3D12) on current system. Built and tested on Windows 10 64-bit us

Adam Sawicki 23 Jun 27, 2022
A fast entity component system (ECS) for C & C++

Flecs is a fast and lightweight Entity Component System with a focus on high performance game development (join the Discord!). Highlights of the frame

Sander Mertens 2.8k Jun 28, 2022
A fast entity component system (ECS) for C & C++

Flecs is a fast and lightweight Entity Component System with a focus on high performance game development (join the Discord!). Highlights of the frame

Sander Mertens 2.8k Jul 4, 2022
Gaming meets modern C++ - a fast and reliable entity component system (ECS) and much more

EnTT is a header-only, tiny and easy to use library for game programming and much more written in modern C++. Among others, it's used in Minecraft by

Michele Caini 6.9k Jun 24, 2022
Gaming meets modern C++ - a fast and reliable entity-component system (ECS) and much more

EnTT is a header-only, tiny and easy to use entity-component system (and much more) written in modern C++. Among others, it's also used in Minecraft by Mojang and The Forge by Confetti.

Sean Middleditch 8 Feb 16, 2021
Simple tower defense game using C++ with Entity Component System (ECS)

CubbyTower CubbyTower is a simple tower defense game using C++ with Entity Component System (ECS). The code is built on C++17 and can be compiled with

Chris Ohk 33 Jun 26, 2022
Entity-Component-System (ECS) with a focus on ease-of-use, runtime extensibility and compile-time type safety and clarity.

Kengine The Koala engine is a type-safe and self-documenting implementation of an Entity-Component-System (ECS), with a focus on runtime extensibility

Nicolas Phister 453 Jul 2, 2022
EntityX - A fast, type-safe C++ Entity-Component system

EntityX - A fast, type-safe C++ Entity Component System NOTE: The current stable release 1.0.0 breaks backward compatibility with < 1.0.0. See the cha

Alec Thomas 2k Jun 23, 2022
apecs: A Petite Entity Component System

apecs: A Petite Entity Component System A header-only, very small entity component system with no external dependencies.

Matt Cummins 17 Jun 1, 2022
Small implementation of c++ entity component system inspired by Unity

EntityComponentSystem About This is small implementation of entity component system with C++. The API is heavily inspired by Unity ECS framework, but

Lukas Chodosevičius 2 Oct 13, 2021
A C++14 Entity Component System

NOTICE: This project is currently in the progress of being rewritten for C++17. Check out this issue if you have any suggestions/know a good way to tr

Elnar Dakeshov 185 Jun 8, 2022
[WIP] Experimental C++14 multithreaded compile-time entity-component-system library.

ecst Experimental & work-in-progress C++14 multithreaded compile-time Entity-Component-System header-only library. Overview Successful development of

Vittorio Romeo 443 Jun 16, 2022
C++ single-header entity component system library

ECS This is a simple C++ header-only type-safe entity component system library. It makes heavy use of C++11 constructs, so make sure you have an up to

Sam Bloomberg 395 Jun 16, 2022
C++ entity-component system

CORGI Version 1.0.2 {#corgi_readme} CORGI is a C++ entity-component system library developed primarily for games that focus on simplicity and flexibil

Google 250 Jun 18, 2022
Thoughts about entity-component-system

About Warning: This is not a complete production-ready library for entity-component-system. This is only my thoughts about how the modern entity-compo

Sergey Makeev 177 Jun 6, 2022
The InitWare Suite of Middleware allows you to manage services and system resources as logical entities called units. Its main component is a service management ("init") system.

InitWare isn't ready to use yet!! Unless you are doing so for fun, to experiment, or to contribute, you most likely do not want to try to install Init

null 151 Jun 15, 2022
An open source C++ entity system.

anax ARCHIVED: as I haven't maintained this library for at least a couple of years. I don't have the time or interest to work on this. Please use anot

Miguel Martin 455 Jun 7, 2022
An open source C++ entity system.

anax ARCHIVED: as I haven't maintained this library for at least a couple of years. I don't have the time or interest to work on this. Please use anot

Miguel Martin 456 Jun 29, 2022
Yet another component system

Yet another component system Header-only c++11 entity component system Depends on Parallel hashmap for fast pointer container Compile time type name a

Devil Devilson 11 Jul 14, 2021
Godex is a Godot Engine ECS library.

Godex Godex is a Godot Engine ecs library. Disclaimer: this module is still in development, open an issues to report any problem or a new discussion i

GodotECS 652 Jun 28, 2022