Citizens and Stories

Before the first line of code and the Journey it starts

DEVLOG #1

I’ve Been Trying to Play This Game for Fifty Years

— Or: what happens when an EMC Engineer decides to build the game he couldn’t find —

The Anthill

I want to tell you about a game I’ve never been able to play.

Not because it doesn’t exist. Because every game that came close got one thing right and left the most important thing on the table. And for fifty years I kept picking up the next one, getting a few hours in, and feeling the same quiet disappointment — the moment when I realized, again, that the world I was playing in existed for me. That without me, it was nothing. That I was the point of it.

I didn’t want to be the point of it. I wanted to visit something.

When I was a kid I used to watch anthills. Not for any scientific reason — just because they were there. Doing something. The colony had its own urgency, its own hierarchy, its own logic. It didn’t know I existed. I could drop a crumb and watch the whole network reorganize. I could be a god for a moment, or I could just sit and watch.

The anthill was not built for me. But I could interact with it.

That’s the game I’ve been looking for. A world that runs on its own logic. That has its own history, its own legendary figures, its own conflicts and discoveries and losses. A world I can put my hand on — nudge, influence, guide — but that doesn’t need me.

Not a game I play. A place I visit.

What Came Close and Why It Hurt

A few games almost got there.

Civilization IV had Great People — citizens who emerged from your civilization’s actual behavior. Your philosophical city produced a philosopher. Your military city produced a general. The causality was visible. You could look at who emerged and understand exactly why, and it felt earned. Later entries abandoned it. The mechanic got reduced to a points pool you drew from. The causality disappeared. It became a feature instead of a truth.

Civilization VII tried something brave with age transitions — the idea that an era should end as a reckoning, not a timer. Your civilization would face a crisis that reflected who it had become. An agrarian civilization facing famine. A militaristic one facing succession conflict. The concept was right. The execution failed because the crisis arrived from outside the world. It was imposed. It had no roots in what your civilization had actually done. Players hated it — not because the idea was wrong, but because it felt arbitrary. It felt authored. It felt like someone decided it was time.

Distant Worlds was the most heartbreaking. One of the most ambitious space games ever made. A living universe you could engage with at whatever level of involvement you chose — full manual control down to full automation, with everything in between. The vision was exactly right. But the automation was layered onto a game originally designed for manual play. The seam was always visible. The manual game and the automated game were two different products that had been forced to share a codebase. The beauty of the vision was lost in the gap between what the game was and what it was trying to become.

RimWorld actually got the storytelling part right. Your colonists are people. They have histories and quirks and relationships and things they care about. Stories emerge from the system rather than being authored on top of it. A colonist breaks down at exactly the wrong moment for exactly the right reasons. The system generates narrative more interesting than anything a writer could have scripted. But the world stays small. It never scales beyond a single colony. The emergent storytelling stays local.

Every one of these games had the vision. Every one of them got there too late — after the foundation was already built, after the architecture was already committed. The vision arrived and found a codebase that couldn’t carry it. So it got bolted on. And you could always see the bolts.

Who I Am — And Why That Matters

I should tell you who I am before I tell you what changed.

I’m an EMC Engineer. I’ve spent my career thinking about electromagnetic compatibility — how systems coexist without interfering with each other. I have some old coding experience: Pascal mostly, a little C++, some Visual Basic. Nothing modern. Nothing close to game development.

What gave me the courage to start was something small. A few weeks ago I used AI to help me write some VBA hooks for Excel workbooks — solving real gaps in real systems I work with every day. It worked. The AI didn’t write my solution — it taught me enough to find it myself. And somewhere in that process I thought: if I can do that, what else is within reach?

Turns out — the game I’ve been imagining for fifty years.

I want to be clear about what that means. I’m not a developer. I’m not a game designer. I don’t have a studio or a team or a budget. I have a vision that’s been taking shape since I was old enough to watch anthills, and I finally found a way to start building it.

That’s what this devlog is. Not a polished studio diary. An honest record of what it looks like when someone who has never built a game decides to build the one they’ve always wanted.

What Changed This Week

I’ve been carrying the idea for this game for most of my life. I finally started writing it down.

What I expected: a game design document. Feature lists, mechanic descriptions, interface sketches.

What actually happened: the act of writing it down forced me to ask why the games I loved fell short. And the answer, every single time, was the same.

They built a game first and tried to add the simulation later.

The simulation was never the primary thing. The player experience was the primary thing, and the simulation was a feature added to serve it. So when the simulation needed to do something the architecture wasn’t designed for — when the Great People mechanic needed a city’s entire philosophical history threaded through the code, when the automation needed to run identically whether a human was playing or not — the foundation couldn’t hold it.

