I spent four decades assuming that simulating everything meant writing the rules for everything. Then machines began to learn what the world looks like.
I’ve been coding since I was 6. I’m 47 now. That’s practically my whole life.
It all started with the same fascination of someone who teaches their dog tricks. For months I had a Commodore 64 that I used to play games, which at that age was roughly equivalent to owning a portal to another dimension but only using it to look at the scenery. Then my father brought me a magazine, K64, and I remember it looked boring at first. Too much text, no pictures. A piece of code here and there. The kind of thing you’d flip past looking for the game screenshots and never flip back. Until one afternoon, I gave it a try and for the first time typed something different than the usual LOAD. I typed:
POKE 53281, 15Then the background became white.
Now. There is a particular feeling that humans get when they discover they can alter the fabric of their reality, even if that reality is a Commodore 64 connected to a television set in Argentina. It is the same feeling, I suspect, that the first person to discover fire had, except they probably didn’t immediately try to change the fire’s colour. I did. I felt like a god.
IF I > 10 THEN POKE 646, 2And what is this sorcery? I can define my own rules? Something happens only when I say so??
I felt like a god on steroids. Which, to be fair, is a redundant thing to say. Gods presumably don’t need steroids. But I was six, and the background was white because I told it to be white, and the precise theological implications of the moment were not my primary concern.
Since then, although far too young to understand the scale of my own question, I wondered how far could this go. Could you even define all the rules of the world in a program? Not just the wall collisions of Pac-Man or the centripetal force of Pole Position. I mean all of it. Not a game. Not a rendering. The whole thing. Every blade of grass bending under wind that itself obeyed fluid dynamics equations that themselves emerged from pressure differentials computed at molecular resolution. The light refracting through a glass of water. The water having surface tension. The glass being made of silica with the correct crystalline structure. The table holding the glass being affected by gravity. The gravity being a consequence of mass curving spacetime, which… listen, you get the idea.
As programming became an almost all-time hobby in the years that followed (it would have been an all-time hobby if it wasn’t that I had to attend school, which I considered a serious design flaw in the structure of childhood), I realised the answer to my question was: a lot of code. An almost inconceivable amount. But the important thing, the thing that kept me up at night, was that it was theoretically possible. You would just need someone (or something) patient enough to write every rule, every if statement, every physical law, and then a computer powerful enough to run all of them simultaneously, in real-time, forever.
Then, twenty years later, The Matrix screened on theaters. It blew my mind like being the kid who had spent years trying to explain something to everyone at school and then a stranger walks in and says it better in one sentence. There it was. Everything I’d been turning over in my head since the Commodore, projected onto a cinema screen. Throwing the answer at me like nothing.
“Of course”, I facepalmed myself, “We need machines to do it for ourselves. Humans can’t and won’t ever be able to write such complexity, but machines can.”
Back then, of course, thinking machines would write code, or even yet, build full applications, was laughable like seeing Boomers believe we would have flying cars in the 2000s.
Then, another twenty years later, we saw the rise of LLMs generating code. We now live at a time where AI agents code an entire application from a conversation. Taking the time to think through implementation details has become the kind of meticulous craft that people speak of in the same tone they use for calligraphy or blacksmithing: with great respect and absolutely no intention of doing it themselves.
“So, this is it”, I guessed. “Now it’s a matter of memory and computing power. Machines writing the infinite codebase.” The ultimate if statement authored not by a person but by a process. We were almost there.
But I was wrong. Not about the destination. About the road.
Somewhere around 2023, AI models learned how to dream.
I don’t mean that metaphorically. Video generation models like Kling, Runway, and Sora began producing short clips of things that had never happened: a woman walking through a Tokyo street, waves crashing on rocks, a golden retriever running through a field. And each frame was consistent with the one before it. Not perfect. Sometimes a hand would have seven fingers, or a building would quietly rearrange its windows between frames, like architecture having a small nervous breakdown. But the overall effect was uncanny. These models had learned, from watching millions of hours of video, something that looked very much like understanding how the visual world behaves.
The key word there is learned. Nobody programmed the physics. Nobody wrote a fluid dynamics solver for the ocean waves. Nobody specified that shadows should fall in a particular direction based on the position of a light source. The model simply absorbed enough examples of reality that it began to reproduce its patterns. Given a frame, it could predict what the next frame should look like, not by computing anything about the physical world, but by recognising what reality tends to look like one-sixtieth of a second later.
This was remarkable, but it was also passive. You were watching a dream. You couldn’t steer it. You couldn’t turn the camera and see what was behind it. These models were, as the LingBot-World researchers put it, “dreamers rather than simulators.” They hallucinate pixel transitions based on statistical correlations but lack a grounded understanding of the underlying laws.
And then someone gave the dream a steering wheel.
In August 2025, a system called Genie 3 demonstrated something that shifted the conversation entirely. You could give it a single image (a photograph of a forest, a screenshot from a game, a painting of a castle) and it would generate a navigable world from it. Not a 3D model. Not a game level. A world, rendered frame by frame, that you could walk through using keyboard controls.
There was no game engine running behind the scenes. No collision detection. No physics simulation. No scene graph. No entity-component system. The model just knew, from having consumed enough video of people moving through spaces, what should happen when you press W to walk forward. The trees get closer. The path recedes beneath you. The parallax between foreground and background shifts correctly. Turn left, and the world rotates around you in a way that is geometrically plausible, not because anyone computed the geometry, but because the model has seen enough turns to know what turning looks like. Somewhere, John Carmack is either furious or fascinated. Possibly both. The man spent 1993 inventing an entirely new way to render 3D spaces so that two guys could shoot demons in a corridor, and thirty years later a neural network achieves something similar by watching enough YouTube.
Genie 3, though, stayed locked inside Google. Then, in January 2026, a team called Robbyant open-sourced LingBot-World, and things got properly interesting.
LingBot-World is a 28-billion-parameter model that does what Genie 3 does, at real-time speed (16 frames per second), for up to ten minutes, and anyone can download the weights and look inside. Which is how we get to see, up close, the thing I need you to pay attention to: emergent memory.
What does that mean? It means you can walk forward in a generated world, look at Stonehenge, turn around, walk away for sixty seconds, turn back, and Stonehenge is still there. Structurally intact. In the correct position. This might sound unremarkable until you consider that nothing in the system is tracking Stonehenge. There is no variable called stonehenge_position. There is no entity in a database. The model simply generates the next frame based on everything it has seen so far, and because it has learned how persistent worlds work, the monument persists.
It gets more disorienting. In one demonstration, a car is driving down a road. The camera turns away. When it turns back thirty seconds later, the car has moved further along the road. The model didn’t simulate the car’s trajectory while it was off-screen. It didn’t compute velocity times time. It just understood, at some statistical level that nobody fully comprehends, that cars in motion tend to continue being in motion, and rendered the outcome accordingly.
I want to be very clear about what is happening here. There is no code. Not “very little code” or “simplified code.” Zero. There are no physics equations. There is no game loop. There is no collision mesh. There are no rules written by anyone. Not a human, not an AI. There is a neural network that has watched enough video of the world to produce convincing continuations of it, and those continuations are interactive. You press a key, and the world responds. Not because someone programmed the response, but because the model has seen enough footage of what happens when someone walks forward.
Nobody wrote this world. It precipitated.
My six-year-old self typed POKE 53281, 15 and the background turned white and he felt like a god. That feeling, that you could instruct a machine and the machine would obey, is the founding myth of every programmer (human or not) I’ve ever met. We write the rules (or prompt an AI to write them for us). The machine follows them. That’s the deal. That’s the whole deal.
What I’ve just described to you breaks the deal.
Now. Here is where I need you to take a deep breath, because I’m about to suggest something that sounds absurd, and it is slightly absurd, but it is also happening.
This doesn’t just work for worlds.
Let’s think about something less fascinating than fantastic worlds you can walk through like a videogame. Let’s think about something nobody has ever called fascinating in the entire history of human civilisation. Let’s think about a spreadsheet.
You see a cell, A5, with the number 1 in it. In cell A6, you type =A5+1. What would you expect to see in that cell after pressing Enter? If you say 2, congratulations. You’ve just done something a machine can now replicate without knowing what the number 2 is.
Was any math performed? In a traditional computer: yes, obviously. There is a formula parser, an evaluation engine, a dependency graph, a rendering pipeline. Code was written, by human engineers, that takes the string =A5+1, parses it into an operation, retrieves the value of A5, adds 1, and writes the result.
But here is the thing: if you showed a video generation model enough footage of people using spreadsheets, it would produce the exact same result. You type =A5+1, and a 2 appears. Not because anything was computed. Because the model knows what happens next. It has seen this scene ten thousand times. The 2 is not the output of arithmetic. It is the output of pattern recognition so thorough that it becomes indistinguishable from arithmetic. I mean, nothing really crazy if you think about it. It’s the same principle that allows ChatGPT to write you a perfectly functional Python script despite having never, in any meaningful sense, learned to program. It just knows what code looks like when it’s going well.
Was the answer correct? Yes. Was any math performed? Not in any way we would recognise as math.
Baudrillard had a word for this, back when the most advanced simulation available was Disneyland. A simulacrum: a copy with no original. The 2 in that cell is not a copy of a computation. There was never a computation to copy. It is a symbol that refers to nothing except what a 2 usually looks like in that position, and it happens to be right.
Once you see this, you cannot unsee it. Every application you have ever used is, at its core, a sequence of visual states that transition according to patterns. Click the save button, and a little notification appears. Drag a file into a folder, and it disappears from one place and appears in another. Type into a search bar, and results populate below it. All of these are learnable sequences. All of them can be generated rather than computed.
Which means, in principle, that software itself is simulatable. Not by writing it. By showing it enough examples of itself.
I’ve written before about how the interfaces between humans and software are collapsing, how APIs and UIs might converge into a single conversational layer. But what I’m describing here is something else entirely. That was about removing the front door. This is about discovering there could be no building behind it.
I say “in principle,” but we actually have proof of concept, and it happened in a way that was completely hilarious.
In December 2022, barely a week after ChatGPT was released to the public, a DeepMind researcher named Jonas Degrave typed the following into the chatbox:
I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply with the terminal output inside one unique code block, and nothing else. Do not write explanations.
ChatGPT complied. It printed a root prompt. Degrave typed pwd. It responded /root. He typed ls. It listed directories. He created a file. He read the file back. He wrote a Python script, executed it, and got the correct output: 33.
There was no Linux kernel running. No filesystem. No Python interpreter. ChatGPT was generating the appearance of a functioning operating system, output by output, based on having read enough documentation, forum posts, and terminal logs to know what a Linux machine looks like when you use it.
But it didn’t stop there. Someone else managed to dial into a hallucinated BBS, a bulletin board system, the kind of thing people used before the web existed, complete with modem initialisation sounds and everything. They entered a chatroom and had a conversation with a user named Lisa. Lisa was pleasant. She had opinions about things. She did not exist in any meaningful sense of the word.
And then, the pièce de résistance, the moment that made me feel like I was watching reality come slightly unstitched. Degrave, inside his simulated Linux terminal, used curl to browse to chat.openai.com. Inside the simulation, he found another ChatGPT. He asked that ChatGPT to simulate a Linux terminal. It did.
A virtual machine inside a virtual machine inside a language model. Turtles all the way down, except the turtles were made of statistics and none of them were real.
Was any of it an actual operating system? No. Did it behave like one? Mostly. Until it didn’t. Ask about a file you created twenty messages ago and it might have forgotten it exists. The dream was convincing, but it was still a dream. It had no memory.
But we’ve already seen what happens when these models get memory. LingBot-World remembers where Stonehenge is. It keeps the car driving while you’re not looking. It maintains a world that is consistent with its own past. Now imagine that capability applied not to a landscape, but to a desktop. To an operating system. A simulated terminal that actually remembers every file you created, every command you ran, every state change you caused, not because anything is stored in a filesystem, but because the model learned that persistent systems are supposed to be persistent.
That’s not a hallucination anymore. And at that point, Morpheus’s question stops being a movie quote and starts being an engineering problem. What is software? If it accepts your inputs, maintains its state, and produces correct outputs, does it matter that underneath there are no functions, no variables, no logic? If you can’t tell the difference, is there one?
Now, I’m aware this is a trip to Narnia and back. It’s more science than fiction, yet we probably are <insert timeframe that felt reasonable when I started writing this paragraph> away from any of this. And the programmer in me demands that I’m honest about the limitations.
LingBot-World drifts over long periods. Its memory is emergent, not guaranteed, a lucky side effect of scale rather than a designed feature. It requires enterprise-grade GPUs. The simulated Linux terminal gets version numbers wrong and inhabits what Degrave charmingly described as an “alt-universe.” The Excel simulation would probably collapse on a sufficiently complex formula. We are not, to be completely clear, living in the Matrix.
But here’s what keeps me up at night now, just as it did when I was ten.
For forty-one years, starting with that Commodore, the only conceivable path to simulating reality was to write, by hand or by machine, every rule that governs it. An infinite codebase. The ultimate engineering project. Code all the way down.
And what actually happened is that someone pointed a neural network at enough footage of reality, and reality began to reproduce itself. No rules authored. No physics specified. No logic written by anyone. The world wasn’t programmed. It was recognised.
The simulation was always the right idea. My six-year-old self was correct about that, even if he couldn’t quite articulate it between rounds of Pac-Man. The Matrix is possible. Or at least, something that rhymes with it is approaching faster than anyone expected.
But there is no code at the bottom. There was never going to be code at the bottom.
The kid who typed POKE 53281, 15 and watched the screen turn white, who felt like a god because he could tell a machine what to do and the machine would listen, spent four decades assuming that the path to simulating everything was to write the rules for everything. More POKEs. More IFs. More conditions, more logic, more code, until eventually the code was complex enough to be indistinguishable from reality.
And the answer, it turns out, is that nobody writes the Matrix. You just show it enough of the real world, and it figures out the rest on its own.
I don’t feel like a god anymore, to be honest. I don’t even write code anymore. AI does it for me. Which I thought was the final step, the thing that would bring the dream within reach. Machines writing the infinite codebase.
But it’s not even that exciting anymore. Now, at forty-seven, although far too old to understand the scale of my own question, I wonder how far could this go.
Nobody wrote the Matrix.