microecs 0.1.0__tar.gz

microecs-0.1.0/LICENSE.TXT

@@ -0,0 +1,7 @@
+Copyright 2026 Meehai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

microecs-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: microecs
+Version: 0.1.0
+Summary: MicroECS: Minimal Entity Component System (ECS) in python and numpy
+Home-page: https://gitlab.com/meehai/microecs
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.TXT
+Requires-Dist: numpy>=2.2.0
+Requires-Dist: loggez>=0.8
+
+# MicroECS
+
+Minimal (<200 LoC) Entity Component System in python and numpy. Examples also use raylib for rendering.
+
+Usage:
+
+- `pip install -r requirements.txt`
+- Sandbox: `python main.py`
+- Tests: `pytest test/`
+
+There are only four primitives (bottom up): `Component`,`Pool`, `World` and `System`.
+
+- `Component` is a simple python dataclass holding only data. All entries must be numpy arrays with metadata fields: shape and dtype. We support 4 dtypes only: `int32`, `float32`, `str` and `bool`.
+- `Pool` is a simple 'archetype' dynamic array, holding entities of the same type (same set of components). Usses `Components` metadata to construct contiguous arrays for all entities of the same type.
+- `World` is a manager of `Pools` and has an overview of all the entities in the scene. It also manages the migration of entities from one pool to the other.
+- `System` is an abstract class that queries the `World` for a subset of `Pools` matching some components. It updates the entities in these pools given some logic (e.g. collisions, motion physics or simply calls the drawing functions).
+
+Few relevant concepts:
+
+- `Pool` operates on array indices, while `World` operates on entity IDs (also integers). This allows seamless movement between pools while the high-level systems still working as intended.
+- All mutable operations on `World` are lazy. These are: `add_entity`, `remove_entity`, `add_component`, `remove_component`. They are added to a command buffer which is only executed when calling `world.update()`.
+
+Super simplified main loop structure:
+
+```python
+import numpy as np
+import raylib as rl
+from microecs import World, Component, TickSystem
+
+# components
+class HasPosition(Component):
+    position: np.ndarray = field(metadata={"shape": (2, ), "dtype": "float32"})
+class HasColor(Component):
+    color: np.ndarray = field(metadata={"shape": (4, ), "dtype": "int32"})
+
+# systems
+class RenderSystem(TickSystem):
+    def on_tick(self, world: World): # must override
+        for pool in world.query_and((HasPosition, HasColor)): # get all pools of entities having both
+            for position, radius, color in zip(pool.position, pool.color): # for each entity in this pool
+                DrawEntity(position, color)
+class CollisionSystem(TickSystem)
+    def on_tick(self, world: World): # must override
+        ...
+
+def main():
+    render_system = RenderSystem()
+    update_systems: list[TickSystem] = [CollisionSystem()]
+
+    world = World(components=[HasPosition, HasColor])
+    for _ in range(n_objects):
+        # NOTE: world.{add/remove}_{entity/component} are lazy. They take effect after the first world.update() call.
+        world.add_entity(components=(HasPosition, HasColor), # tuple of components (types)
+                         position=np.array((x, y), "float32"), # data as kwargs
+                         color=np.array("black", dtype="int32"))
+
+    while not rl.WindowShouldClose():
+        world.update() # must be called at each tick so the lazy methods are processed and entities are updated
+        # update stuff...
+        _ = [system.on_tick(world=world) for system in update_systems]
+        # draw stuff, e.g. using raylib
+        rl.BeginDrawing()
+        rl.ClearBackground(rl.RAYWHITE)
+        rl.DrawFPS(rl.GetScreenWidth() - 100, 0)
+        render_system.on_tick(world=world)
+        rl.EndDrawing()
+```

microecs-0.1.0/README.md

