The first thing I optimize is not Nanite or Lumen—it's understanding where the frame time is going. Otherwise it's easy to spend days tuning the wrong subsystem.
A workflow I use for Unreal projects is:
1. Profile first (always)
Start by determining whether you're CPU-bound, GPU-bound, or both.
Useful tools:
stat unit – frame, game, draw, GPU timesstat gpu – GPU cost breakdownUnreal Insights – game thread, render thread, async loading, asset streamingProfileGPU – detailed GPU pass timingsstat scenerendering, stat rhi, stat foliage, etc. for targeted investigation
Until you know what's consuming 10–20 ms, optimization is mostly guesswork.
2. Eliminate the biggest offenders
I usually prioritize in roughly this order:
| Area | Why it matters |
|---|
| Visibility/culling | Reduces work everywhere else |
| Expensive materials | Often larger wins than geometry |
| Lighting/Lumen | Major GPU cost in open worlds |
| Shadows | Frequently among the most expensive passes |
| World partition/streaming | Prevents CPU and memory spikes |
| Geometry (Nanite/LOD) | Important, but often overestimated |
3. Visibility and occlusion
Open worlds often spend too much time rendering things that shouldn't even be considered.
Check:
- Frustum culling
- Distance culling
- Cull Distance Volumes
- HLOD effectiveness
- Occlusion query efficiency
- Whether large meshes prevent useful occlusion
A surprising amount of GPU time disappears simply by drawing fewer objects.
4. Lumen
Lumen is commonly one of the largest GPU consumers.
Things I'd experiment with:
- Lower software tracing quality
- Reduce reflection quality separately
- Lower update frequency where acceptable
- Shorten view distances
- Disable Lumen for scalability tiers on mid-range hardware
- Use baked/static lighting where gameplay allows
Many teams ship with multiple Lumen quality presets rather than one "Ultra" configuration.
5. Nanite
Nanite is fantastic, but it isn't "free."
Things to inspect:
- Triangle counts after culling
- Cluster count
- Overdraw from foliage
- Materials with expensive pixel shaders
- Very small Nanite meshes that create unnecessary overhead
One common misconception is that Nanite solves all rendering problems. In reality:
- Nanite reduces geometry cost.
- It does not reduce expensive shading.
- It does not solve overdraw.
- It does not make Lumen or shadows cheaper.
6. Foliage
This is often the real killer in open worlds.
Watch for:
- Alpha-tested leaves
- Heavy overdraw
- Wind animation costs
- Shadow casting on distant foliage
- Density that's too high for the target hardware
Reducing foliage shading complexity often yields bigger gains than reducing polygon count.
7. Materials
Shader complexity is frequently underestimated.
Look for:
- Excessive texture samples
- Expensive layered materials
- World Position Offset everywhere
- Pixel Depth Offset
- Translucency
- Complex landscape materials
Switching to simpler material variants at distance can save multiple milliseconds.
8. Shadows
Shadow rendering is commonly among the top GPU passes.
Things to tune:
- Shadow distance
- Number of shadow-casting lights
- Virtual Shadow Map settings
- Foliage shadow casting
- Contact shadows
Disabling shadows on distant decorative assets often has little visual impact but noticeable performance benefits.
9. World streaming
For open worlds, smooth streaming is just as important as average FPS.
Profile:
- Async loading
- Asset decompression
- Texture streaming
- World Partition cell sizes
- Actor initialization spikes
A stable 60 FPS with occasional 80 ms streaming hitches still feels poor.
A typical optimization order
If I inherited an open-world prototype, my checklist would look something like:
- Profile with Unreal Insights and GPU profiler.
- Fix obvious CPU bottlenecks.
- Reduce visibility/rendered objects.
- Optimize shadows.
- Tune Lumen.
- Simplify expensive materials.
- Optimize foliage.
- Tune Nanite/HLOD.
- Optimize streaming and memory.
- Repeat profiling after every major change.
One common pitfall
Many developers jump straight to Nanite because it's the most visible rendering feature. In practice, on mid-range GPUs, I've often seen the biggest gains come from:
- reducing foliage overdraw,
- simplifying materials,
- lowering shadow costs,
- and tuning Lumen quality.
Those changes can recover several milliseconds per frame, whereas aggressive Nanite tuning may only yield modest improvements if geometry wasn't the primary bottleneck.
If you can share your target hardware (for example, an RTX 3060, GTX 1660 Super, RX 6600, or console target), along with your current frame breakdown (Game, Draw, GPU from stat unit and the top entries from stat gpu), I can suggest a more targeted optimization plan.
