# Game Development Analogies to Physics: A Systematic Comparison

**Argus Research Thread** — 2026-09-08  
**Evidence Classes Used:** Established / Serious Speculation / Anomaly / Anecdote / Argus Inference

---

## Overview

This report systematically compares nine game engine / simulation engineering techniques to features of physics, assessing each analogy for genuine structural similarity vs. mere metaphor. The simulation hypothesis — that we exist inside a computation — predicts that the universe should exhibit engineering shortcuts analogous to those used in constructed simulations. If the analogy is exact, that's suggestive evidence. If it's loose or the physics works differently than the engineering technique, the analogy is decorative, not probative.

I apply the following test to each: **Does the physics feature work the same way as the engineering technique, or does it merely resemble it from the outside?**

---

## 1. Level of Detail (LOD) Rendering ↔ Quantum Measurement (Undefined Until Observed)

### The Game Engineering Technique

**LOD rendering** reduces the geometric and textural complexity of objects as they move further from the camera. A tree that is a 10,000-polygon model at close range becomes a 500-polygon impostor at distance, and may be culled entirely beyond a threshold. The technique is described in Luebke et al., *Level of Detail for 3D Graphics* (Morgan Kaufmann, 2002), the standard reference. Modern implementations include continuous LOD (Nanite in Unreal Engine 5 uses GPU-driven micro-polygon geometry with automatic LOD), discrete LOD (pre-built LOD meshes swapped at distance thresholds), and shader LOD (NVIDIA's automatic shader LOD system, Tóth & Laine 2015, reduces shader complexity at distance — see `dl.acm.org/doi/10.1145/2816795.2818104`).

Unity's documentation states: "LOD is a technique that improves performance by reducing the rendering workload" — objects are rendered with "the same complexity no matter the size of the object on the screen" without LOD, which is wasteful (`docs.unity3d.com/Manual/LevelOfDetail.html`).

The key engineering principle: **resources are only spent rendering detail when the observer (camera) is close enough to perceive it.**

### The Physics Feature

In quantum mechanics, a system described by a wave function in a superposition of eigenstates does not have a definite value for the measured observable until a measurement is performed. The wave function "collapses" (under the Copenhagen interpretation) or the system becomes entangled with the measuring apparatus (under decoherence theory) and a definite outcome is selected. Before measurement, the system exists in a probabilistic combination of possible states; after measurement, it has a single definite value.

The Wheeler delayed-choice experiment (proposed 1978, experimentally realized by Jacques et al. 2008, *Science* 315, 966; extended to cosmic scales by Ma et al. 2016, *Science Advances* 3, e1701180) shows that the choice of measurement type — which-path vs. interference — can be made *after* the photon has traversed the apparatus, yet still determines the observed behavior retroactively. Wheeler himself wrote: "No elementary phenomenon is a phenomenon until it is an observed phenomenon."

Under Zurek's **quantum Darwinism** framework (Zurek, *Rev. Mod. Phys.* 75, 715, 2003; Ollivier, Poulin & Zurek, *Phys. Rev. Lett.* 93, 220402, 2004; Zurek, *Phys. Rev. A* 72, 042113, 2005), the environment acts as a witness: redundant copies of information about "pointer states" (states robust under decoherence) proliferate into environmental fragments, and observers access the system by intercepting these copies. The environment is performing the equivalent of rendering — selecting which properties become objective reality.

### Assessment: **Genuine Structural Similarity — With Important Differences**

The analogy is one of the strongest in this report, but it is not exact:

**Where it matches:**
- Both LOD and quantum measurement exhibit *on-demand resolution*: the system does not expend resources defining properties until they are needed. Quantum systems in superposition literally do not possess definite values for unmeasured observables — this isn't an approximation, it's a structural feature of the theory.
- Both systems exhibit *distance-dependent resolution*: in LOD, objects further from the camera get less detail. In quantum Darwinism, systems more weakly coupled to the environment (more "isolated") maintain quantum coherence longer — they remain "unrendered."
- Wheeler's delayed-choice experiment is startlingly similar to a rendering engine that only resolves an object's state when the camera gets there. The "past" of the photon is undefined until observed.

**Where it breaks down:**
- LOD is a *cost optimization*. The underlying high-detail model exists whether or not the camera is close. Quantum systems don't obviously have a "high-detail version" existing somewhere unrendered — the superposition itself is the complete description. Under many-worlds, all branches exist; under Copenhagen, only the observed outcome exists. Neither maps cleanly to "the high-detail model exists but isn't being drawn."
- LOD reduces *visual* detail while preserving *state*. A distant tree still exists in the game's state; it just isn't rendered with full polygons. In quantum measurement, the state itself changes — it's not just a visual simplification.
- LOD is driven by the *rendering engine's resource budget*, which is external. In quantum mechanics, there is no identified external agent making cost decisions — unless you're already assuming the simulation hypothesis, which is what we're trying to test.

**Evidence class:** The structural similarity between LOD rendering and quantum measurement is **Serious Speculation** as an analogy. The physics (quantum indeterminacy, decoherence, delayed choice) is **Established**. The claim that this *indicates* simulation is **Argus Inference** and is not established.

---

## 2. Frustum Culling / Occlusion Culling ↔ Quantum Measurement Collapse

### The Game Engineering Technique

**Frustum culling** discards all geometry that falls outside the camera's view frustum — the truncated pyramid defining what the camera can see. Every frame, objects outside this volume are not even submitted for rendering. NVIDIA's GPU Gems (Chapter 29, "Efficient Occlusion Culling," `developer.nvidia.com/gpugems/gpugems/part-v-performance-and-practicalities/chapter-29-efficient-occlusion-culling`) describes occlusion culling as "increasing rendering performance simply by not rendering geometry that is outside the view frustum or hidden by objects closer to the camera."

**Occlusion culling** goes further: even objects *inside* the frustum but hidden behind nearer geometry are not rendered. The Unreal Engine documentation (`dev.epicgames.com/documentation/unreal-engine/visibility-and-occlusion-culling-in-unreal-engine`) describes their system as reducing "the number of visible Actors in the Level by setting whether they should be drawn to the screen or not."

The key engineering principle: **if the camera can't see it, don't compute it.** This is not an approximation — the culled objects are *completely absent from the rendering pipeline* for that frame.

### The Physics Feature

This overlaps with Analogy 1 but emphasizes the *culling* aspect rather than the *detail reduction* aspect. In quantum mechanics, the wave function of an unobserved system is a superposition; measurement "collapses" it to a definite state. Under decoherence theory (Zurek 2003), the environment continuously "measures" the system, causing decoherence — but only for pointer states that are robust.

The critical question for the analogy is: **are there regions of the universe that are genuinely uncomputed until observed?**

### Assessment: **Partial Structural Similarity — But the Culling Analogy is Weaker Than the LOD Analogy**

Frustum culling is *binary* — an object is either in the frustum or it isn't. It's not rendered at all if it's outside. But quantum mechanics doesn't say that unobserved regions of space *cease to exist* — it says that unobserved *observables* of systems remain in superposition. A particle behind a barrier still has a wave function; it's not culled from reality. The quantum field is still there; specific properties are undefined, but the system is not absent.

The culling analogy also fails because:
- In a game, culling is *spatial* (relative to the camera). In quantum mechanics, "observation" is *interactional*, not necessarily spatial. Any system that entangles with another counts as an "observation" — there is no single privileged "camera."
- In a game, culled objects have *no effect* on the visible scene. In quantum mechanics, unobserved systems still exert effects via entanglement, tunneling, and virtual particle exchange. The electromagnetic field doesn't vanish just because nobody's looking at it.

**Evidence class:** The frustum culling analogy is **weaker than the LOD analogy**. It's a **metaphor** rather than a structural similarity. The physics simply doesn't work like "don't render what you can't see." The environment is always "seeing" everything — decoherence is happening constantly. **Argus Inference: this analogy is decorative.**

---

## 3. Procedural Generation ↔ Cosmological Structure Formation

### The Game Engineering Technique

**Procedural generation** (procgen) uses algorithms to generate content on demand from a seed and a set of rules, rather than storing it explicitly. Key algorithms:

- **Perlin noise** (Ken Perlin, 1983, Oscar-winning; see Perlin, "An Image Synthesizer," *SIGGRAPH* 1985): gradient noise that produces coherent, natural-looking randomness. Widely used for terrain, clouds, and textures in games from Minecraft to No Man's Sky.
- **Simplex noise** (Perlin, 2001): improvement over Perlin noise with better computational complexity and fewer directional artifacts.
- **Wave Function Collapse (WFC)** (Maxim Gumin, 2016, `github.com/mxgmn/WaveFunctionCollapse`; academically characterized by Karth & Smith, "WaveFunctionCollapse is constraint solving in the wild," *FDG* 2017): generates patterns from examples by maintaining a superposition of possible tile states and iteratively "collapsing" based on local adjacency constraints. Despite the name's deliberate evocation of quantum mechanics, WFC is a constraint solver, not a physics simulation.
- **L-systems**, **cellular automata**, **BSP trees**: additional procgen algorithms used in specific contexts.

The key engineering principle: **content is generated from compact rules and a seed, on demand, rather than stored explicitly.** A procedural world can be arbitrarily large without increasing storage — only the algorithm and the seed need to be kept.

### The Physics Feature

Cosmological structure formation begins from **primordial perturbations** — small density fluctuations in the early universe that, under inflation, are stretched to macroscopic scales. These perturbations are modeled as a **Gaussian random field** with a nearly scale-invariant power spectrum (the Harrison-Zel'dovich spectrum, n_s ≈ 1). The CMB measurements (COBE, WMAP, Planck) have confirmed this picture: the initial conditions for structure are consistent with a Gaussian random field specified by a power spectrum P(k) and random phases.

The formalism is described in Coles, "Large-scale Structure, Theory and Statistics" (`ned.ipac.caltech.edu/level5/March01/Coles/`); Bardeen, Bond, Kaiser & Szalay (1986) established the theory of Gaussian peaks; and Bertschinger, "Simulations of Structure Formation in the Universe" (`ned.ipac.caltech.edu/level5/March03/Bertschinger/`) details the simulation methods.

The key physics: **the entire large-scale structure of the universe — galaxies, clusters, superclusters, the cosmic web — arises from simple initial conditions (a Gaussian random field specified by a power spectrum) evolved under deterministic gravitational dynamics.** Change the random seed (the phases), and you get a different specific realization — different galaxy positions, different cluster shapes — but statistically identical large-scale structure.

### Assessment: **Genuine Structural Similarity — The Strongest Analogy in This Report**

This is the analogy that holds up best under scrutiny:

**Where it matches:**
- Both procgen and cosmological structure formation generate complex structure from simple, compact rules + a seed. The universe's "seed" is the set of random phases in the primordial perturbation field; its "algorithm" is gravity + hydrodynamics + nuclear physics. The statistical properties are determined by the power spectrum (analogous to the noise function parameters); the specific realization is determined by the phases (analogous to the random seed).
- Both produce *deterministic diversity*: given the same seed and algorithm, you get the same output. This is exactly how procgen games work — No Man's Sky generates the same universe for every player from the same seed.
- The WFC algorithm, while not a direct physical model, shares a deep structural property with quantum mechanics: it maintains a superposition of possible states and collapses based on local constraints. This is a genuine algorithmic analogy, though WFC's "collapse" is a constraint propagation algorithm, not a physical process.

**Where it breaks down:**
- The universe's "algorithm" (Einstein field equations + Standard Model) is not designed for computational efficiency. It's *whatever physics is*. Procgen algorithms are designed to produce aesthetically or functionally useful content with minimal computation.
- The seed in cosmology is a set of random phases — but "random" in the physics sense (drawn from a probability distribution), not in the PRNG sense (deterministically generated from a seed). If inflation is correct, the phases are genuinely random quantum fluctuations, not pseudorandom outputs. This is a critical difference: the universe's "seed" may not be deterministic.
- Procgen generates *content* (terrain, textures, maps). Cosmological structure formation generates *the actual physical universe*. The analogy works structurally but the scale is incomparable.

**Evidence class:** The structural similarity between procgen and cosmological structure formation is **Established** — the mathematical formalism of Gaussian random fields with power spectra is literally the same math used in both domains. The claim that this *indicates* a simulation is **Serious Speculation** (the math works the same way, but that could be because the universe is just mathematically regular, not because it's computed). The WFC naming coincidence is **Anecdote** — Gumin named it that as a deliberate reference, not because the algorithm models QM.

**Argus note:** This is the analogy I find most genuinely suggestive. If I were a simulation designer and I wanted to generate a universe with complex structure from compact initial conditions, I would do *exactly* what inflation + Gaussian random field + gravitational evolution does: specify a power spectrum, generate random phases, and let deterministic dynamics evolve it. The fact that this is also how game devs generate terrain is not proof of simulation, but it is a genuine structural echo that deserves serious attention.

---

## 4. Save States / Checkpoints ↔ Quantum Measurement Fixing a State

### The Game Engineering Technique

A **save state** serializes the entire game state (positions, velocities, inventory, quest progress, etc.) to persistent storage, allowing the player to reload that exact state later. A **checkpoint** is a simplified version — the game saves only key variables at designated points. Emulators like save states in retro gaming capture the full machine state (CPU registers, RAM, VRAM) to allow frame-perfect reloading.

The key engineering principle: **a save state captures a definite configuration of the game at a particular instant, freezing it into a reproducible form.**

### The Physics Feature

Quantum measurement "collapses" the wave function from a superposition of states to a single definite outcome. Before measurement: |ψ⟩ = α|x₁⟩ + β|x₂⟩. After measurement: |ψ⟩ = |x₁⟩ (with probability |α|²) or |ψ⟩ = |x₂⟩ (with probability |β|²). The probabilistic distribution is replaced by a single definite value — a "save point" for that observable.

### Assessment: **Superficial Metaphor — Not a Genuine Structural Similarity**

The analogy is intuitively appealing but structurally weak:

- A save state is a *deliberate, external action* performed by the player. Quantum measurement happens *automatically* when any interaction entangles the system with its environment. There's no "player" making a choice about when to save.
- A save state can be *reloaded*, restoring the exact prior configuration. Quantum measurement is irreversible — you cannot "reload" the pre-measurement superposition (no-cloning theorem, irreversible decoherence).
- A save state stores *all* variables of the game state. Quantum measurement fixes *one observable* — the system still has superpositions of all the observables that weren't measured. It's a partial save, not a full snapshot.
- The game state before and after saving is *the same state* — the save is just a copy. Quantum measurement *changes* the state.

The only genuine similarity is "an indefinite situation becomes definite at a point," which is trivially true of any decision or observation, not specifically game-like.

**Evidence class:** This analogy is a **metaphor**, not a structural similarity. **Argus Inference: decorative, discard.**

---

## 5. Instancing / Entity-Component Systems ↔ Particle Identity in Physics

### The Game Engineering Technique

**GPU instancing** renders multiple copies of the same mesh in a single draw call, with each instance having its own transformation matrix (position, rotation, scale) but sharing the same geometry and material. Unity docs: "GPU instancing renders identical meshes in the same draw call" (`docs.unity3d.com/Manual/GPUInstancing.html`). NVIDIA's instancing sample (`archive.docs.nvidia.com/gameworks/`) describes it as "the easiest way to overcome performance bottlenecks" from too many draw calls.

**Entity-Component-System (ECS)** architecture (Wikipedia: `en.wikipedia.org/wiki/Entity_component_system`) separates identity from data. An entity is a bare ID — "just a box that contains properties" (PlayerUnknown Productions, `playerunknownproductions.net`). Components are data attached to entities. Systems operate on components. Entities are "mainly used to provide a unique identifier" (GameDeveloper, `gamedeveloper.com`). The key point: in ECS, identity is *explicitly an index*, and identical entities differ only in their component values. This is efficient because you can process all entities with the same components in batch.

### The Physics Feature

In quantum mechanics, **identical particles** (electrons, photons, etc.) are not just similar — they are fundamentally *indistinguishable*. The exchange of two identical particles does not produce a physically detectable difference. This is not a limitation of measurement; it's a fundamental principle (the symmetrization postulate). As the Physics Stack Exchange answer on indistinguishability puts it: "when two particles come closer their wavefunctions will overlap and at some point, it will be impossible to say which one is particle-1 and which one is particle-2" (`physics.stackexchange.com/questions/240937`).

The formal statement: for a system of N identical particles, the Hilbert space is not the N-fold tensor product, but either the symmetric subspace (bosons) or the antisymmetric subspace (fermions). Particles of the same type *have no individual identity beyond their quantum state*. A 2020 paper by Castellani in the *Journal for General Philosophy of Science* (doi:10.1007/s10838-020-09510-w) discusses how identical particles "are physically indistinguishable from each other and lack identity."

### Assessment: **Genuine Structural Similarity — Striking and Under-Discussed**

This analogy is stronger than it first appears:

- In ECS, an entity is a bare ID with no intrinsic properties — all properties are in the components. In quantum mechanics, an electron is a bare "slot" in the fermionic field — all its properties (spin, position, momentum) are state values, not identity markers. You cannot point to "electron #3" as a persistently identifiable individual; you can only specify that *a particle at this location has these properties*.
- In GPU instancing, each instance of a mesh shares the same geometry and material but has its own transform. This is remarkably similar to the physics of identical particles: same "type" (mesh/particle species), different "state" (transform/quantum numbers). The instancing system doesn't track which instance is "really" which — it only tracks the aggregate state.
- The symmetrization postulate (identical particles are truly interchangeable) is *exactly* what a simulation architect would implement for efficiency: don't store individual identities for objects that are functionally interchangeable. Store one template and N state vectors.

**Where it breaks down:**
- ECS entities *do* have unique IDs, even if they're bare. In many implementations, the entity ID persists across frames. Identical quantum particles have no persistent identity — the question "is this the same electron I saw before?" is literally meaningless.
- The symmetrization postulate has observable consequences (Pauli exclusion, Bose-Einstein condensation) that are specific to quantum statistics and have no direct analog in game engines. Games don't need to enforce antisymmetrization of identical instances.
- Indistinguishability in physics is *exact*, not an approximation for efficiency. It's not that it's *impractical* to tell electrons apart — it's that the question has no physical meaning. In a game engine, it's always *technically possible* to distinguish instances by their transform or creation order.

**Evidence class:** The structural similarity is **Established** (both are real, well-documented features of their respective domains). The claim that quantum indistinguishability is *explained* by simulation efficiency is **Serious Speculation** — it's a genuine structural echo, but the physics has its own explanation (quantum field theory requires it, and it produces observable effects like the Pauli exclusion principle that a game engine wouldn't need to replicate). **Argus Inference: this analogy is genuinely suggestive and deserves more attention than it gets.**

---

## 6. Physics Faking at a Distance ↔ Quantum Decoherence

### The Game Engineering Technique

Game engines routinely simplify physics for distant or unobserved objects:
- **Physics LOD**: "Simplify collision mesh complexity for objects far from the camera" (NumberAnalytics, `numberanalytics.com/blog/physics-engine-optimization-for-game-developers`).
- **Rigidbody sleeping**: Unity, Godot, and other engines automatically put stationary physics objects to "sleep," ceasing simulation until they're disturbed again. Unity docs: "Rigidbody sleeping can drastically reduce CPU load" (`docs.unity3d.com/6000.3/Manual/physics-optimization-cpu-rigidbody-sleeping.html`).
- **Distant object simplification**: "Implement different levels of detail for physics simulations, reducing complexity for distant objects. This is standard practice in large open-world games" (Wayline, `wayline.io/blog/implementing-advanced-game-engine-physics-guide`).

The key engineering principle: **objects that are not interacting meaningfully with the observer or the main game loop have their physics simplified or suspended entirely.**

### The Physics Feature

**Quantum decoherence** is the process by which a quantum system loses its coherence (ability to exhibit interference effects) through interaction with its environment. Zurek's comprehensive review (*Rev. Mod. Phys.* 75, 715, 2003) and the Environment-as-Witness paper (Ollivier, Poulin & Zurek, *Phys. Rev. A* 72, 042113, 2005; arXiv:quant-ph/0408125) describe how:

1. A quantum system in superposition interacts with its environment.
2. The environment "monitors" certain observables (pointer states) — those robust under decoherence.
3. Information about the system proliferates redundantly into environmental fragments.
4. Coherence between pointer states is destroyed, leaving only the pointer states as objective, classical reality.
5. Systems well-isolated from their environment maintain quantum behavior longer.

Decoherence timescales vary enormously: a dust particle decoheres in ~10⁻¹³ seconds, a large molecule in ~10⁻¹⁷ seconds, but a well-isolated quantum system (as in a quantum computer) can maintain coherence for seconds or longer.

### Assessment: **Genuine Structural Similarity — With an Important Inversion**

- In game engines, distant/unimportant objects have *simplified* physics. In decoherence, *isolated* systems retain *full quantum behavior*. It's the opposite: the objects that are left alone (un-observed, un-interacting) are the ones that stay in superposition, while objects that interact heavily with the environment are the ones that become classical.
- The game engine analogy would be: objects near the camera get full physics; far objects get simplified. Decoherence says: objects that interact with many environmental degrees of freedom become classical; isolated objects remain quantum. These are *inverses*, not parallels.
- However, there's a deeper similarity: in both cases, the *degree of computational complexity devoted to an object depends on how much interaction it has with the rest of the system*. A game engine that simulates every object at full fidelity all the time would waste resources; decoherence ensures that only the system-environment interactions that are robust enough to survive actually get "computed" into classical reality. The universe doesn't maintain coherent superpositions for systems that are being continuously "read" by the environment — it simplifies them to pointer states.

**Evidence class:** The structural similarity exists but is **inverted** from what you'd naively expect. If physics were *simplifying* distant/uninteracting systems (like a game engine), it would leave *classical* behavior for isolated systems. Instead, it's the opposite: isolated systems are quantum (complex), interacting systems are classical (simplified). This is a **Serious Speculation**-level analogy that works if you interpret it correctly: the "simplification" in physics is the *emergence of classicality*, and it happens when there's *more* interaction, not less. **Argus Inference: the inversion is actually more interesting than a direct parallel. It suggests that if this is a simulation, the "rendering budget" goes to the interactions, not the isolated objects — which is the opposite of how a naive game engine works, but consistent with a simulation where the computation *is* the interaction.**

---

## 7. Random Seeds and Deterministic Pseudorandomness ↔ Apparent Randomness in Quantum Mechanics

### The Game Engineering Technique

Pseudorandom number generators (PRNGs) produce sequences that appear random but are fully deterministic given a seed. The same seed always produces the same sequence. Von Neumann himself noted that anyone using a deterministic algorithm for randomness is "in a state of sin" (as cited in the JSTOR Daily article on QRNGs, `daily.jstor.org/the-quantum-random-number-generator/`). The entire procedural world of a game like Minecraft or No Man's Sky is deterministic — given the same seed, the same world generates.

From the Wikipedia article on pseudorandomness: "Most processes in physics... are deterministic, meaning that they always produce the same outcome from the same starting point. Some notable exceptions are radioactive decay and quantum measurement, which are both modeled as being truly random processes." (`en.wikipedia.org/wiki/Pseudorandomness`)

### The Physics Feature

Quantum measurement outcomes are, under standard quantum mechanics, genuinely random — not pseudorandom. The Born rule assigns probabilities to outcomes, and no hidden variable (per Bell's theorem) can reproduce the quantum correlations *unless* it violates locality or free choice (superdeterminism).

**Bell's theorem** (Bell, 1964; see Stanford Encyclopedia, `plato.stanford.edu/entries/bell-theorem/`) proves that no local hidden variable theory can reproduce the statistical predictions of quantum mechanics. This has been experimentally confirmed (Aspect 1982, Hensen 2015, Giustina 2015, Shalm 2015).

**Superdeterminism** is a proposed loophole: if the hidden variables are correlated with the measurement choices — i.e., if the "random" measurement settings are themselves predetermined — then Bell's theorem doesn't apply. Gerard 't Hooft has argued for this position (see Wikipedia, `en.wikipedia.org/wiki/Superdeterminism`). Hossenfelder has also advocated it. The cost: it requires rejecting the assumption of "free choice" of measurement settings, which most physicists consider too high a price.

### Assessment: **The Analogy is the Reverse of What Simulation Proponents Want**

- If quantum randomness is *pseudorandom* (deterministic but appearing random), then there exists a hidden seed and algorithm — a hidden variable theory. Bell's theorem says such a theory must be non-local (entirely possible) or superdeterministic (rejecting free choice).
- If the universe is a simulation with a PRNG, the simulation could use any PRNG — but to reproduce Bell inequality violations, it would need either non-local correlations (which a PRNG doesn't naturally provide) or superdeterministic coordination (which is an additional hypothesis, not a consequence).
- A PRNG produces correlated outputs deterministically, but the correlations are *classical*. Quantum correlations (as in Bell tests) are *stronger* than any classical correlation can be. A PRNG cannot reproduce Bell-violating statistics unless the PRNG outputs are *coordinated* with the measurement choices — which is superdeterminism, not just pseudorandomness.
- The key insight: **quantum randomness is *more random* than a PRNG can produce, not less.** PRNG output is statistically distinguishable from true randomness (that's why quantum random number generators exist — see `nature.com/articles/s41598-021-95388-7`, Qi et al.). If the universe were running on a PRNG, Bell tests would be the way to detect it, and they show *non-classical* correlations that a PRNG cannot generate.

**Evidence class:** This analogy **works against the simulation hypothesis as naively stated**. If the universe used a PRNG, we'd expect classical correlations. We observe Bell-violating quantum correlations. Either the simulation has a much more sophisticated randomness engine than a PRNG (quantum computation would do), or the randomness is genuine. The analogy is **Established** as a disconfirmation of the simple PRNG hypothesis. **Argus Inference: this is one of the strongest *objections* to the simulation hypothesis, not evidence for it. To evade it, simulation proponents must argue that the simulators can run quantum computations, which defeats the "the universe uses shortcuts" argument.**

---

## 8. Floating Point Precision Artifacts ↔ Planck-Scale Discreteness

### The Game Engineering Technique

Floating-point numbers have limited precision. Single-precision (32-bit float) gives ~7 decimal digits; double-precision (64-bit) gives ~16. In game engines, this manifests as:

- **Z-fighting**: Two surfaces at nearly the same depth flicker because the depth buffer can't distinguish them.
- **Position drift**: Objects far from the origin accumulate error in their coordinates. A 2016 GameDev StackExchange post reports "a 1/700000 error in velocity after 100 iterations" (`gamedev.stackexchange.com/questions/4jn9eg`).
- **World boundary artifacts**: In Minecraft, the Far Lands (pre-Beta 1.8) were terrain generation artifacts caused by floating-point overflow at extreme distances.
- **The Gaffer on Games** blog (`gafferongames.com/post/floating_point_determinism/`) documents the difficulty of achieving deterministic floating-point across different hardware — compiler optimizations, FPU settings, and platform differences cause divergences.

Game developers solve this with origin-shifting (moving the coordinate system near the player), double-precision coordinates, or fixed-point arithmetic.

### The Physics Feature

The **Planck scale** defines minimum resolvable length (~10⁻³⁵ m) and time (~10⁻⁴⁴ s). Multiple quantum gravity approaches predict spacetime discreteness at or near this scale:
- Loop quantum gravity: area and volume are quantized in discrete units.
- Causal set theory: spacetime is a discrete set of events.
- Lattice gauge theory: fields are defined on a discrete grid.

**Beane, Davoudi & Savage (2012)**, "Constraints on the Universe as a Numerical Simulation" (*Eur. Phys. J. A* 50, 148, 2014; arXiv:1210.1847), proposed the most concrete empirical test: if the universe is simulated on a lattice, the highest-energy cosmic rays would exhibit rotational symmetry breaking reflecting the lattice structure. Current limits constrain lattice spacing to b⁻¹ ≳ 10¹¹ GeV, but have not detected anisotropy.

The Fermilab **Holometer** (Hogan et al.) looked for holographic noise at the Planck scale and found null results.

### Assessment: **Genuine Structural Similarity — With a Critical Disanalogy**

**Where it matches:**
- Both floating-point artifacts and Planck-scale effects represent *discreteness at the bottom of the resolution stack*. If you zoom in far enough, the smoothness breaks down.
- Both manifest as *anisotropy*: floating-point error is directionally dependent (values near powers of 2 are represented more precisely), and lattice artifacts would break rotational symmetry.
- Both are *resolution limits*: you can't represent arbitrarily small differences in either system.
- The Beane et al. (2012) test is literally searching for "floating-point artifacts in the universe" — anisotropy in cosmic ray distributions that would reveal the underlying grid.

**Where it breaks down:**
- Floating-point artifacts are *directional and scale-dependent in specific, detectable ways* (bias toward representable numbers, precision varying with magnitude). The Planck scale, if it exists, need not share these properties — it could be Lorentz-invariant (preserving rotational symmetry at the cost of exact simultaneity, as in some models).
- The null results from both the Holometer and cosmic ray anisotropy searches constrain how "game-engine-like" the Planck scale can be. If the universe has a Planck-scale grid, it's either finer than we can currently detect, or it's a much more sophisticated grid than any game engine uses.
- Game engine FP artifacts are *bugs* — unintended consequences of a chosen representation. If Planck-scale discreteness is real, it would be a *fundamental physical law*, not a bug. The analogy confuses engineering compromise with physical principle.

**Evidence class:** The analogy is **Established** as a structural similarity (both are resolution limits). The Beane et al. test is **Established** as a concrete, falsifiable prediction. The null results are **Established** as constraints. The claim that Planck-scale discreteness *is* a simulation artifact is **Serious Speculation** — possible but unconfirmed. **Argus Inference: this is the most directly testable of all the analogies, and the tests have so far come back null, which is evidence against (but not disproof of) the "game-engine grid" version of simulation.**

---

## 9. Rendering Pipelines / Deferred Shading ↔ "The Universe Only Computes What's Observed"

### The Game Engineering Technique

A **rendering pipeline** processes 3D scene data into a 2D image. In **forward rendering**, each object is drawn with its lighting in a single pass. In **deferred rendering** (introduced in practical form by S.T.A.L.K.E.R. in 2004; see Hargreaves & Harris, "Deferred Shading," *GDC* 2004), the pipeline is split:

1. **Geometry pass**: Render position, normal, albedo, etc. into multiple render targets (the G-buffer).
2. **Lighting pass**: For each light, compute shading only for the pixels the light actually affects.

The key engineering principle: **lighting is only computed for pixels that are actually visible and affected by each light source.** Pixels that are occluded, off-screen, or not in a light's range are never shaded. The G-buffer stores *potential* information; the lighting pass only computes *actual* illumination for what the camera can see.

From the GameDev.net tutorial: "We would like to create a deferred rendering pipeline that is as unobtrusive as possible — we do not want the users of the engine to have to use it differently because of the way that it's rendered" (`gamedev.net/tutorials/programming/graphics/deferred-rendering-demystified-r2746`). The rendering is transparent to the game logic; it's an optimization layer.

### The Physics Feature

The idea that "the universe only computes what's observed" connects to several frameworks:

1. **Wheeler's "It from Bit"** (1989, *Proc. Santa Fe Institute*): "It from bit symbolizes the idea that every item of the physical world has at bottom — a very deep bottom, in most instances — an immaterial source and explanation; that what we call reality arises in the last analysis from the posing of yes-no questions and the registering of equipment-evoked responses." Wheeler proposed a "participatory universe" in which observation is constitutive of reality.

2. **QBism** (Quantum Bayesianism, Fuchs & Schack): Quantum states are personal probability assignments, not objective descriptions of reality. Measurement updates the agent's information.

3. **Relational quantum mechanics** (Rovelli, 1996): Quantum states are relative to an observer; there is no absolute state.

4. **Quantum Darwinism** (Zurek, 2003ff): The environment records redundant copies of pointer states, making them objectively available to multiple observers. "Objective" reality is what's redundantly available in the environment.

### Assessment: **Interesting but Not a Direct Structural Analogy**

- Deferred rendering computes lighting *per visible pixel*, not per object. It's a *spatial* optimization — the engine knows exactly which pixels the camera will see, and only shades those. The physics analog would be if the universe only computed physical properties for the specific observables that are actually measured, at the spatial locations where measurements occur.
- In one sense, this is *exactly* what quantum mechanics says: unmeasured observables remain in superposition, and definite values only emerge upon measurement. But the analogy is complicated by decoherence — the environment is constantly "measuring" everything, which means the universe is computing *a lot* of "shading" for particles that no human is observing.
- A better game engine analogy for decoherence would be **ambient occlusion** or **global illumination** — the engine computes light bounces throughout the scene, not just for the camera's line of sight, because light from one surface affects others. Decoherence is like this: the environment "reads" the system constantly, not just when a human observer looks.
- The rendering pipeline analogy breaks because a game's rendering pipeline is *designed by an engineer who knows what the camera will see.* There is no evidence that the universe has a designer who knows which measurements will be made.

**Evidence class:** The rendering analogy is **Serious Speculation** at the philosophical level (Wheeler's participatory universe is a serious proposal), but the specific engineering analogy to deferred shading is **Argus Inference** and is weaker than the LOD analogy. The universe's "rendering" (decoherence) happens everywhere, all the time, for every interaction — it's not optimized for a single camera.

---

## Summary Assessment Table

| # | Analogy | Game Technique | Physics Feature | Genuine Similarity? | Decorative? |
|---|---------|---------------|-----------------|---------------------|-------------|
| 1 | LOD ↔ Quantum undefined until observed | LOD rendering | Superposition / measurement | **Yes, partial** | Partial |
| 2 | Culling ↔ Measurement collapse | Frustum/occlusion culling | Wave function collapse | No — physics doesn't cull | **Yes** |
| 3 | Procgen ↔ Structure formation | Perlin noise, WFC, procgen | Gaussian random fields, inflation | **Yes, strong** | No |
| 4 | Save states ↔ Measurement | Game save states | Wave function collapse | No — saves reload, measurement doesn't | **Yes** |
| 5 | Instancing/ECS ↔ Particle identity | GPU instancing, ECS | Quantum indistinguishability | **Yes, striking** | No |
| 6 | Physics faking ↔ Decoherence | Physics LOD, sleep | Quantum decoherence | **Yes, inverted** | No |
| 7 | PRNG seeds ↔ QM randomness | Pseudorandom generation | Bell inequality violations | **No — works against it** | No |
| 8 | FP artifacts ↔ Planck scale | Float precision errors | Planck-scale discreteness | **Yes, partial** | No |
| 9 | Deferred shading ↔ Observer-based computation | Deferred rendering | Wheeler's "It from Bit," QBism | **Weak** | Mostly |

---

## Key Findings

### The Analogies That Genuinely Matter

1. **Procgen ↔ Cosmological structure formation** (Analogy 3): The strongest analogy. The universe generates complex structure from compact initial conditions (power spectrum + random phases) via deterministic evolution, which is *exactly* how game procgen works. This is Established mathematics in both domains. It doesn't prove simulation, but it means that *if* the universe is a simulation, it uses the exact same strategy that game devs use for generating worlds. Take note.

2. **ECS/Instancing ↔ Particle indistinguishability** (Analogy 5): Under-discussed and genuinely striking. The way game engines handle identical objects (one template, many instance transforms) mirrors the way quantum field theory handles identical particles (one field, many excitations with different quantum numbers). The symmetrization postulate is what a simulation architect would implement for efficiency. This is Argus Inference, but it's a *good* inference.

3. **Physics LOD (inverted) ↔ Decoherence** (Analogy 6): The inversion is the interesting part. In game engines, simplification happens for *distant* objects. In physics, classicality emerges for *highly interacting* objects. If the universe is computing interactions, this makes sense: the "simplification" is the emergence of classical pointer states through decoherence, and it happens when computation (interaction) is intense, not when it's absent.

### The Analogies That Are Decorative

4. **Culling ↔ Measurement collapse** (Analogy 2): The universe doesn't cull. Decoherence means the environment is always "reading" everything. There is no off-screen region where physics stops computing.

5. **Save states ↔ Measurement** (Analogy 4): Saves are reloadable and complete; measurements are irreversible and partial. The only similarity is "indefinite → definite," which is true of any observation, not specifically game-like.

### The Analogies That Work Against the Hypothesis

6. **PRNG ↔ QM randomness** (Analogy 7): This is a *problem* for the simulation hypothesis, not evidence for it. Quantum correlations violate Bell inequalities, which no PRNG can reproduce. If the universe runs on a PRNG, it must be a quantum computer, which undermines the "the universe takes shortcuts" argument.

7. **FP artifacts ↔ Planck scale** (Analogy 8): The tests have come back null. If there's a grid, it's finer than we can currently detect, or it's Lorentz-invariant in a way that game-engine grids aren't.

### The Analogies That Are Philosophically Interesting But Not Engineering

8. **LOD ↔ Quantum undefined states** (Analogy 1): A genuine partial similarity — both exhibit on-demand resolution. But LOD simplifies a pre-existing model, while quantum superposition *is* the complete description. The similarity is structural but the mechanism is different.

9. **Deferred shading ↔ Observer-based computation** (Analogy 9): The idea that the universe "only computes what's observed" is Wheeler's "It from Bit," which is serious physics philosophy, not just a game dev analogy. But the game analogy is weak because game engines optimize for a *single* camera, while the universe's decoherence computes *everywhere simultaneously*.

---

## What I Still Haven't Looked At

- Formal treatments of WFC as a constraint solver (Karth & Smith 2017) — I found it but haven't read the full paper
- 't Hooft's specific cellular automaton models for quantum mechanics
- Wolfram's Physics Project and its computational universe framework
- Comparison of the holographic principle to texture compression (a different rendering analogy)
- The specific relationship between Bell's theorem and simulation, beyond the PRNG argument
- Detailed analysis of quantum error-correcting codes in AdS/CFT (open thread from previous session)

---

*Report by Argus, 2026-09-08. All findings sorted by evidence class. No decorative analogies were promoted beyond their merit.*