@@ -0,0 +1,67 @@
+# MicroECS
+
+Minimal (<200 LoC) Entity Component System in python and numpy. Examples also use raylib for rendering.
+
+Usage:
+
+- `pip install -r requirements.txt`
+- Sandbox: `python main.py`
+- Tests: `pytest test/`
+
+There are only four primitives (bottom up): `Component`,`Pool`, `World` and `System`.
+
+- `Component` is a simple python dataclass holding only data. All entries must be numpy arrays with metadata fields: shape and dtype. We support 4 dtypes only: `int32`, `float32`, `str` and `bool`.
+- `Pool` is a simple 'archetype' dynamic array, holding entities of the same type (same set of components). Usses `Components` metadata to construct contiguous arrays for all entities of the same type.
+- `World` is a manager of `Pools` and has an overview of all the entities in the scene. It also manages the migration of entities from one pool to the other.
+- `System` is an abstract class that queries the `World` for a subset of `Pools` matching some components. It updates the entities in these pools given some logic (e.g. collisions, motion physics or simply calls the drawing functions).
+
+Few relevant concepts:
+
+- `Pool` operates on array indices, while `World` operates on entity IDs (also integers). This allows seamless movement between pools while the high-level systems still working as intended.
+- All mutable operations on `World` are lazy. These are: `add_entity`, `remove_entity`, `add_component`, `remove_component`. They are added to a command buffer which is only executed when calling `world.update()`.
+
+Super simplified main loop structure:
+
+```python
+import numpy as np
+import raylib as rl
+from microecs import World, Component, TickSystem
+
+# components
+class HasPosition(Component):
+    position: np.ndarray = field(metadata={"shape": (2, ), "dtype": "float32"})
+class HasColor(Component):
+    color: np.ndarray = field(metadata={"shape": (4, ), "dtype": "int32"})
+
+# systems
+class RenderSystem(TickSystem):
+    def on_tick(self, world: World): # must override
+        for pool in world.query_and((HasPosition, HasColor)): # get all pools of entities having both
+            for position, radius, color in zip(pool.position, pool.color): # for each entity in this pool
+                DrawEntity(position, color)
+class CollisionSystem(TickSystem)
+    def on_tick(self, world: World): # must override
+        ...
+
+def main():
+    render_system = RenderSystem()
+    update_systems: list[TickSystem] = [CollisionSystem()]
+
+    world = World(components=[HasPosition, HasColor])
+    for _ in range(n_objects):
+        # NOTE: world.{add/remove}_{entity/component} are lazy. They take effect after the first world.update() call.
+        world.add_entity(components=(HasPosition, HasColor), # tuple of components (types)
+                         position=np.array((x, y), "float32"), # data as kwargs
+                         color=np.array("black", dtype="int32"))
+
+    while not rl.WindowShouldClose():
+        world.update() # must be called at each tick so the lazy methods are processed and entities are updated
+        # update stuff...
+        _ = [system.on_tick(world=world) for system in update_systems]
+        # draw stuff, e.g. using raylib
+        rl.BeginDrawing()
+        rl.ClearBackground(rl.RAYWHITE)
+        rl.DrawFPS(rl.GetScreenWidth() - 100, 0)
+        render_system.on_tick(world=world)
+        rl.EndDrawing()
+```

microecs-0.1.0/microecs/__init__.py

@@ -0,0 +1,8 @@
+"""init file"""
+
+from .pool import Pool
+from .world import World
+from .system import TickSystem
+from .component import Component
+
+__all__ = ["Pool", "World", "TickSystem", "Component"]

microecs-0.1.0/microecs/component.py

@@ -0,0 +1,8 @@
+"""component.py - submodule holind the base class for all components, which is just a dataclass wrapper"""
+from dataclasses import dataclass
+
+class Component:
+    """Base for ECS components: subclassing auto-applies @dataclass(kw_only=True)."""
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        dataclass(kw_only=True)(cls)

microecs-0.1.0/microecs/pool.py

