The Rendering Engine

The Outside view is the god view no player ever gets. A drifting interstellar field hangs in the void, crystal asteroids, satellites, ringed planetoids, comets, deep-space probes, and a camera-drone, the Eye, sweeps among them trailing a glowing view frustum. Inside the cone the world is fully rendered: lit rock, luminous crystals, comet tails, solar panels. Outside it, the field decays into a violet fog of possibilities and faint data boxes: stored, not drawn. The status bar counts every chunk and triangle, live and true. This is frustum culling, the oldest optimisation in real-time graphics, made visible.

The Inside view puts you behind the lens. Whip the camera as hard as you can: with zero latency the world is always already there, because the engine renders between your frames. Then switch to the lagging engine, 450 milliseconds of deliberate brokenness, and the world visibly loads as you turn. The counter tracks every pop-in you catch. Nature's counter, after a century of precision measurement, still reads zero.

The Correspondence table, bottom-left, is the sim's educational core and its conscience. Seven rungs of the analogy, engine on one line, world on the next, each tagged ENGINE (a real technique), PHYSICS (textbook quantum mechanics) or READING (Virk's interpretation). Rows light up as you touch the matching control, so you always know which kind of claim you are looking at.

This instrument grew directly out of a piece of writing on this site: the signed review of the second edition of Rizwan Virk's The Simulation Hypothesis. That book's central line is seven words long: "Only render that which is being observed." Virk's claim is that the rule of a game rendering engine and the rule of quantum indeterminacy are the same rule: the engine does not draw the room behind you, and the universe, on his reading, does not settle the electron until you look. The claim cannot be demonstrated by the site's other instruments, because it is not a law of physics; it is a reading of physics. What can be demonstrated is the engine the reading leans on, which is real, ships every day, and has been played by everyone. So we built the engine itself.

It is also a stress test of this site's editorial stance. Every fact on the quantum side of the table is textbook material, with its own exact instrument next door: the Double-Slit, Entanglement, the Uncertainty Principle. Every technique on the engine side is industry standard. The danger is mistaking a rhyme for an identity, which is exactly why the Correspondence table exists: every rung of the analogy is tagged ENGINE / PHYSICS / READING, with the places where the analogy holds and the places where it strains drawn in plain sight. Summarise, attribute, link; the verdict is yours.

One rule draws the whole scene:

render(chunk) ⇔ chunk ∩ frustum ≠ ∅ · frustum = f(position, direction, FOV)

The frustum is the observer. To an engine, an observer is three numbers: position, direction, field of view. Each frame, every chunk's bounding sphere is tested against the six planes of each observer's frustum; chunks that intersect are rendered, chunks that do not are skipped. The FOV slider changes the cone in the exact way it changes a real camera, and the compute meter pays for every degree.

The unobserved world is data. A culled chunk is not deleted: its full state persists in memory, ready to render the moment a frustum arrives. The sim draws that state as violet probability fog when you choose Virk's on-demand mode, or as nothing at all in plain culled mode. Same fact, two pictures, and the toggle is yours.

Latency is the falsifiable edge. With zero latency, pop-in is invisible by construction: the containment test runs before the frame is drawn, so the engine always wins. Add latency and materialisation becomes catchable, which is precisely the glitch a lagging simulated universe would show. Beane, Davoudi and Savage (2014) made this respectable: a crude lattice simulation would leave measurable signatures. None have been found.

Narrowcasting is one draw list per player. In multiplayer engines each client renders its own subset of the world. The anomaly preset stages it: one object rendered only in Eye-1's frustum, while two other observers sweep the same sky and get nothing. The technique is ordinary; applying it to disagreeing UAP witnesses (p. 270) is Virk's reading, and the table tags it so.

The counts stay honest. 79 chunks, about twelve thousand triangles. Rendered, culled, coverage, savings versus the naive engine: every number in the status bar and readout is computed from this scene each frame. When the naive mode pegs the meter at 100%, that is a real measurement of why no shipped game has ever worked that way.

