Comparative benchmarks for Go Entity Component System (ECS) implementations.

Disclaimer: This repository is maintained by the author of Ark.

ECS	Tested	Latest	Activity
Ark	v0.6.1
Donburi	v1.15.7
go‑gameengine‑ecs	v0.9.0
unitoftime/ecs	v0.0.3
Volt	v1.6.0

Candidates are always displayed in alphabetical order.

In case you develop or use a Go ECS that is not in the list and that want to see here, please open an issue or make a pull request. See the section on Contributing for details.

In case you are a developer or user of an implementation included here, feel free to check the benchmarked code for any possible improvements. Open an issue if you want a version update.

[1] ECS lifecycle events, allowing to react to entity creation, component addition, ...
[2] Faster batch operations for entity creation etc.

Last run: Wed, 15 Oct 2025 16:10:15 UTC
CPU: AMD EPYC 7763 64-Core Processor

For each benchmark, the left plot panel and the table show the time spent per entity, while the right panel shows the total time.

Note that the Y axis has logarithmic scale in all plots. So doubled bar or line height is not doubled time!

All components used in the benchmarks have two float64 fields. The initial capacity of the world is set to 1024 where this is supported.

N entities with components Position and Velocity. 10x N entities with components Position.

• Query all [Position, Velocity] entities, and add the velocity vector to the position vector.

Note: Donburi, unitoftime/ecs, and Volt use a callback-based approach for their query loops. As a result, iteration speed may degrade if the callback contains complex logic and the Go compiler is unable to inline it.

Query where the matching entities are fragmented over 32 archetypes.

N entities with components Position and Velocity. Each of these N entities has some combination of components C1, C2, ..., C5, so entities are fragmented over up to 32 archetypes.

• Query all [Position, Velocity] entities, and add the velocity vector to the position vector.

Note: Donburi, unitoftime/ecs, and Volt use a callback-based approach for their query loops. As a result, iteration speed may degrade if the callback contains complex logic and the Go compiler is unable to inline it.

Query where there are 256 non-matching archetypes.

N entities with components Position and Velocity. Another 4 * N entities with Position and some combination of 8 components C1, ..., C8, so these entities are fragmented over up to 256 archetypes.

• Query all [Position, Velocity] entities, and add the velocity vector to the position vector.

Note: Donburi, unitoftime/ecs, and Volt use a callback-based approach for their query loops. As a result, iteration speed may degrade if the callback contains complex logic and the Go compiler is unable to inline it.

N entities with component Position. All entities are collected into a slice, and the slice is shuffled.

• Iterate the shuffled entities.
• For each entity, get its Position and sum up their X fields.

• Create N entities with components Position and Velocity.

The operation is performed once before benchmarking, to exclude memory allocation, archetype creation etc. See the benchmark below for entity creation with allocation.

• Create N entities with components Position and Velocity.

Each round is performed on a fresh world. This reflects the creation of the first entities with a certain components set in your game or application. As soon as things stabilize, the benchmarks for entity creation without allocation (above) apply.

Low N values might be biased by things like archetype creation and memory allocation, which is handled differently by different implementations.

• Create N entities with 10 components C1, ..., C10.

The operation is performed once before benchmarking, to exclude things like archetype creation and memory allocation.

N entities with component Position.

• Add Velocity to all entities.
• Remove Velocity from all entities.

One iteration is performed before the benchmarking starts, to exclude memory allocation.

N entities with component Position and 10 further components C1, ..., C10.

• Add Velocity to all entities.
• Remove Velocity from all entities.

One iteration is performed before the benchmarking starts, to exclude memory allocation.

N entities with components Position and Velocity.

• Delete all entities

N entities with 10 components C1, ..., C10.

• Delete all entities

• Create a new world

Given that all tested projects are on Github, we can use the star history as a proxy here.

Run the benchmarks using the following command:

go run . -test.benchtime=0.25s

On PowerShell use this instead:
go run . --% -test.benchtime=0.25s

The benchtime limit is required for some of the benchmarks that have a high setup cost which is not timed. They would take forever otherwise. The benchmarks can take up to one hour to complete.

To run a selection of benchmarks, add their names as arguments:

go run . query2comp query1in10 query32arch

To create the plots, run plot/plot.py. The following packages are required:

• numpy
• pandas
• matplotlib

pip install -r ./plot/requirements.txt python plot/plot.py 

Developers of ECS frameworks are welcome to add their implementation to the benchmarks. However, there are a few (quality) criteria that need to be fulfilled for inclusion:

• All benchmarks must be implemented, which means that the ECS must have the required features
• The ECS must be working properly and not exhibit serious flaws; it will undergo a basic review by maintainers
• The ECS must be sufficiently documented so that it can be used without reading the code
• There must be at least basic unit tests
• Unit tests must be run in the CI of the repository
• The ECS must not be tightly coupled to a particular game engine, particularly graphics stuff
• There must be tagged release versions; only tagged versions will be included here

Developers of included frameworks are encouraged to review the benchmarks, and to fix (or point to) misuse or potential optimizations.