Modern Game Engine Architecture: Data-Oriented Design and ECS

Modern games with tens of thousands of dynamic entities need an efficiency that classic object-oriented programming can no longer reach. The Entity Component System is the answer to a limit that was never really a limit of language, but of hardware.

The problem is the cache, not the CPU

The gap between processor speed and main memory speed has been widening for decades. Fetching data from RAM takes hundreds of cycles; from L1 cache, only a handful. Modern processors spend most of their time waiting for data, not computing.

The object-oriented approach places each entity as a separate object on the heap, each one holding all of its data. When the physics system only needs position and velocity, the processor still pulls the entire object into cache — including textures, names, and state it has no use for. Most of that cache goes to waste.

Arranging data by how it gets used

ECS separates data from behavior. Components of the same kind are stored side by side in contiguous arrays: all positions in one array, all velocities in another. The system that handles movement reads those two arrays in sequence.

Every cache line that gets pulled in is now filled entirely with data that will actually be used. The processor's prefetcher recognizes the sequential access pattern and loads the next data before it is requested. The performance difference is often a multiple, not a few percent.

Parallelism that follows on its own

A benefit that rarely gets mentioned up front: this separation makes parallelism far safer. Because each system declares which components it reads and which it writes, the scheduler can work out which systems do not overlap and run them concurrently without locks.

The uniform layout also opens the way for SIMD instructions, which process several entities in a single instruction. Both emerge as a consequence of how the data is arranged, not as features bolted on later.

The honest cost

ECS is not without drawbacks. The code is harder for newcomers to read: a single entity's logic is spread across many systems, and debugging gets more convoluted. Operations that touch one entity at random are actually slower than they are under the object-oriented approach.

That is why ECS pays off most when entities are very numerous and processed uniformly. For a game with a few dozen entities, the complexity does not repay itself. Hardware-friendly memory layout delivers extraordinary performance — on the problems that genuinely take that shape.