The engine mechanics and all printed counts are real; the fog, the burst and the ever-rendered backdrop are presentation; the claim that our universe works this way is tagged T3 wherever it appears.

Six ways to run the same world, from brute force to the one that started the argument.

• Render everything. No culling: all 79 chunks, all the time, compute pegged. The honest brute force no engine ships.
• Frustum culling. Skip what no camera sees, unobserved chunks drawn as plain nothing. Standard since 1976.
• On-demand. The same culling, with the unobserved world drawn as Virk reads it: a fog of persisted possibilities that renders on look. The T3 preset, and it says so.
• Lagging engine. 450 ms of render latency. Go Inside and whip the view: the pop-in counter is waiting.
• Three observers. Three frustums sweep at once and the world renders wherever anyone looks. Coverage triples; the void retreats.
• Narrowcast. Three observers, and one object rendered for Eye-1 alone. The other two frustums pass straight through it.

1. Watch one asteroid all the way through. Park the flight speed at 0%, pick a fogged chunk at the frustum's edge, and nudge the FOV until it materialises. That single transition is the whole book.
2. Peg the meter. Flip to Render everything and watch coverage hit 100% and the savings hit 0%. Then flip back and read the savings line again.
3. Try to catch the render. Go Inside with zero latency and whip the view as fast as you can. You will fail. That failure is the argument's cleverest move.
4. Then break the engine. Lagging engine, still Inside, same whip. Now count your pop-ins, and remember that nature's count is still zero.
5. Run the narrowcast. Watch the anomaly appear for Eye-1 and not for the others, then decide for yourself what that does and does not explain.
6. End on the Correspondence. Toggle the fog and watch the PHYSICS row light; change FOV and watch the READING row light. The tags are the point.

The honest line between what is engine-real, physics-real, and read-in:

In one line: the engine is real and the quantum facts are real; the claim that the second is an instance of the first is Rizwan Virk's reading, argued in a book this site has reviewed, and so far unfalsifiable, which the instrument tells you to your face.

• Virk, R. (2025). The Simulation Hypothesis (2nd ed.). Tarcher / Penguin Random House. The seven words (p. 164), the Planck pixel (p. 196), entanglement as shared memory (p. 208), narrowcasting and UAP (p. 270).
• Bostrom, N. (2003). Are You Living in a Computer Simulation? Philosophical Quarterly 53(211). The trilemma the whole genre stands on.
• Chalmers, D. (2022). Reality+: Virtual Worlds and the Problems of Philosophy. W. W. Norton. The philosophical case that simulated worlds are real worlds.
• Wheeler, J. A. (1990). Information, Physics, Quantum: The Search for Links ("it from bit"), in Complexity, Entropy and the Physics of Information. The respectable ancestor of information-first physics.
• Clark, J. H. (1976). Hierarchical Geometric Models for Visible Surface Algorithms. Communications of the ACM 19(10). The original culling paper: do not draw what cannot be seen.
• Akenine-Möller, T., Haines, E., & Hoffman, N. (2018). Real-Time Rendering (4th ed.). CRC Press. Frustum culling and visibility as standard practice.
• Zurek, W. H. (2003). Decoherence, einselection, and the quantum origins of the classical. Reviews of Modern Physics 75, 715. Why "measurement" needs no conscious observer.
• Schlosshauer, M. (2005). Decoherence, the measurement problem, and interpretations of quantum mechanics. Reviews of Modern Physics 76, 1267. The measurement problem, stated carefully.
• Beane, S. R., Davoudi, Z., & Savage, M. J. (2014). Constraints on the Universe as a Numerical Simulation. European Physical Journal A 50, 148. The one genuinely falsifiable corner: lattice signatures a crude simulation would leave.
• This site (2026). A Player, Not a Program: the signed review of Virk, with the full argument and its objections.