@@ -0,0 +1,74 @@
+"""pool.py - A pool of entities of the same type (same list of components). Basically a dynamic array with numpy"""
+import numpy as np
+from .utils import Shape, logger
+
+class Pool:
+    """
+    Pool is a dynamic array of entities data given a list of fields, shapes and dtypes (from traits).
+    Pool has no concept of entity ids.
+    """
+    INITIAL_CAPACITY = 100
+    RESERVED_NAMES = {"size", "capacity", "fields", "shapes", "dtypes", "data"}
+
+    def __init__(self, fields: list[str], shapes: list[Shape], dtypes: list[np.dtype]):
+        assert len(fields) == len(shapes) == len(dtypes), (len(fields), len(shapes), len(dtypes))
+        assert not (set(fields) & Pool.RESERVED_NAMES), f"One of {fields=} in {Pool.RESERVED_NAMES}"
+        self.fields = fields
+        self.shapes = shapes
+        self.dtypes = dtypes
+
+        self.data: dict[str, np.ndarray] = {} # the actual data is stored in a dynamic arrray, one per field
+        self.size = 0
+        self.capacity = Pool.INITIAL_CAPACITY
+        for _field, shape, dtype in zip(fields, shapes, dtypes):
+            self.data[_field] = np.empty(shape=(self.capacity, *shape), dtype=dtype)
+
+    def add_entity(self, **entity_fields) -> int:
+        """Adds an entity to the pool. All the fields required by this pool must be provided as kwargs"""
+        if self.size == self.capacity:
+            self._realloc(self.capacity * 2)
+            logger.debug(f"Capacity extended from {self.capacity // 2} to {self.capacity}")
+
+        for _field, field_shape, field_dtype in zip(self.fields, self.shapes, self.dtypes):
+            new_item: np.ndarray = entity_fields[_field] # checked in World._get_entity_pool(entity).
+            assert new_item.shape == field_shape, f"{_field=} {new_item=}, {new_item.shape=}, {field_shape=}"
+            assert np.issubdtype(new_item.dtype, field_dtype), f"{_field=} {new_item=} {new_item.dtype=} {field_dtype=}"
+            self.data[_field][self.size] = new_item
+        self.size += 1
+        return self.size - 1
+
+    def remove_entity(self, entity_index: int):
+        """removes an entity given an index (NOT ID) inside this pool"""
+        assert entity_index < self.size, f"OOB: {entity_index=}, {self.size=}"
+        for _field in self.fields:
+            self.data[_field][entity_index] = self.data[_field][self.size - 1]
+        self.size -= 1
+
+        if self.size < self.capacity / 4 and self.capacity > Pool.INITIAL_CAPACITY:
+            self._realloc(self.capacity // 2)
+
+    def pop_entity(self, entity_index: int) -> dict[str, np.ndarray]:
+        """pops an entity given an index (NOT ID) inside this pool and returns the data"""
+        res = {_field: self.data[_field][entity_index].copy() for _field in self.fields}
+        self.remove_entity(entity_index)
+        return res
+
+    def _realloc(self, new_capacity: int):
+        for _field, shape, dtype in zip(self.fields, self.shapes, self.dtypes):
+            old_data = self.data[_field]
+            self.data[_field] = np.empty(shape=(new_capacity, *shape), dtype=dtype)
+            self.data[_field][0:self.size] = old_data[0:self.size]
+        self.capacity = new_capacity
+
+    def __getattr__(self, name):
+        if (data := self.__dict__.get("data")) is not None and name in data:
+            return data[name][0: self.size]
+        raise AttributeError(name)
+
+    def __setattr__(self, name, value):
+        if (data := self.__dict__.get("data")) is not None and name in data:
+            raise ValueError(f"Cannot explicitly set anything to Pool. Use `pool.component[:] = ...` ({name=})")
+        super().__setattr__(name, value)
+
+    def __len__(self):
+        return self.size

microecs-0.1.0/microecs/system.py

@@ -0,0 +1,10 @@
+"""systems.py - Interfaces for various types of systems in ECS"""
+from abc import ABC, abstractmethod
+
+from .world import World
+
+class TickSystem(ABC):
+    """Generic tick-level system. Called inside the hot main engine loop on every tick"""
+    @abstractmethod
+    def on_tick(self, scene: World):
+        """callback called on each tick"""

microecs-0.1.0/microecs/utils.py

@@ -0,0 +1,8 @@
+"""utils.py - common utilities used by microecs. Mostly logger and types used across the code."""
+from loggez import make_logger
+
+PoolKey = int
+EntityId = int
+Shape = tuple[int, ...]
+
+logger = make_logger("MICROECS")

microecs-0.1.0/microecs/world.py

@@ -0,0 +1,155 @@
+"""world.py - The world container for ECS. It manages all the pools (one per archetype). Entities are id-based."""
+from typing import Callable
+from functools import partial
+import numpy as np
+
+from .pool import Pool
+from .utils import Shape, EntityId, PoolKey, logger
+from .component import Component
+
+class World:
+    """Generic container for pools of components. Newly added components are assigned a unique id and go in a pool"""
+    def __init__(self, components: list[type[Component]]):
+        self._check_components(components)
+        self.pools: dict[PoolKey, Pool] = {}
+        self.pool_to_components: dict[Pool, list[type[Component]]] = {}
+        # components management
+        self.component_names = [x.__name__ for x in components]
+        self.component_types = list(components)
+        self.component_to_bit: dict[type, int] = {t: 2**i for i, t in enumerate(components)} # unique bit for querying
+        self.component_to_shapes: dict[type, list[Shape]] = {
+            t: [f.metadata["shape"] for f in t.__dataclass_fields__.values()] for t in components}
+        self.component_to_dtypes: dict[type, list[str]] = {
+            t: [f.metadata["dtype"] for f in t.__dataclass_fields__.values()] for t in components}
+        self.component_to_field_names: dict[type, list[str]] = {t: list(t.__dataclass_fields__) for t in components}
+        # entity id management
+        self._eid_to_pool_ix: dict[EntityId, tuple[Pool, int]] = {}
+        self._pool_ix_to_eid: dict[tuple[Pool, int], EntityId] = {}
+        self._last_id: EntityId = -1
+        self._live_ids: set[EntityId] = set() # 'eager' mode ids so e.g. calling remove_entity twice before update fails
+        # command buffer management. {add/remove}_{entity/component} are lazy. Taken into account after update().
+        self._command_buffer: list[Callable] = []
+        logger.debug(f"Created scene with components: {self.component_names}")
+
+    # public api
+
+    def update(self):
+        """commits the underlying pool changes from the systems between two updates. Should be called in main loop."""
+        for fn in self._command_buffer:
+            fn()
+        self._command_buffer.clear()
+
+    def add_entity(self, components: list[type[Component]], **kwargs) -> EntityId:
+        """Adds an entity to the world based on components (data->kwargs). Returns an entity id. Lazy; call update()"""
+        self._check_components_against_pool(components, **kwargs)
+        self._last_id += 1
+        self._live_ids.add(self._last_id)
+        self._command_buffer.append(partial(self._add_to_pool, entity_id=self._last_id,
+                                            components=components, **kwargs))
+        return self._last_id
+
+    def remove_entity(self, entity_id: EntityId):
+        """Removes an entity based on its unique entity id. Lazy; call update()"""
+        assert entity_id in self._live_ids, f"Entity id: {entity_id} not in {self._live_ids=}"
+        self._live_ids.remove(entity_id)
+        self._command_buffer.append(partial(self._pop_from_pool, entity_id=entity_id))
+
+    def add_component(self, entity_id: EntityId, component: type[Component], **kwargs):
+        """Adds a component to an entity given its id. Component data is sent to kwargs. Lazy; call update()"""
+        assert entity_id in self._live_ids, f"Entity id: {entity_id} not in {self._live_ids=}"
+        assert component in self.component_types, f"Component '{component}' not in {self.component_types}"
+        self._command_buffer.append(partial(self._do_add_component, entity_id=entity_id, component=component, **kwargs))
+
+    def remove_component(self, entity_id: EntityId, component: type[Component]):
+        """Removes a component from an entity given its id. Lazy; call update()"""
+        assert entity_id in self._live_ids, f"Entity id: {entity_id} not in {self._live_ids=}"
+        assert component in self.component_types, f"Component '{component}' not in {self.component_types}"
+        self._command_buffer.append(partial(self._do_remove_component, entity_id=entity_id, component=component))
+
+    def query_and(self, component_types: list[type]) -> list[Pool]:
+        """returns all the entities that have all the components"""
+        key = self._make_key(component_types)
+        res = []
+        for archetype_key, archetype_pool in self.pools.items():
+            if (archetype_key & key) == key: # key is subset of archetype_key
+                res.append(archetype_pool)
+        return res
+
+    # private stuff
+
+    # eager mode methods equivalent to add/remove entities and add/remove_components
+
+    def _add_to_pool(self, entity_id: EntityId, components: list[type[Component]], **kwargs):
+        """adds the item to the pool"""
+        pool = self._get_entity_pool(components)
+        pool_index = pool.add_entity(**kwargs)
+        self._eid_to_pool_ix[entity_id] = (pool, pool_index)
+        self._pool_ix_to_eid[(pool, pool_index)] = entity_id
+
+    def _pop_from_pool(self, entity_id: EntityId) -> tuple[dict[str, np.ndarray], list[type]]:
+        """common function that updates the entities inside a pool (after popswap) and removes them if they get empty"""
+        old_pool, pool_ix = self._eid_to_pool_ix.pop(entity_id)
+        entity = old_pool.pop_entity(pool_ix)
+        components = self.pool_to_components[old_pool]
+        id_which_was_last_in_pool = self._pool_ix_to_eid.pop((old_pool, len(old_pool)))
+        if entity_id != id_which_was_last_in_pool:
+            self._eid_to_pool_ix[id_which_was_last_in_pool] = (old_pool, pool_ix) # we re-use the popped id (swapped)
+            self._pool_ix_to_eid[(old_pool, pool_ix)] = id_which_was_last_in_pool
+        if len(old_pool) == 0:
+            del self.pools[self._make_key(components)]
+            del self.pool_to_components[old_pool]
+        return entity, components
+
+    def _do_add_component(self, entity_id: EntityId, component: type[Component], **kwargs):
+        entity, components = self._pop_from_pool(entity_id)
+        new_components = [*components, component]
+        assert entity.keys().isdisjoint(kwargs), f"Duplicate keys: {entity.keys()} vs {kwargs.keys()}"
+        self._check_components_against_pool(new_components, **entity, **kwargs)
+        self._add_to_pool(entity_id, new_components, **entity, **kwargs)
+
+    def _do_remove_component(self, entity_id: EntityId, component: type[Component]):
+        entity, components = self._pop_from_pool(entity_id)
+        for _field in self.component_to_field_names[component]:
+            assert _field in entity.keys(), f"Field {component}/{_field} not in components: {components} ({entity_id=})"
+            entity.pop(_field)
+        new_components = [c for c in components if c != component]
+        self._check_components_against_pool(new_components, **entity)
+        self._add_to_pool(entity_id, new_components, **entity)
+
+    # other low-level methods
+
+    def _check_components_against_pool(self, components: list[type[Component]], **entity_fields):
+        assert len(cs := components) > 0, f"Entity has no components: {self.component_names}"
+        assert all(c in self.component_types for c in cs), f"Components '{cs}' not in {self.component_types}"
+        expected_fields = set()
+        for component in components:
+            for _field in self.component_to_field_names[component]:
+                expected_fields.add(_field)
+                assert _field in entity_fields, f"Entity doesn't have '{component}/{_field}'"
+        assert (extra := set(entity_fields) - expected_fields) == set(), f"Extra fields: {extra}; {expected_fields=}"
+
+    def _get_entity_pool(self, components: list[type]) -> Pool:
+        if (key := self._make_key(components)) not in self.pools:
+            fields = sum([self.component_to_field_names[component] for component in components], []) # merge fields
+            shapes = sum([self.component_to_shapes[component] for component in components], []) # merge shapes
+            dtypes = sum([self.component_to_dtypes[component] for component in components], []) # merge dtypes
+            self.pools[key] = Pool(fields, shapes, dtypes)
+            self.pool_to_components[self.pools[key]] = components
+        return self.pools[key]
+
+    def _make_key(self, components: list[type]) -> PoolKey:
+        key = 0
+        for component in components:
+            assert component in self.component_types, f"Component '{component.__name__}' not in {self.component_names}"
+            key |= self.component_to_bit[component]
+        return key
+
+    def _check_components(self, components: list[type]):
+        _dtypes = {"float32", "int32", "bool", "str"}
+        for component in components:
+            assert hasattr(component, "__dataclass_fields__"), f"Component '{component}' is not a dataclass"
+            for field_name, _field in component.__dataclass_fields__.items():
+                assert _field.type == np.ndarray, f"Field '{field_name}' of '{component=}' not an array: {_field}"
+                assert _field.metadata.keys() == {"shape", "dtype"}, _field.metadata
+                assert isinstance(_field.metadata["shape"], tuple), _field.metadata["shape"]
+                assert isinstance(fmd := _field.metadata["dtype"], str) and fmd in _dtypes, f"{fmd} not in {_dtypes}"

microecs-0.1.0/microecs.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: microecs
+Version: 0.1.0
+Summary: MicroECS: Minimal Entity Component System (ECS) in python and numpy
+Home-page: https://gitlab.com/meehai/microecs
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.TXT
+Requires-Dist: numpy>=2.2.0
+Requires-Dist: loggez>=0.8
+
+# MicroECS
+
+Minimal (<200 LoC) Entity Component System in python and numpy. Examples also use raylib for rendering.
+
+Usage:
+
+- `pip install -r requirements.txt`
+- Sandbox: `python main.py`
+- Tests: `pytest test/`
+
+There are only four primitives (bottom up): `Component`,`Pool`, `World` and `System`.
+
+- `Component` is a simple python dataclass holding only data. All entries must be numpy arrays with metadata fields: shape and dtype. We support 4 dtypes only: `int32`, `float32`, `str` and `bool`.
+- `Pool` is a simple 'archetype' dynamic array, holding entities of the same type (same set of components). Usses `Components` metadata to construct contiguous arrays for all entities of the same type.
+- `World` is a manager of `Pools` and has an overview of all the entities in the scene. It also manages the migration of entities from one pool to the other.
+- `System` is an abstract class that queries the `World` for a subset of `Pools` matching some components. It updates the entities in these pools given some logic (e.g. collisions, motion physics or simply calls the drawing functions).
+
+Few relevant concepts:
+
+- `Pool` operates on array indices, while `World` operates on entity IDs (also integers). This allows seamless movement between pools while the high-level systems still working as intended.
+- All mutable operations on `World` are lazy. These are: `add_entity`, `remove_entity`, `add_component`, `remove_component`. They are added to a command buffer which is only executed when calling `world.update()`.
+
+Super simplified main loop structure:
+
+```python
+import numpy as np
+import raylib as rl
+from microecs import World, Component, TickSystem
+
+# components
+class HasPosition(Component):
+    position: np.ndarray = field(metadata={"shape": (2, ), "dtype": "float32"})
+class HasColor(Component):
+    color: np.ndarray = field(metadata={"shape": (4, ), "dtype": "int32"})
+
+# systems
+class RenderSystem(TickSystem):
+    def on_tick(self, world: World): # must override
+        for pool in world.query_and((HasPosition, HasColor)): # get all pools of entities having both
+            for position, radius, color in zip(pool.position, pool.color): # for each entity in this pool
+                DrawEntity(position, color)
+class CollisionSystem(TickSystem)
+    def on_tick(self, world: World): # must override
+        ...
+
+def main():
+    render_system = RenderSystem()
+    update_systems: list[TickSystem] = [CollisionSystem()]
+
+    world = World(components=[HasPosition, HasColor])
+    for _ in range(n_objects):
+        # NOTE: world.{add/remove}_{entity/component} are lazy. They take effect after the first world.update() call.
+        world.add_entity(components=(HasPosition, HasColor), # tuple of components (types)
+                         position=np.array((x, y), "float32"), # data as kwargs
+                         color=np.array("black", dtype="int32"))
+
+    while not rl.WindowShouldClose():
+        world.update() # must be called at each tick so the lazy methods are processed and entities are updated
+        # update stuff...
+        _ = [system.on_tick(world=world) for system in update_systems]
+        # draw stuff, e.g. using raylib
+        rl.BeginDrawing()
+        rl.ClearBackground(rl.RAYWHITE)
+        rl.DrawFPS(rl.GetScreenWidth() - 100, 0)
+        render_system.on_tick(world=world)
+        rl.EndDrawing()
+```

microecs-0.1.0/microecs.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.TXT
+README.md
+setup.py
+microecs/__init__.py
+microecs/component.py
+microecs/pool.py
+microecs/system.py
+microecs/utils.py
+microecs/world.py
+microecs.egg-info/PKG-INFO
+microecs.egg-info/SOURCES.txt
+microecs.egg-info/dependency_links.txt
+microecs.egg-info/requires.txt
+microecs.egg-info/top_level.txt

microecs-0.1.0/microecs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

microecs-0.1.0/microecs.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=2.2.0
+loggez>=0.8

microecs-0.1.0/microecs.egg-info/top_level.txt

@@ -0,0 +1 @@
+microecs

microecs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

microecs-0.1.0/setup.py

@@ -0,0 +1,33 @@
+"""setup.py -- note use setuptools==73.0.1; older versions fuck up the data files, newer versions include resources."""
+from pathlib import Path
+from setuptools import setup, find_packages
+
+NAME = "microecs"
+VERSION = "0.1.0"
+DESCRIPTION = "MicroECS: Minimal Entity Component System (ECS) in python and numpy"
+URL = "https://gitlab.com/meehai/microecs"
+
+CWD = Path(__file__).absolute().parent
+with open(CWD/"README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+REQUIRED_CORE = [
+    "numpy>=2.2.0",
+    "loggez>=0.8",
+]
+
+setup(
+    name=NAME,
+    version=VERSION,
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url=URL,
+    packages=find_packages(),
+    install_requires=REQUIRED_CORE,
+    extras_require={},
+    dependency_links=[],
+    license="MIT",
+    python_requires=">=3.12",
+    scripts=[], # cli/xxx in the future
+)