Entity component system - Wikipedia https://en.wikipedia.

org/wiki/Entity_component_system

Entity component system

Entity component system (ECS)[a] is a software architectural pattern mostly
used in video game development for the representation of game world objects.
An ECS comprises entities composed from components of data, with systems
which operate on the components.

ECS follows the principle of composition over inheritance, meaning that every
entity is defined not by a type hierarchy, but by the components that are
A simple Entity Component System
associated with it. Systems act globally over all entities which have the required
layout.
components.

Due to an ambiguity in the English language, however, a common interpretation of the name is that an ECS is a
system comprising entities and components. For example, in the 2013 talk at GDC,[1] Scott Bilas compares a C++
object system and his new custom component system. This is consistent with a traditional use of system term in
general systems engineering with Common Lisp Object System and type system as examples.

Characteristics
ECS combines orthogonal, well-established ideas in general computer science and programming language theory.
For example, components can be seen as a mixin idiom in various programming languages. Components are a
specialized case under the general delegation (object-oriented programming) approach and meta-object protocol.
That is, any complete component object system can be expressed with the templates and empathy model within The
Orlando Treaty[2] vision of object-oriented programming.

Entity: An entity represents a general-purpose object. In a game engine context, for example, every coarse game
object is represented as an entity. Usually, it only consists of a unique id. Implementations typically use a plain
integer for this.[3]

Component: A component characterizes an entity as possessing a particular aspect, and holds the data needed to
model that aspect. For example, every game object that can take damage might have a Health component associated
with its entity. Implementations typically use structs, classes, or associative arrays.[3]

System: A system is a process which acts on all entities with the desired components. For example, a physics system
may query for entities having mass, velocity and position components, and iterate over the results doing physics
calculations on the set of components for each entity.

The behavior of an entity can be changed at runtime by systems that add, remove or modify components. This
eliminates the ambiguity problems of deep and wide inheritance hierarchies often found in Object Oriented
Programming techniques that are difficult to understand, maintain, and extend. Common ECS approaches are
highly compatible with, and are often combined with, data-oriented design techniques. Data for all instances of a
component are contiguously stored together in physical memory, enabling efficient memory access for systems
which operate over many entities.

History
In 1998, Thief: The Dark Project pioneered an ECS.[4] The engine was later used for its sequel, as well as System
Shock 2.

In 2007, the team working on Operation Flashpoint: Dragon Rising experimented with ECS designs, including
those inspired by Bilas/Dungeon Siege, and Adam Martin later wrote a detailed account of ECS design,[5] including

1 of 4 01/04/2024, 03:38
Entity component system - Wikipedia https://en.wikipedia.org/wiki/Entity_component_system

definitions of core terminology and concepts.[6] In particular, Martin's work popularized the ideas of systems as a
first-class element, entities as identifiers, components as raw data, and code stored in systems, not in components or
entities.

In 2015, Apple Inc. introduced GameplayKit, an API framework for iOS, macOS and tvOS game development that
includes an implementation of ECS.[7]

