Every time you load into a dense open world or a tightly packed urban environment, your GPU faces an almost absurd problem: the game world contains far more geometry than any single frame could ever show. Mountains hidden behind buildings, entire underground districts above you, enemy models buried behind a concrete wall — all of it technically exists in memory at once. So how does your hardware stay above 60 frames per second without melting? The answer is occlusion culling, one of the most quietly important techniques in real-time rendering.
At its core, occlusion culling is the process of identifying which objects in a scene are hidden from the camera's current point of view, then simply not drawing them at all. If your character is standing in a narrow corridor, the rendering engine doesn't need to process the entire city block on the other side of the wall. Occlusion culling figures that out before the draw calls ever reach the GPU, saving enormous amounts of work.
The most established method is called hardware occlusion queries. The engine draws simplified proxy shapes — often called occluders — for large solid objects first. It then tests whether smaller or more distant objects fall entirely behind those proxies in screen space. Any object that fails the test gets skipped for that frame. This sounds simple, but the timing is tricky: the GPU needs a moment to return the query result, which means engines often work with results from the previous frame or two, introducing a brief lag that must be managed carefully to avoid objects popping in at the wrong moment.
A more sophisticated approach is hierarchical Z-buffering, or Hi-Z culling. Here, the engine builds a pyramid of depth information — called a depth mipmap — where each level stores the maximum depth value from the level below it. Testing whether an object is occluded then becomes a matter of checking its bounding box against the appropriate mipmap level, rather than testing every pixel individually. This scales extremely well with scene complexity and runs almost entirely on the GPU, making it a favourite in modern engines.
Software-based culling systems still have a role too, particularly for managing streaming and level-of-detail decisions before data even reaches the GPU. Precomputed visibility sets, used in more static environments, bake occlusion relationships offline so the engine can look them up at runtime with almost no cost.
All of these techniques work together in layered stacks inside engines like Unreal and Unity, and game teams spend significant time tuning their occluder meshes and query budgets. When culling is set up poorly, you get the dreaded geometry pop-in that breaks immersion. When it's dialled in correctly, you simply never notice it — which is exactly the point.
Understanding occlusion culling is a good reminder that the smoothness of a modern game is never just about raw GPU power. It's about how cleverly the engine avoids work in the first place.
