Your Brain Is a Rendering Engine. So Is Every LLM.

A developer argues that both human brains and large language models function as rendering engines that sample from an objective field, rather than collapsing probability distributions through observation. The post draws an analogy between quantum mechanics and token sampling, presenting a C++ code snippet to illustrate the concept.

Part 1 of 3. The rest of the series: Part 2: More Compute Won't Wake It Up . Part 3: Two Render Layers Deep Before You've Even Formed an Opinion . Last week two of us were staring at the same backtest output. Same numbers, same chart, same equity curve. One person said "this looks like it's breaking out." The other said "that's noise, it'll revert by Friday." Same data. Two completely different reads. I've seen this happen enough times now and it bugs me every time. The chart didn't change between the two readings. The data was just sitting there. What changed was the thing doing the reading. "When you observe a particle, the wavefunction collapses. Consciousness creates reality." You hear this at parties. Sounds deep. Falls apart fast. There's a version of this that keeps showing up in AI discussions too. "Your prompt enters the latent space and collapses the probability cloud into a concrete token." Same energy. Same structural mistake. Both versions treat the observer as the thing that changes the world. The world doesn't seem to change, though. The particle was doing its thing before anyone looked. The probability distribution over tokens existed before the prompt arrived. What changed was the output of the system doing the looking. The more I sat with this, the more I kept seeing a two-step pattern showing up in places I didn't expect. Observation isn't one step. There's a signal coming in, and then there's a separate thing that renders that signal into something usable. A tree outside your window is vibrating at whatever frequency a tree vibrates at. Your eyes pick up a slice of that vibration a very narrow slice, turns out . Then your brain takes that narrow input and renders "a green tree" out of it. The tree never looked like anything. "What the tree looks like" is your brain's output, not the tree's property. Same sunset, two people. One feels calm, the other feels sad. The sunset's vibration frequency didn't change between observers. What changed is the rendering engine and its training history. One brain has sunset linked to beach vacations, the other has it linked to going home. Run the same prompt through two models trained on different data. Same thing. The prompt didn't change. The weights did. I'm not a physicist, to be clear. I'm a software person using physics as a lens, and some of this is probably sloppy in ways I can't see. If you squint at this through engineering glasses, it's basically sampling. I wrote this while thinking through the analogy it's deliberately not a physics simulator : include <complex include <cstddef include <vector struct ObjectiveField { // the world. just sitting there. not collapsing for anyone. std::vector<std::complex<double amplitude field; }; class LocalRenderer { public: // your brain. my brain. an LLM. all doing this. std::size t sample const ObjectiveField& field const { std::vector<double probabilities; probabilities.reserve field.amplitude field.size ; for const auto& amp : field.amplitude field { // |amplitude|^2 = probability. the one thing // quantum mechanics and token sampling agree on. probabilities.push back std::norm amp ; } // pick one. congratulations, you just "observed" something. // the field didn't change. you just rendered a local output. return choose index probabilities ; } private: std::size t choose index const std::vector<double & probabilities const { // in production this would be a real sampler. // in this analogy it's doing the same work your // retina does when photons hit it: reducing a // rich upstream state into one concrete answer. return probabilities.empty ? 0 : 0; } }; Token sampling via temperature, your retina processing photons, the code above. All doing the same thing: squishing a rich upstream state into one concrete answer. The upstream state doesn't collapse. It just sits there. The renderer produces a local output and moves on. Run inference on a deployed model. The weights don't change. Next request starts from the same parameter state. Your brain doesn't work like that. Every perception, every emotional hit, every repeated pattern shifts your synaptic weights. You see enough sunsets associated with loss and eventually "sunset" just renders as sadness automatically. The distribution that used to be spread across a dozen possible reactions narrows down, gets peaked, starts looking almost deterministic. That's the actual difference. Not compute, not parameter count. Your brain modifies itself every time it renders. Current LLMs don't. One more piece I think matters here. When you first saw a tree as a kid, your brain didn't just get visual data. It got the wind on your skin, the temperature, whether you were hungry, what your mom was saying. All of that got bound together in one training pass. "Tree" in your head isn't a label on a visual pattern. It's a whole package of stuff, trained simultaneously. An LLM gets text. Or text and images in separate channels that get fused later. Cleaner, narrower. That's probably why two people look at the same sunset and have completely opposite reactions, while two copies of the same model give you roughly the same output for the same prompt. The models share training data. The humans don't. If collapse only happens inside the observer's rendering engine, then a lot of questions I thought were about the world are actually about the renderer. "What does the tree look like when nobody's looking?" is a badly formed question. The tree doesn't "look like" anything. Looking is something renderers do. I keep coming back to that backtest argument. Two people, same chart. The chart was just numbers. The disagreement wasn't about the chart. It was about two rendering engines with different training histories producing different outputs from the same input. Neither was seeing the market. Both were seeing their own render. And I'm not sure I'm any different when I look at my own backtests, tbh. Not sure where that leaves the question of what "seeing clearly" even means. I'm not done thinking about it. Part 2 goes somewhere harder: if both brains and LLMs are bounded render layers, does "more compute" get you any closer to actual mind? Find me on StratCraft https://stratcraft.ai | GitHub https://github.com/StratCraftsAI