Occlusion Culling in Unity: When It Actually Helps and When It Just Costs You

You open the Profiler, the GPU is pinned, and someone in your Discord says the magic words: "just turn on occlusion culling." So you bake it, hit play, and either nothing changes or your frame time somehow gets worse. Occlusion culling is one of those Unity features everyone name-drops and almost nobody actually profiles. Here is what it really does, the two very different systems Unity ships in 2026, and how to tell whether it will help your game or just quietly eat memory.

What occlusion culling actually is

Unity already throws away geometry you cannot see, in a couple of ways. Frustum culling drops anything outside the camera's view frustum, and it happens automatically with no setup. Back-face culling skips the triangles of a mesh that face away from you, per draw, also for free. Occlusion culling is the third one, and it is the only one you have to opt into: it skips objects that are inside the frustum and facing you but are fully hidden behind other opaque objects. The classic case is a room full of props behind a solid wall. You are pointed right at them, but the wall is in the way, so drawing them is wasted work.

Back-face culling (left, off; right, on) is a sibling technique Unity runs for free. Occlusion culling handles a different case: whole objects hidden behind others. Image via Wikimedia Commons (CC BY-SA).

Here is the part people miss. Occlusion culling does not speed up the objects you do render. It just renders fewer of them. That is a real win when a big slice of your scene is hidden, and it is nothing at all when most of what the camera points at is genuinely visible.

Occlusion culling does not make your scene render faster. It makes Unity render less of it. Those are not the same promise.

The baked system (Umbra): still the default for most projects

The occlusion culling most tutorials show you is the baked, CPU-based system, powered under the hood by Umbra. You flag geometry in the Occlusion window: mark solid, non-moving meshes as Occluder Static (they can block) and objects that should get culled as Occludee Static. Then you bake. Umbra voxelizes your scene and precomputes visibility data, basically a lookup of what can possibly be seen from where. At runtime, if your camera has Occlusion Culling ticked, Unity queries that data on the CPU every frame. The query does no dynamic allocations and spreads across cores, so it is cheap to run.

The bake settings that matter

Three parameters do most of the work. Smallest Occluder is roughly the output resolution: bigger values bake faster and cull faster but get more conservative, meaning more false positives where hidden stuff still gets drawn. Smallest Hole is the input resolution and maps almost directly to voxel size. Unity defaults it to 25 cm, and for human-scale games anything from 5 cm to 50 cm is a sane range. Backface Threshold lets you discard visibility from angles the camera will never reach. If you have doors or windows that open and close, drop in Occlusion Portals so Unity can toggle visibility through them, and use Occlusion Areas to tell the baker where the camera can actually go.

The catch with the baked system: only your marked static geometry can occlude. Moving objects can be culled as occludees, but a moving wall will never block anything. And the baked data lives in memory and reloads with the scene, so it is not free. On a large open level with almost no big occluders, you can spend bake time and memory to cull almost nothing.

GPU occlusion culling in Unity 6: the newer option

Unity 6 added a second path that skips baking entirely. GPU occlusion culling runs on the GPU using the GPU Resident Drawer. Instead of precomputed data, Unity builds depth textures from the camera's point of view and uses the depth from the current frame plus the previous frame to decide what is hidden. It renders anything that was unoccluded in either frame and culls the rest. Because it is dynamic, moving objects can occlude other objects, which the baked system never managed.

Turning it on has requirements. It only works with the Forward+ rendering path and on platforms and graphics APIs that support compute shaders. In URP, go to Graphics, open the URP tab, make sure Compatibility Mode (Render Graph disabled) is off, enable the GPU Resident Drawer, then enable GPU Occlusion on the active Universal Renderer. In HDRP, enable the GPU Resident Drawer and then GPU Occlusion in the HDRP asset's Rendering section. No bake, no Occluder Static flags, no Occlusion window.

It is not magic either. The depth work and the drawer have overhead, so on a simple scene you can pay more than you save. Some teams on HDRP have also reported occasional one-frame spikes from the culling pass, so profile it on your target hardware rather than trusting it blind. If you are already fighting draw call counts, it pairs naturally with the batching work covered in draw calls and batching in Unity, since the GPU Resident Drawer is part of the same modern rendering stack.

When it helps, and when it just hurts

Occlusion culling earns its keep when a large, reliable chunk of your scene is hidden most of the time. Think dense interiors, tight corridors, multi-room buildings, and city streets where solid walls block whole blocks of geometry. In those scenes the savings on draw calls and overdraw are real and repeatable.

It tends to do nothing, or cost you, in the opposite cases. Open outdoor terrain has few big occluders, so almost everything in the frustum is visible anyway. Top-down and isometric games often see most of the playfield at once. Small scenes may spend more on the cull test than they save. And if your world is mostly moving objects, the baked system cannot use them as occluders at all. In every one of these, the honest answer is often to leave occlusion culling off and spend your time elsewhere.

How to actually decide

Profile before you bake anything. Open the Profiler and the Frame Debugger, look at your draw call count and how much overdraw you are eating, then test the same scene with occlusion culling on and off on real target hardware, not just your dev rig. If the hidden-object count is high and your numbers drop, keep it. If the graph barely moves, you just learned your bottleneck is somewhere else, and the broader checklist in how to optimize your Unity game for better performance is a better use of the afternoon.

One practical note for asset buyers: well-built environment packs, including the modular kits on DevLoot, usually ship geometry that is already clean and sensibly split, which makes marking occluders far less painful than retrofitting a scene you glued together from mismatched sources. It will not decide whether occlusion culling helps your game. Only your Profiler can do that. But it removes one of the dumber reasons a bake goes sideways.

Occlusion culling is a scalpel, not a switch. Used on a scene that genuinely hides a lot of itself, it is one of the cheapest wins in the engine. Used on a scene that shows you everything anyway, it is bake time and memory you will never get back. Point the Profiler at it first, and let the numbers, not the Discord advice, make the call.