Entitas

Entitas uses a code generator (Jenny) that introspects component class definitions marked with IComponent interface and automatically generates type-safe fluent APIs (e.g., entity.AddPosition() instead of generic entity.AddComponent<Position>()). The generator creates context-specific entity classes, matcher factories, and component accessors by parsing C# source files and emitting boilerplate code, eliminating manual repetition while maintaining compile-time safety and IDE autocomplete support.

Entitas provides a Context abstraction that acts as a container and lifecycle manager for entities belonging to a specific domain (e.g., GameContext, InputContext, UIContext). Each context maintains its own entity pool, component index, and group cache, allowing developers to logically partition game state and systems. Contexts expose fluent APIs for entity creation, destruction, and querying via matchers, with automatic group updates when entities gain or lose components.

Entitas uses a Jenny code generator that parses component class definitions and their attributes ([Event], [Unique], [ForeignKey], [PrimaryKey], etc.) to generate specialized code. Attributes control code generation behavior, allowing developers to declare component properties without writing boilerplate. The generator supports custom generation rules via plugins, enabling teams to extend code generation for domain-specific needs (e.g., network serialization, UI binding).

Entitas provides a fluent API for entity manipulation where component operations (add, remove, replace) can be chained together in a single expression. The generated entity classes expose typed methods like entity.AddPosition(x, y).AddVelocity(vx, vy).IsMoving(true) that return the entity instance, enabling readable, chainable code. This fluent pattern reduces boilerplate and improves code readability compared to imperative component management.

Entitas implements reactive systems that automatically trigger when entities gain, lose, or replace specific components. Systems subscribe to component change events (OnComponentAdded, OnComponentRemoved, OnComponentReplaced) via matcher-based predicates, and the framework batches these events and executes reactive systems in response. This eliminates manual polling and enables event-driven architecture where systems only run when relevant state changes occur.

Entitas provides a Matcher class that defines entity query criteria using fluent AllOf/AnyOf/NoneOf predicates, which are compiled into efficient group collections. Groups automatically track entities matching the matcher criteria and update their membership when entities gain or lose components. The framework caches groups by matcher hash to avoid redundant queries, and invalidates caches when component changes occur, ensuring queries always return correct results without manual refresh.

Entitas implements object pooling for entities and components to minimize garbage collection pressure in Unity's managed environment. When entities are destroyed, they are returned to a pool rather than deallocated, and component instances are reused across entity lifecycle. The framework pre-allocates entity pools based on expected capacity and resets component state on reuse, reducing GC.Alloc calls and frame-time spikes from garbage collection.

Entitas provides entity indexing capabilities that create hash-based indices on specific component fields (e.g., index entities by their ID or position). Indices are automatically maintained as entities gain/lose components or component values change, enabling O(1) lookups by field value instead of O(n) group iteration. Developers declare indices via attributes on components, and the code generator creates index management code.

Entitas provides integration with Unity's MonoBehaviour system through a bridge pattern that allows MonoBehaviours to interact with ECS entities. Developers can attach MonoBehaviour components to GameObjects and have them communicate with Entitas entities via event systems or direct component access. The framework provides helper classes and patterns for converting between GameObject-based and entity-based representations.

Entitas includes editor extensions and visual debugging tools that allow developers to inspect entity state, component values, and group membership in real-time during gameplay. The framework provides an Entity Inspector window in Unity Editor that displays all entities in a context, their components, and component field values, with the ability to add/remove components and modify values directly from the inspector.

Entitas provides a system execution framework where developers define systems (ISystem implementations) and control their execution order either manually through explicit ordering or automatically through dependency declaration. Systems can be organized into feature groups and execution phases (Initialize, Execute, Cleanup), and the framework ensures systems execute in the correct order with proper initialization and teardown. Developers can declare system dependencies via interfaces or attributes, and the framework validates and enforces execution order.

Entitas provides an event system that allows systems and entities to publish and subscribe to events at both entity scope (events attached to specific entities) and global scope (events broadcast to all listeners). Events are type-safe and can carry arbitrary data, and the framework batches event publishing and dispatch to ensure consistent execution within a frame. Event subscriptions are managed automatically and cleaned up when entities are destroyed.