Programs That Write Worlds – From Grids to Quantum Fields

Toy Universes on a Grid

You know, people often ask me, “Dick, what is the world really made of?” And they expect me to say atoms, or quarks, or vibrating strings, or fields. And sure, those are the actors on the stage. But sometimes I wonder if we’re asking the wrong question. Maybe we shouldn’t ask what it’s made of, but how it runs.

I was looking at these things called cellular automata. Stephen Wolfram and others have been playing with them for years. Imagine a piece of graph paper. Just a simple grid. You color in a square, and then you have a rule for the next row. Maybe the rule is: “If the square above is black, and its neighbor is white, make this one black.” Something simple. A child could do it. You could do it with a pencil and patience.

You’d think, if the rule is simple, the pattern you get must be simple, right? Maybe a checkerboard, or a solid line, or a repeating stripe. And sometimes, that’s what you get. Boring. But then you tweak the rule just a little bit—change a “yes” to a “no” in your rulebook—and suddenly, wham! You get these triangles, these intricate, jagged patterns that look like seashells or mountain ranges. You get complexity.

There are even rules—like the famous Rule 30—that produce patterns so wild, so random-looking, that you can’t tell them apart from pure noise. But there’s no noise! It’s completely deterministic. It’s just a simple rule, repeating over and over.

And here’s the kicker: you can’t predict it. You can’t look at the rule and say, “Oh, row one billion will look like a face.” No! The only way to know what happens is to actually do it. You have to run the program. They call this computational irreducibility. It means there’s no shortcut. The universe doesn’t skip steps. It calculates every single moment. If you want to know the future, you have to live through the present.

It reminds me of the “control problem” in these systems. You want to design something—a game, a simulation, a universe—but if you let emergence take the wheel, you lose control. You plant a seed, but you don’t know if you’ll get a flower or a monster. You have to iterate. Try, fail, tweak, try again. It’s like design by emergence. You build the Lego blocks, but you don’t build the castle. The castle builds itself. Nature doesn’t plan; she just tries everything. She iterates.

So, we have these toy universes where simple rules make complex worlds. And I think, isn’t that what we see out there? Is the universe just a grid of cellular automata running a program we haven’t figured out yet?

Drawing the Code of Particles

Now, let’s jump from graph paper to the real stuff. Quantum mechanics. When I was working on quantum electrodynamics—QED—I had a similar problem. The math was a mess. Pages and pages of algebra just to figure out what an electron does when it meets a photon. It was a nightmare.

So I started drawing pictures. Little diagrams. An electron goes along—that’s a straight line. A photon comes in—that’s a wavy line. They meet at a point, a vertex. Bloop! Something happens.

People thought I was just doodling, but those Feynman diagrams are the code. Each line, each vertex, it corresponds to a specific piece of math, a specific rule. You stitch them together, and you can calculate the probability of anything happening. It’s like the cellular automata, but instead of a grid, the “board” is spacetime itself, and the “rules” are the interactions between fields.

And just like the grid, you have to sum up all the possibilities. In my path integral formulation, a particle doesn’t just take one path from A to B. It takes every possible path. It goes to the moon and back. It goes in a loop. It goes straight. It goes backwards in time! And each path has a little “score,” a phase, like a clock hand spinning.

This is where that beautiful Euler’s formula comes in. You know, the one with the exponentials and the imaginary numbers: $e^{i\theta} = \cos(\theta) + i\sin(\theta)$. It connects growth and rotation. In quantum mechanics, it tells us how these phases rotate. It turns the “impossible” math of imaginary numbers into the geometry of rotation.

When you add up all these paths, most of the crazy ones cancel each other out—the arrows point in opposite directions and sum to zero. The only path that survives, the one we see as “classical” motion, is just the path where the phases line up. The “impossible” paths are part of the calculation! The universe is running all the bad code, all the bugs, all the glitches, just to find the one line of code that works.

It’s surprisingly similar to Kepler’s equation. Back in the 1600s, Kepler found that planets sweep out equal areas in equal times. But to calculate where a planet is at a specific time, he had to solve this nasty equation: $M = E - e \sin(E)$. It looks innocent, but you can’t solve it with algebra. You can’t just say “E equals…” You have to guess. You have to iterate. You have to run a little numerical program. Kepler didn’t have a computer, so he was the computer. Nature is doing the same thing. It’s solving a massive, transcendental equation by trying every possibility at once.

And look at entropy. We say entropy always increases. Why? Is it a law? A policeman saying “You must get messier”? No! It’s just counting. It’s configuration counting. There are simply more ways to be messy than to be tidy.

Imagine a gas. The molecules are bouncing around. If they’re all in one corner, that’s a special, rare arrangement. But let them go, and they explore the room. They explore all the possible configurations. And since there are gazillions more arrangements where the gas is spread out, that’s what we see. It’s probabilistic. The “arrow of time” is just the universe shuffling the deck, moving from unlikely states to likely ones. It’s a statistical program.

Even black holes play this game. Stephen Hawking showed us that. Hawking radiation. Right at the edge, the event horizon, the universe is running a very strange subroutine. Virtual particles pop in and out—borrowing energy from the vacuum. Normally, they pay it back instantly. But at the edge, one falls in, and the other escapes. The black hole pays the debt. It loses mass. It evaporates!

It’s like the universe has a built-in garbage collection mechanism, recycling the code at the boundaries of spacetime. The black hole isn’t just a hole; it’s a computer processing information at the limit of what’s possible.

Is the Universe Really a Program?

So, we have worldlines tracing paths through spacetime. We have diagrams calculating probabilities. We have entropy counting states. It all looks very… computational. A worldline isn’t just a path; it’s a complete history, a curve frozen in the block of spacetime. The apple doesn’t “move”; it just is a long, worm-like shape in four dimensions.

But we have to be careful. When you have a hammer, everything looks like a nail. When you have a computer, everything looks like a program.

In the cellular automata, the grid is rigid. Space and time are discrete steps. Tick, tock, tick, tock. But in physics, as far as we can tell, spacetime is smooth. It’s a continuum. Or is it? Maybe down at the bottom, at the Planck scale, it is a grid. Maybe it is discrete. We don’t know yet.

And there’s a difference in how we read the code. In the toy universe, we set the rules. We are the gods. In the real universe, we are the characters inside the game, trying to figure out the rules by watching the pixels change. We are the Mario brothers trying to reverse-engineer the Nintendo.

We find “pockets of reducibility”—places where we can write a simple equation, like $F=ma$, and it works. We don’t have to run the whole simulation of every atom to predict where a baseball will land. We can cheat. We can compress the data. That’s what science is: finding the compression algorithms for nature’s data stream. We look for the patterns that let us skip the hard work of simulating every particle.

But maybe, just maybe, the universe itself is the ultimate computer. Not a machine made of silicon, but a machine made of possibility. It computes the next moment from the previous one, using rules we are just beginning to glimpse. It sums over histories. It counts configurations. It iterates equations.

It’s a humbling thought. We are just little patterns, emergent phenomena, dancing on the grid, trying to understand the program that writes us. And isn’t that fantastic? The mystery is what keeps us looking. The game isn’t over yet. We’re just getting to the good level.