Why Subterrans

(Editor’s note, 2026-05-17: Phase numbering has been updated since this post was published. See the current roadmap for the active phase structure.)

In 1991, Maxis released SimAnt. It put you in charge of a black ant colony in a suburban backyard, fighting a red colony for territory and eventually invading the house. You could zoom into a single ant and play it directly, or pull back and command the colony as a whole. Pheromone trails. Foraging. Larvae. A queen to protect.

I played a lot of SimAnt. So did a lot of people. Then it disappeared into the shelf where Maxis kept the games that didn’t become franchises, and nothing has really filled that gap since.

There are good ant-themed games — Empires of the Undergrowth is excellent, Ants Took My Eyeball is strange and great — but none of them are the SimAnt-shaped game. The thing where you’re managing a colony as a system, not commanding individual units, where pheromone fields propagate independently of the ants on them, where the enemy colony is running the same code you are.

Subterrans is an attempt to build that game. It’s a spiritual successor, not a remake. Same shape, modern foundations.

What’s actually different

Three things, mostly.

First, it runs in a browser. SimAnt shipped on floppies. Subterrans Phase 1 is a single static page on subterrans.com. Native builds for iOS, Android, Steam, and desktop come later, but the web is the primary target. That’s a deliberate constraint — if I can’t get the loop fun in 2D inside a browser tab, I shouldn’t be building anything bigger.

Second, the simulation is a first-class architectural object. In SimAnt, the simulation and the rendering were inseparable — that was just how games were built in 1991. In Subterrans, src/sim/ is pure TypeScript. No DOM, no Phaser, no Date.now(), no floats. Everything is integers, fixed timestep at 20 Hz, single seeded PRNG. The renderer reads state and draws it; the simulation doesn’t know the renderer exists.

That’s not architectural showing-off. It’s the only way I get deterministic replay, future multiplayer, and AI agents that can actually reason about the code. More on that in the seven principles post.

Third, this is also an experiment in AI-agent development. Most of the code is being written by Claude Code and Codex working from planning artifacts I write. The architectural rigor above isn’t separate from that — it’s how I get AI agents to produce code that doesn’t drift. Every PR gets reviewed by both agents independently. Lint rules enforce the architectural boundaries. The planning workflow is its own discipline.

I’ll write more about that elsewhere. The short version: I want to know how much of a real game one person can ship if they treat AI agents as collaborators with very specific failure modes, and design the project around those failure modes rather than ignoring them.

What Phase 1 actually is

Phase 1 answers exactly one question: is the core colony management loop fun?

Not “is the art good.” Not “is there a tutorial.” Not “are there ten enemy types.” The minimum thing that’s recognizably SimAnt-shaped is:

• Your colony has a queen, workers, larvae, and food storage
• You designate tunnels to dig; workers dig them
• You assign chamber types (queen chamber, nursery, food storage); ants behave accordingly
• You toggle between surface view and underground cross-section
• Workers find food on the surface and bring it home
• Pheromone trails form and decay
• You set behavior priorities (forage / dig / defend / idle)
• One enemy AI colony runs the same simulation systems you do
• Win condition: kill the enemy queen. Lose condition: they kill yours.

That’s it. That’s the whole thing. A round takes 5 to 15 minutes. You play it, and either you want to play another round or you don’t.

If the answer is “yes” — Phase 2 starts adding depth. Multiple castes. Real pixel art. Sound. The Yellow Ant, where you can drop into a single individual SimAnt-style. Multiple patches. A day/night cycle.

If the answer is “no” — no amount of art, sound, tutorials, or content saves it. You go fix the core loop or you stop.

What I’m explicitly not doing in Phase 1

• Pixel art. Phase 1 is programmer art — circles and rectangles. Real art begins after the loop is validated.
• Sound and music. Same reason.
• Tutorial system. There’s a one-page text explanation.
• Settings menus, save/load UI, main menu. The game boots straight into a hardcoded scenario and autosaves to localStorage.
• Multiple enemy types, multiple ant castes, weather, the Yellow Ant, the human invasion, mating flights. All deferred to later phases.
• Multiplayer. The architecture preserves the option (deterministic simulation, replay logging) but Phase 1 is single-player only.

Each of these has a reason. The collective reason is the same: scope discipline. SimAnt was made by a bigger team than me, and they were doing it as their day job. I’m one person with AI collaborators. The way that math works is that I have to cut hard until the thing I’m building is small enough to be good, then expand from there.

Where this is now

The site you’re reading just came online. The game itself has a working simulation skeleton — fixed timestep, deterministic RNG, the seven principles enforced via lint — and is currently mid-Phase 1 buildout. There’s no playable demo yet. There will be, behind a sign-up gate, and you’ll see it land in the roadmap when it does.

I’ll keep posting here. No cadence promises — when something worth reading happens, you’ll see it.