Here's a weird thing that keeps happening. Every time I read a physicist explaining how the universe works at the bottom, I get déjà vu — not from other physics, but from work. From distributed systems. From game engines. From the specific, unglamorous tricks you reach for when you have a big system and not enough compute.
Not in a "wow, the universe sure is complicated, and so is my codebase" way. That comparison is cheap — complicated things resemble other complicated things all the time. This is more specific. Sharding. Level of detail. Lazy evaluation. Garbage collection. These are named optimizations with precise definitions, invented to solve one problem: making a large simulation run on finite hardware. And they keep showing up in descriptions of physical law.
So here's the plan. First I'll make the case as strongly as I can. Then — because the case has real objections, and the objections are more interesting than the applause — I'll make the counter-case as strongly as I can. What's left standing at the end is worth having either way.
The layers
Physics has a stack:
- Quantum mechanics
- Atomic structure
- Molecular chemistry
- Biology
- Cognition
Software has a stack:
- Transistors
- Logic gates
- Operating system
- Runtime
- Application
graph LR
subgraph physics["Physics stack"]
Q[Quantum] --> A[Atomic] --> M[Molecular] --> B[Biological] --> C[Cognitive]
end
subgraph software["Software stack"]
T[Transistors] --> G[Logic gates] --> O[Operating system] --> R[Runtime] --> AP[Application]
end
Q -.-> T
A -.-> G
M -.-> O
B -.-> R
C -.-> AP
Neither stack requires a layer to know how the layer below it works. You don't need quantum field theory to do chemistry, the same way your web app doesn't need transistor physics. This is abstraction — and it wasn't a property the universe was obligated to have. A universe could have been an undifferentiated mess where everything depends on everything at every scale. Ours is layered cleanly, the way you'd layer a system if you wanted each part buildable and testable on its own.
Level of detail is built into the laws
In a game engine, level of detail is a hack. The mountain on the horizon gets a low-poly mesh; full geometry only loads when the player gets close. It saves enormous compute, and it's an approximation — get the transition wrong and the player sees the seams.
Physics has the same mechanism with one difference: it isn't an approximation.
Newton's shell theorem says the gravity of a spherically symmetric body, viewed from outside, is exactly that of a single point holding all its mass. General relativity has the same property (Birkhoff's theorem). The center-of-mass theorem says a system of 10^50 particles moves, under external forces, as one point. This is why NASA can fly a spacecraft for a decade and hit a target the size of a parking lot without simulating a single atom of Jupiter. The universe hands you the cheap aggregate, and the cheap aggregate is correct. We bolt LOD onto our engines and pay for it in glitches; the laws come pre-aggregated.
Now, the honest footnote: a mathematician will point out that the shell theorem isn't an added feature — it falls out of the inverse-square law, which falls out of flux conservation in three-dimensional space. Exact aggregation is forced by geometry plus the linearity of the laws. Fair. But that relocates the mystery rather than dissolving it: why are the laws linear, local, and symmetric enough for this to work everywhere? Nothing required that either. The suspicious thing was never the theorem — it's the design constraints the theorem falls out of.
The extreme case is almost funny either way: the no-hair theorem says a black hole — the densest object there is, formed from arbitrarily complex matter — exposes exactly three properties to the outside: mass, charge, spin. A class with all fields private and three getters.
The universe is sharded
The speed of light gets described as a cosmic speed limit, which makes it sound like a traffic rule. Here's a better frame: in Planck units, the speed of light is one Planck length per Planck time — one cell per tick. Cellular automata researchers have used exactly this term for decades: in Conway's Game of Life, the fastest any influence can spread is one cell per generation, and the literature literally calls it the speed of light.
The speed of light isn't the universe's latency. It behaves like the universe's clock speed.
(While we're here: clocks run measurably slower near dense mass. Frame rates drop in the computationally heavy parts of the scene. I'm just noting it.)
A bounded propagation rate has a consequence every distributed-systems engineer will recognize: regions far enough apart cannot interact at all. Two events outside each other's light cones can't affect each other — no locks needed, no race conditions possible. The universe partitions naturally into shards. The solar system can be computed to extraordinary precision knowing nothing about Alpha Centauri except a few aggregate values. Cross-shard traffic is tiny, read-only, and stale: look at Andromeda and you're reading state from 2.5 million years ago, because that's when the packet was sent. Eventual consistency, literally. And accelerating expansion keeps pushing distant shards past the cosmic event horizon, after which they can never send us another byte — partitions permanently retired from the working set.
But I owe you the famous exception, because it's not small: entanglement. Measure one of two entangled particles and the outcomes correlate across any distance, instantly — and Bell's theorem proves those correlations can't come from pre-shared state. In my own metaphor, that's cross-shard consistency without messages, which should be impossible. The no-communication theorem saves the sharding story's practical core — entanglement can't carry a signal, so shards still can't talk — but the cleanest quantum phenomenon we know is aggressively non-local. The partitioning is real, and so is the one thing that ignores it. Both facts stay on the table.
Lazy evaluation — and its problem
In quantum mechanics, a particle doesn't show a definite state until it's measured — and "measured" means any interaction, not just a physicist looking. Before that, it's a spread of probabilities. The moment something needs the value, the value resolves.
Software has a name for computing values only when something reads them: lazy evaluation. Game engines don't render the far side of the mountain. Databases don't materialize views nobody queries. Computing everything, everywhere, all the time, whether or not anyone's looking, is the most wasteful possible design. A universe that resolves definite states at the point of observation looks exactly like render-on-demand.
Here's the problem, and it's a real one: the unobserved part is the expensive part. Simulating a quantum state classically costs exponentially more as the system grows — a few hundred entangled particles exceed any conceivable classical computer. That's the entire reason quantum computers are interesting. If you were designing physics to save compute, quantum superposition is the last thing you'd implement. The "collapse saves work" reading is also interpretation-dependent — in many-worlds there's no collapse at all, just the wavefunction grinding on.
So this correspondence, the one that launched a thousand YouTube videos, cuts both ways: the interface looks like lazy evaluation, but the implementation — if it's classical — would be the most expensive in the building. Either the host isn't classical, or this row belongs in the "against" column. I'll keep it in both.
(One quantum behavior survives as pure comedy regardless: particles occasionally pass through barriers they lack the energy to cross. We call it tunneling. Speedrunners call it clipping through walls, and it happens for the same structural reason — sample position probabilistically rather than continuously, and sometimes you're just on the other side.)
Every electron is an instance of the same class
All 10^80 electrons in the observable universe are exactly identical. Same mass, same charge, same spin, everywhere, always. Not similar the way two handmade things are similar — identical the way two instances of a class are identical, because there's one definition and everything else is a reference to it. Handbuilt things vary. Instantiated things don't. John Wheeler once called Feynman with the idea that every electron is identical because there's only one electron, bouncing forward and backward through time. The serious version is nearly as strange: the universe behaves as if "electron" is defined once, and reality holds 10^80 pointers to the spec.
You can move a quantum state, but you can't copy it
The no-cloning theorem: it is physically impossible to copy an unknown quantum state. Not hard — forbidden by the structure of quantum mechanics. And when quantum teleportation transfers a state between particles, the original is necessarily destroyed. That's not copy semantics. That's move semantics. The universe's most fundamental data type is non-copyable, transfer-only — unique ownership, enforced by the laws themselves. Notably, nothing about our hardware forced us to invent move semantics; it was a language-design choice about correctness. The universe made the same choice at the bottom.
Storage scales with surface area
The Bekenstein bound says the maximum information a region of space can contain is proportional to its surface area — not its volume. Double a sphere's radius and capacity goes up 4x, not 8x. Physically this is bizarre: why would a 3D room's capacity be set by its 2D walls? 't Hooft and Susskind developed this into the holographic principle — the universe's information may live on boundaries, with the 3D interior as the projection. A black hole saturates the bound exactly: its entropy is its horizon area in Planck units, divided by four.
I'll flag honestly that this one breaks the analogy rather than confirming it — our storage doesn't scale with surface area. But it breaks in the direction of "reality is rendered from lower-dimensional data," which is not the direction that should reassure you.
Black holes are the garbage collector
A garbage collector defines garbage as memory nothing can reach anymore. Once something crosses an event horizon, no reference from the rest of the universe can touch it — not light, not causality, nothing. That's not "like" unreachability; it satisfies the definition. The rest of the lifecycle follows:
- Collection — the object is swept from the observable working set
- Compaction — internal structure is discarded; per no-hair, arbitrarily complex objects compact to the same three fields
- Deallocation — Hawking radiation returns the memory to the heap as thermal energy over ~10^67 years. Incremental GC; no stop-the-world pause.
And the black hole information paradox — forty years of theoretical physics — is literally an argument about whether the garbage collector is allowed to delete data. Quantum mechanics says information can never be destroyed (unitarity: no-delete semantics). Black holes looked like the one place deletion happened. The emerging consensus — information survives, scrambled on the horizon — amounts to: the GC serializes before it frees.
One more, from ordinary thermodynamics: Landauer's principle says erasing a single bit has a minimum energy cost (kT ln 2) — experimentally verified. Deleting data in this universe is a metered operation with a physical price.
The scorecard — both columns
The hits:
| Physics | Software |
|---|---|
| Speed of light (1 Planck length / Planck time) | Clock speed — one cell per tick |
| Light cones / causal separation | Shard boundaries — no locks needed |
| Shell theorem / no-hair theorem | Aggregation / encapsulation |
| Identical particles | Instances of one class |
| No-cloning theorem | Move semantics |
| Landauer's principle | Metered deletes |
| Unitarity | No-delete semantics |
| Conservation laws | Invariants |
And — because a scorecard that only counts hits is a sales deck, not an argument — the misses:
| Physics | Why it doesn't fit |
|---|---|
| Quantum superposition | Exponentially expensive to simulate classically — the opposite of a compute-saving trick |
| Entanglement | Non-local correlations across shard boundaries |
| Lorentz invariance | A grid picks a preferred frame; experiments find none, to extreme precision — no evidence of an actual lattice |
| The Standard Model's ~19 free parameters | Config values nobody would ship — arbitrary, unexplained, underived |
| Dark matter & dark energy | 95% of the system unaccounted for |
The hits are specific and numerous. So are the misses. Hold both.
The strongest objection
Here's the argument I can't fully dismiss, so it gets its own section instead of a footnote.
Our computers are made of physics. Signals in our hardware are bound by the speed of light — that's why we invented sharding and fret about latency. Energy is scarce — that's why we invented lazy evaluation and LOD. Our entire notion of "efficient computation" was dictated by the physics we compute inside. So of course our optimizations mirror physical law: the causality runs from the universe to our engineering, not the other way. Under this reading, the scorecard doesn't reveal a simulator's fingerprints. It reveals that we're fish admiring how much the ocean resembles water.
This objection cleanly explains the locality cluster — clock speed, shards, aggregation. Those were forced on us.
But it explains less than everything. Nothing about our hardware forced move semantics — that was a correctness choice, and the universe enforces it at the bottom. Nothing forced unitarity's no-delete rule, or a metered per-bit cost for erasure, or storage that scales with boundary area — our systems have none of those properties. The rows that survive the fish-in-water objection are, interestingly, all the information rows: the universe tracks, conserves, prices, and refuses to duplicate information as if information — not matter — were the managed resource.
What actually survives
Strip away everything the objections claim, and you're left with a thesis that needs no simulator and is arguably stranger:
Information appears to be physical. Erasing it costs energy (Landauer). Destroying it is forbidden (unitarity). Storing it has a geometric capacity limit (Bekenstein). Copying it can be impossible (no-cloning). This is Wheeler's "it from bit," and it's not a fringe position — it's a live research program: physics and computation may be the same subject, approached from opposite ends.
The simulation hypothesis is one possible reading of that fact. It's the vivid one. It's also — as a famous jailbreaker of other people's systems put it, in a quote I initially wanted to use as decoration until I noticed it was aimed at me:
"I'm interested only in simulation theory as far as it gives me power over nature. If it's totally unfalsifiable, then who cares?" — George Hotz
That's the right challenge. So, concretely: what would move this from vibes to physics? A detected anisotropy from an underlying lattice. A Lorentz violation at high energy. A measured deviation suggesting finite precision in the constants. People have looked for all three. So far: nothing — which is evidence, and it counts against the grid.
Am I just doing what everyone else did?
Every era describes the universe with its most impressive technology. Newton's universe ran like a clock. The 1800s reached for steam. The twentieth century compared brains to switchboards, then computers. Now the people who build software look up and see software. It would be a little on the nose.
And I'll concede more than most versions of this essay do: the clockwork metaphor wasn't a single loose analogy that collapsed on contact. It sharpened for two hundred years — Laplace, Lagrange, celestial mechanics of astonishing precision — before quantum mechanics ended it. Metaphors built from your best technology can be productive for centuries and still be wrong about the substrate.
So the honest position isn't "this time the metaphor is true." It's: the parts of the correspondence that were forced by our hardware being embedded in physics prove nothing. The parts that weren't — the information rows — are pointing at something real, and "it from bit" is that something whether or not anyone is running the process.
So, coincidence?
The safe claim, the one I can defend all day: computation and physics keep turning out to be the same subject, and the universe manages information the way engineered systems manage their scarcest resource.
The unsafe claim — that someone built it this way — is unfalsifiable today, and I've tried to be honest about which rows of the scorecard actually support it (fewer than the fun version of this essay pretends).
But I'll admit which way I lean, and why: when I audit a system I didn't build and find unreachability semantics, no-delete guarantees, metered writes, unique ownership, and per-region storage quotas, I don't usually conclude the invariants assembled themselves. I conclude somebody cared about resource management. Maybe the universe is the exception. Maybe it's the first draft of the pattern, and our software is the copy. I can't prove either. But only one of those readings explains why the audit keeps finding policy.
Prior art, because this isn't a new stoner thought — it has a literature: Konrad Zuse's Calculating Space (1969) proposed the universe is a cellular automaton; John Wheeler's "it from bit" put information at the bottom of physics; Edward Fredkin built digital physics into a program; Seth Lloyd argued the universe is a quantum computer — which, note, would answer the superposition objection; Stephen Wolfram is still at it; and Nick Bostrom's simulation argument (2003) supplied the probability math everyone else paraphrases.