The Trick Happening Behind Every Wall
You clip through a wall by accident, or a streamer's photo mode spins the wrong way, and suddenly the city crowd behind you is a street full of featureless mannequins. Flat textures. No faces. Limbs locked mid-stride like the world hit pause.
It feels like a bug. It isn't.
The engine is doing exactly what it was told, and understanding why requires sitting with one uncomfortable truth: your GPU is always overwhelmed, and every frame is a negotiation.
Polygons Cost Money (In Processing Time)
A single detailed character in a modern open-world RPG can carry anywhere from 50,000 to 200,000 polygons. Multiply that across a city crowd of 300 NPCs and you're asking the GPU to process tens of millions of triangles just for background people whose only job is making a street feel alive.
No consumer hardware handles that at 60 frames per second.
So engines use a tiered swap system. The character standing next to you runs at full fidelity: full polygon count, high-resolution textures, cloth simulation, facial blend shapes. Walk thirty metres away and the engine silently swaps them to LOD1, maybe 20,000 polygons. Walk further and you're at LOD2, around 5,000 polygons, a single flat texture baked with fake shadow detail. Far enough and they become a billboard, literally a flat image that rotates to always face the camera, like a cardboard standee propped up in a theme park queue.
The transition is tuned to happen just beyond the threshold where most players notice. Usually.
What "Off-Camera" Actually Triggers
Distance is only part of it. The camera angle is doing heavier lifting than most people realise.
Engines run a process called frustum culling every single frame. The view frustum is the pyramid of space the camera can actually see, and everything outside that pyramid gets culled: the engine skips rendering it entirely. Culled doesn't mean paused, though. Characters outside your view still run their AI routines, their pathfinding, their dialogue triggers. Their renderer just switches off, or drops to the absolute lowest LOD, because there's no point drawing what no eye will see.
Some engines go further with occlusion culling. If a wall sits between you and a crowd, the engine confirms those NPCs are fully blocked and drops them to skeleton-only simulation or pauses animation entirely. A character behind a building might freeze mid-stride, then snap back to life the instant they enter your sightline. You'll never see it happen.
Unless you do. Picture this: a streamer sets up a photo mode shot and rotates the camera 180 degrees to look back at the city they just walked through. That crowd was fully culled a second ago. Now it snaps into view at LOD2 or lower, because the engine hasn't had time to stream the full assets. The result is a street of sock puppets. The clip goes everywhere. Comments fill with "the simulation is breaking." What they're actually seeing is the engine caught mid-negotiation, which is a much less exciting explanation and also the correct one.
The Feature That Looks Like a Bug
LOD systems work so well, most of the time, that players develop a warped expectation: everything on screen is always fully rendered.
It never was.
Unreal Engine 5's Nanite system tries to change the underlying philosophy here. Instead of swapping discrete LOD tiers, it streams micro-polygon detail dynamically, scaling geometry continuously based on how many pixels a mesh actually occupies on screen. A rock fifty metres away doesn't get a separate low-poly stand-in; it simply renders fewer of its real polygons because they'd be sub-pixel at that distance. The "pop" of traditional LOD transitions shrinks considerably.
But even Nanite doesn't close the book on this. Transparency, characters with complex rigs, skin shaders with subsurface scattering: these still run through traditional LOD pipelines in most implementations, because Nanite handles opaque static geometry most cleanly. So your rocks stop swapping. Your characters don't. Progress is real and it's uneven.
That gap matters, and most coverage glosses over it: LOD thresholds are artistic and performance decisions made by specific teams for specific target hardware. A game built for a mid-range PC from a few years back will switch aggressively compared to something built for current high-end machines. When a port lands on a new platform, developers often retune these thresholds entirely. The same game can look noticeably different across platforms not because of resolution, but because of where the LOD breaks live. That's a creative call, not a technical oversight, and treating it as a flaw misses what's actually happening.
What You Can Actually Do About It
Most PC games expose LOD settings directly, labelled as "Object Detail," "NPC Detail," or folded into a broader "Quality" slider. Pushing higher extends the distance at which full-detail meshes are maintained before the engine swaps down.
It's expensive. A jump from High to Ultra on NPC detail can eat 10 to 15 percent of your frame budget in a dense urban scene, all for fidelity improvements that live mostly in your peripheral vision. So ask yourself: are you actually going to notice, or are you just chasing a number?
If you're on a mid-range GPU and crowds feel sluggish, NPC detail is usually the first thing worth dropping. If you're running something powerful and the world feels thin, it's the first thing worth raising.
Every frame your GPU produces is a small act of triage. The engine is constantly deciding what matters, what you'll notice, and what it can fake convincingly. Off-camera characters are the most fakeable thing in any scene, so they get faked hardest.
The sock puppets behind the wall aren't a glitch. They're the engine being honest about what rendering actually costs, in a room it assumed you'd never walk into.