The insight sounds simple. It took me fifty years to see it clearly enough to act on it:

If you want a world that runs on its own, you have to build that first. The player interface is what you add on top.

Not a game with automation. An automated storytelling system that a player can influence. Those are not the same thing. That distinction is the foundation of everything.

What I’m Building

A generational civilization simulation. Hunter-gatherers to spacefaring — not as a tech tree you climb, but as an emergent consequence of what your people actually learned, discovered, and passed down.

Knowledge lives in individuals. Joe knows how to plant a seed because he figured it out — not because the civilization unlocked Agriculture. When Joe teaches Mary, she learns it. When Joe dies, what he knew either survived in the people he taught or it didn’t. An age doesn’t turn because a timer expired. It turns because enough people learned enough things and the world became something different.

Citizens are not actors in the simulation. They are the simulation. Everything above them — village identity, civilization history, age transitions, legendary figures — is the accumulated consequence of millions of individual moments. The village doesn’t have a personality. It has the aggregate of every interaction that happened inside it. The world doesn’t have a history. It has the record of what the villages became because of what the citizens did.

The player comes in and puts their hand on the wheel. They can nudge any village they can reach. They can influence. They cannot command. The world passes their influence down through its own logic and responds according to who these people actually are. The gap between what the player tries to do and what actually happens is where the most interesting stories live.

A Thing That Happened in the Design Session

I was working through the interaction logic this week — what actually happens when two citizens are near each other. Joe is hungry. Mary sees it. What does she do?

I started to write the answer in system terms. Empathy check, relationship modifier, resource calculation.

And then I stopped. Because I realized I was about to do the thing I was trying not to do. I was about to build a decision tree that modeled the output of human behavior without asking what was actually true about the underlying dynamic.

So instead I just asked: what is actually true about that moment?

Joe is hungry. Mary sees it. Mary doesn’t know Joe. She’s a generous person. She just found berries. She might share. She might point him toward where she found them. She might not notice at all.

Now change one thing. Mary knows Joe. She resents him. She has berries. Now she might ignore him. She might taunt him. She might — if she’s clever and the resentment goes deep enough — tell him there’s food in a direction where she knows there isn’t. Or worse, where something dangerous is.

The logic layer doesn’t evaluate Mary’s intent. It records what she did and what happened. The history carries the truth. If Joe dies because Mary sent him toward a wolf den, that’s not a death event the system generated. That’s a murder Mary committed. It’s in the message history. It’s in her reputation. Everyone who knew Joe now has a reason to feel something about Mary. His children grow up without a father.

Nobody scripted that. Nobody authored it. It came entirely from who Mary is, who Joe is, and the history between them.

The actors are the story. Not the backdrop. The story.

That’s when the architecture became obvious. You don’t build a decision system. You build a faithful translation of character into consequence, and you let the simulation carry it forward honestly.

I also realized something else in that moment. The way that design session went — slowing down instead of jumping to code, asking what was actually true instead of what was convenient to model — that’s not how game systems usually get designed. Most design starts with what the system needs to do. This one started with what was true about two people standing near each other.

That’s a completely different starting point. And it leads somewhere completely different.

Where This Goes

This devlog is going to document the build from the ground up.

Right now there’s no code. There’s a design document that grew into an architecture that became a simulation engine specification in the space of one week. There are eight design laws and a three-layer architecture and an interaction model I’m genuinely proud of. There’s a vision that’s been fifty years in the making and a foundation built specifically to carry it.

Next comes code. The Actor object. The decision engine. Joe and Mary in a test harness, making decisions driven entirely by who they are.

I’m an EMC Engineer, not a game developer. I’m learning Unity and modern C# as I go. I’m using AI as a collaborator — not to write the game for me, but to help me understand enough to build it myself. Some of what I’m figuring out will be obvious to experienced developers. Some of the design thinking might be interesting to anyone. I’m not going to pretend to expertise I don’t have.

What I do have is fifty years of knowing exactly what I wanted and not being able to find it. And a week of work that suggests it might actually be buildable.

I don’t know exactly how long this takes. I know it’s worth doing. And I know the thinking that’s gone into the design is unusual enough that documenting it honestly might be useful to someone — whether you’re a developer who’s felt the same failure modes I described, or someone who just finds the question interesting: what does it actually mean to build a world?

The anthill doesn’t care that you’re watching. But it’s worth watching.

— Week one. No screenshots yet. Just the foundation. —

Next: The Actor object. Joe and Mary get born.

If this resonated with you — a subscriber means more than you know.