Entity Component System (ECS)

Bevy’s Entity Component System (ECS) offers a data-driven, modular solution to managing large numbers of objects efficiently. It separates an entity’s characteristics from its logic to allow flexibility, performance, and scalability.

So… What is ECS?

ECS is a software pattern and structure that breaks down your program into Entities, Components and Systems.

Entities

These are unique identifiers that represent objects in your game or application.
In essence, they connect all the components together to make up a single object in your game world.
Entities themselves don’t hold any data or behavior. They are simply IDs.
For example, an entity could represent a player or an enemy.

Components

Components are pure data structures that hold information about an entity.
They define the properties or attributes of an entity such as position, velocity or health.
Components are purely data and do not contain any logic.

Systems

Systems are the functions that operate on the entities with specific components.
They contain the logic of your application, such as updating positions based on velocity or checking for collisions.

How is ECS different to OOP?

In Object-Oriented Programming (OOP), data and behavior are bundled together inside objects, which follow class hierarchies. While this approach can make code intuitive, it often leads to rigid inheritance structures that are difficult to modify once established. A Character class might inherit movement functions, but adding new movement types often requires restructuring.

In contrast, Bevy’s ECS system separates its data from behavior. Entities are just IDs, while components store their properties. The logic for interacting with these components is handled by systems, which run independently.

Example

This just a simple example that demonstrates the core aspects of ECS: defining components, spawning an entity using commands, and using systems to query entities with their components to apply logic.

use bevy::prelude::*; 

// Component to store the position of an entity
#[derive(Component)]
struct Position {
    x: f32,
    y: f32,
}

// Component to store the velocity of an entity
#[derive(Component)]
struct Velocity {
    dx: f32,
    dy: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, spawn_player) // Run the spawn_player system once at startup
        .add_systems(Update, update_position) // Run the update_position system every frame
        .add_systems(Update, print_position) // Run the print_position system every frame
        .run(); // Start the application
}

// System that spawns a player entity with Position and Velocity components, using Commands
fn spawn_player(mut commands: Commands) {
    commands.spawn((
        Position { x: 0.0, y: 0.0 }, // Initial position
        Velocity { dx: 1.0, dy: 1.0 }, // Initial velocity
    ));
}

// System that updates the position of entities based on their velocity, using Query
fn update_position(mut query: Query<(&mut Position, &Velocity)>) {
    for (mut position, velocity) in query.iter_mut() {
        position.x += velocity.dx; // Update the x-coordinate
        position.y += velocity.dy; // Update the y-coordinate
    }
}

// System that prints the position of entities with a Position component, using Query
fn print_position(query: Query<(Entity, &Position)>) {
    for (entity, position) in query.iter() {
        println!("Player {:?} is at position: ({}, {})", entity, position.x, position.y);
        // Print the entity ID and its position
    }
}

Why ECS is Becoming More Popular

ECS is getting increasingly used in game development due to its performance, scalability, and parallel processing. Unlike traditional OOP, ECS optimizes memory layout, allowing systems to process large amounts of data efficiently. It’s also very flexible, letting developers modify behaviors without complex class hierarchies.

While Bevy is built entirely around ECS, it’s not the only engine using this approach. Major engines like Unity DOTS and Doom’s id Tech embrace ECS for high-performance simulations.

As games and applications grow in complexity, ECS is becoming a standard approach for efficient, modular design.