In August 2018 Sander Mertens created the popular flecs (https://github.com/SanderMertens/flecs) ECS
framework.[8]

In October 2018[9] the company Unity released its megacity demo that utilized a tech stack built on an ECS. It had
100,000 audio sources—one for every car, neon sign, and more—creating a large, complex soundscape.[9]

Variations
The data layout of different ECS's can differ as well as can the definition of components, how they relate to entities,
and how systems access entities' components.

Martin's ECS
A popular blog series by Adam Martin defines what he considers an Entity Component System architecture:[6]

An entity only consists of an ID for accessing components. It is a common practice to use a unique ID for each entity.
This is not a requirement, but it has several advantages:

▪ The entity can be referred using the ID instead of a pointer. This is more robust, as it would allow for the entity to
be destroyed without leaving dangling pointers.
▪ It helps for saving state externally. When the state is loaded again, there is no need for pointers to be
reconstructed.
▪ Data can be shuffled around in memory as needed.
▪ Entity ids can be used when communicating over a network to uniquely identify the entity.
Some of these advantages can also be achieved using smart pointers.

Components have no game code (behavior) inside of them. The components don't have to be located physically
together with the entity, but should be easy to find and access using the entity.

"Each System runs continuously (as though each System had its own private thread) and performs global actions on
every Entity that possesses a Component or Components that match that System's query."

The Unity game engine

Unity's layout has tables each with columns of components. In this system an entity type is based on the
components it holds. For every entity type there is a table (called an archetype) holding columns of components that
match the components used in the entity. To access a particular entity one must find the correct archetype (table)
and index into each column to get each corresponding component for that entity.

Apparatus ECS
Apparatus is a third-party ECS implementation for Unreal Engine that has introduced some additional features to
the common ECS paradigm. One of those features is the support of the type hierarchy for the components. Each
component can have a base component type (or a base class) much like in OOP. A system can then query with the
base class and get all of its descendants matched in the resulting entities selection. This can be very useful for some
common logic to be implemented on a set of different components and adds an additional dimension to the
paradigm.

2 of 4 01/04/2024, 03:38
Entity component system - Wikipedia https://en.wikipedia.org/wiki/Entity_component_system

FLECS
Flecs is a fast and lightweight ECS implementation for C & C++ that lets you build games and simulations with
millions of entities.

Common patterns in ECS use

The normal way to transmit data between systems is to store the data in components, and then have each system
access the component sequentially. For example, the position of an object can be updated regularly. This position is
then used by other systems. If there are a lot of different infrequent events, a lot of flags will be needed in one or
more components. Systems will then have to monitor these flags every iteration, which can become inefficient. A
solution could be to use the observer pattern. All systems that depend on an event subscribe to it. The action from
the event will thus only be executed once, when it happens, and no polling is needed.

The ECS architecture has no trouble with dependency problems commonly found in Object Oriented Programming
since components are simple data buckets, they have no dependencies. Each system will typically query the set of
components an entity must have for the system to operate on it. For example, a render system might register the
model, transform, and drawable components. When it runs, the system will perform its logic on any entity that has
all of those components. Other entities are simply skipped, with no need for complex dependency trees. However
this can be a place for bugs to hide, since propagating values from one system to another through components may
be hard to debug. ECS may be used where uncoupled data needs to be bound to a given lifetime.

The ECS architecture uses composition, rather than inheritance trees. An entity will be typically made up of an ID
and a list of components that are attached to it. Any game object can be created by adding the correct components to
an entity. This allows the developer to easily add features to an entity, without any dependency issues. For example,
a player entity could have a bullet component added to it, and then it would meet the requirements to be
manipulated by some bulletHandler system, which could result in that player doing damage to things by running
into them.

The merits of using ECSs for storing the game state have been proclaimed by many game developers like Adam
Martin. One good example is the blog posts by Richard Lord where he discusses the merits and why ECS designed
game data storage systems are so useful.[10]

Usage outside of games

Although mostly found in video game development, the ECS architecture can be useful in other domains.[11]

See also
▪ Model–view–controller
▪ Observer pattern
▪ Strategy pattern
▪ Relational model

Notes
a. To avoid ambiguity in this article, we follow the words "Entity Component System" with a noun such as
"framework" or "architecture". The word "system" is always singular in this context.

References
1. Bilas, Scott. "A Data-Driven Game Object System" (http://gamedevs.org/uploads/data-driven-game-object-syste
m.pdf) (PDF). Archived (https://web.archive.org/web/20130918001211/http://gamedevs.org/uploads/data-driven-
game-object-system.pdf) (PDF) from the original on 18 September 2013. Retrieved 25 December 2013.

3 of 4 01/04/2024, 03:38
Entity component system - Wikipedia https://en.wikipedia.org/wiki/Entity_component_system

2. Lynn Andrea Stein, Henry Liberman, David Ungar: A shared view of sharing: The Treaty of Orlando. In: Won
Kim, Frederick H. Lochovsky (Eds.): Object-Oriented Concepts, Databases, and Applications ACM Press, New
York 1989, ch. 3, pp. 31–48 ISBN 0-201-14410-7 (online (http://web.media.mit.edu/~lieber/Publications/Treaty-o
f-Orlando-Chapter.pdf) Archived (https://web.archive.org/web/20161007000621/http://web.media.mit.edu/~lieber/
Publications/Treaty-of-Orlando-Chapter.pdf) 2016-10-07 at the Wayback Machine)
3. "Entity Systems Wiki" (http://entity-systems.wikidot.com/). Archived (https://web.archive.org/web/2019123112203
0/http://entity-systems.wikidot.com/) from the original on 31 December 2019. Retrieved 31 December 2019.
4. "The Unknown Design Pattern" (https://dev.to/ovid/the-unknown-design-pattern-1l64). 11 March 2021.
5. Martin, Adam. "Entity Systems are the Future of MMOG Development" (http://t-machine.org/index.php/2007/09/0
3/entity-systems-are-the-future-of-mmog-development-part-1/). Archived (https://web.archive.org/web/20131226
102755/http://t-machine.org/index.php/2007/09/03/entity-systems-are-the-future-of-mmog-development-part-1/)
from the original on 26 December 2013. Retrieved 25 December 2013.
6. Martin, Adam. "Entity Systems are the Future of MMOG Development Part 2" (http://t-machine.org/index.php/20
07/11/11/entity-systems-are-the-future-of-mmog-development-part-2/). Archived (https://web.archive.org/web/20
131226102634/http://t-machine.org/index.php/2007/11/11/entity-systems-are-the-future-of-mmog-development-p
art-2/) from the original on 26 December 2013. Retrieved 25 December 2013.
7. "Introducing GameplayKit - WWDC 2015 - Videos" (https://developer.apple.com/videos/play/wwdc2015/608/).
Archived (https://web.archive.org/web/20171006113323/https://developer.apple.com/videos/play/wwdc2015/60
8/) from the original on 2017-10-06. Retrieved 2017-10-06.
8. "SanderMertens - Overview" (https://github.com/SanderMertens). GitHub. Retrieved 2021-09-06.
9. "Unity unleashes Megacity demo - millions of objects in a huge cyberpunk world" (https://www.mcvuk.com/devel
opment-news/unity-unleashes-megacity-demo-millions-of-objects-in-a-huge-cyberpunk-world/). MCV/DEVELOP.
2018-10-24. Retrieved 2021-06-24.
10. "Why use an Entity Component System architecture for game development?" (https://www.richardlord.net/blog/e
cs/why-use-an-entity-framework.html). www.richardlord.net. Retrieved 2021-11-18.
11. Romeo, Vittorio. (2016): Analysis of entity encoding techniques, design and implementation of a multithreaded
compile-time Entity-Component-System C++14 library 10.13140/RG.2.1.1307.4165. (https://
www.researchgate.net/publication/
305730566_Analysis_of_entity_encoding_techniques_design_and_implementation_of_a_multithreaded_compile-
time_Entity-Component-System_C14_library)

External links
▪ Anatomy of a knockout (http://www.chris-granger.com/2012/12/11/anatomy-of-a-knockout/)
▪ Evolve Your Hierarchy (http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
▪ Entity Systems Wiki (https://web.archive.org/web/20171030021158/http://entity-systems-wiki.t-machine.org/)
▪ Component - Game Programming Patterns (http://gameprogrammingpatterns.com/component.html)
▪ ECS design to achieve true Inversion of Flow Control (http://www.sebaslab.com/ecs-design-to-achieve-true-inver
sion-of-flow-control/)

Retrieved from "https://en.wikipedia.org/w/index.php?title=Entity_component_system&oldid=1214650909"

4 of 4 01/04/2024, 03:38