Lumen changed everything about lighting in Unreal Engine 5. For the first time, a production-ready global illumination system ships built into the engine, works in real-time, and requires zero lightmap baking. No more waiting 45 minutes for a lighting build. No more UV1 lightmap issues. No more choosing between visual quality and iteration speed.
But Lumen is not free. On a mid-range GPU, an unoptimized Lumen scene can easily consume 8-12ms per frame — half your budget at 60fps, and potentially all of it. The difference between a Lumen scene that runs at 30fps and one that runs at 60fps is not about removing features. It is about understanding how Lumen actually works and configuring it accordingly.
This guide covers everything: how Lumen traces rays under the hood, which console variables matter most, how to budget your milliseconds, and how to apply these optimizations to different level types. Whether you are building tight interiors or expansive open worlds, the principles are the same — understand the cost, measure the cost, and reduce only what you need to.
Why Lumen Replaced Baked Lightmaps
Before Lumen, Unreal Engine relied on Lightmass — a CPU-based offline baking system that precomputed global illumination into lightmap textures. Lightmass produced beautiful results, but it came with serious costs.
Iteration time was brutal. A medium-complexity level could take 20-60 minutes to bake on production quality settings. Large open-world maps could take hours. Every time you moved a wall, adjusted a light color, or repositioned a prop, you needed to rebake. Level designers spent more time waiting for builds than actually designing levels.
Lightmap UVs were a constant source of problems. Every static mesh needed a second UV channel with non-overlapping islands for lightmap data. Automatically generated lightmap UVs frequently produced artifacts — seams, bleeding, and wasted space. Artists spent time manually creating lightmap UVs or debugging lightmap resolution issues.
Dynamic and static lighting did not blend well. Baked indirect lighting only applied to static and stationary objects. Movable objects received no indirect bounced light, making them look disconnected from the environment. The mismatch between baked and dynamic lighting was one of the most common visual problems in UE4 projects.
Memory overhead was significant. Lightmap textures consumed VRAM. A large level with high-resolution lightmaps could use hundreds of megabytes to gigabytes of lightmap data. For open-world games with streaming, this added substantial memory pressure.
Lumen solves all of these problems by computing global illumination and reflections at runtime. There is nothing to bake. Lights can be moved freely. Objects receive correct indirect lighting regardless of their mobility. The visual quality is consistent across static and dynamic objects. And iteration is instant — change a light, see the result in real-time.
The tradeoff is GPU cost. Lumen requires a meaningful per-frame budget. Our job as developers is to keep that budget under control.
How Lumen Works Under the Hood
Understanding Lumen's internals is not optional if you want to optimize it. You need to know which parts of the pipeline are expensive, which are cheap, and what you are actually paying for when you change a setting.
The Two Tracing Methods
Lumen uses two distinct ray tracing approaches, and it blends them together.
Screen traces are the cheapest. Lumen first traces rays against the information already available in screen-space buffers — the depth buffer, the normal buffer, and the scene color from the previous frame. If a ray hits something visible on screen, Lumen gets the result almost for free. Screen traces are fast because they reuse data that was already computed for rendering.
The limitation is obvious: screen traces can only find surfaces that are visible on screen. If the camera is looking away from a bright red wall, screen traces cannot capture the red bounce light from that wall. This is where the second method comes in.
Mesh distance field traces (also called software ray tracing) are Lumen's primary workhorse. Every static mesh in your scene is represented by a signed distance field — a 3D volume texture that encodes, for every point in space, the distance to the nearest surface. Lumen traces rays through these distance fields to find intersections with geometry.
Distance field tracing is significantly faster than traditional triangle-based ray tracing because the ray can skip large empty regions in a single step. If the distance field says "the nearest surface is 10 meters away," the ray can jump forward 10 meters immediately instead of testing individual triangles.
However, distance fields are approximations. They cannot represent fine geometric detail. Thin objects, highly concave shapes, and objects with interior complexity may not be accurately represented. This is why Lumen sometimes produces soft, slightly imprecise indirect lighting rather than pixel-perfect bounces.
Hardware ray tracing is the third option, available on RTX/RDNA2+ GPUs. When enabled, Lumen can trace rays against actual triangle geometry using hardware RT cores. This produces more accurate results, especially for detailed geometry, but at a higher GPU cost. We will cover hardware RT Lumen in its own section later.
The Lumen Scene
Lumen maintains its own simplified representation of the scene called the Lumen Scene. This is not the same as the main rendering scene. The Lumen Scene stores surface cache cards — flat rectangular patches that represent the surfaces in your level, along with their material properties (base color, emissive, roughness, etc.).
When Lumen traces a ray and hits a surface, it reads the lighting information from these surface cache cards rather than re-evaluating the full material shader. This is a critical optimization. Evaluating PBR materials with multiple texture samples for every ray hit would be prohibitively expensive. Instead, Lumen pre-caches material properties into these cards and updates them incrementally.
The Lumen Scene Detail setting controls the resolution and coverage of these surface cache cards. Higher detail means more cards, higher resolution, and better coverage of small objects — but also more memory and more update cost.
Temporal Accumulation
Lumen does not compute perfect global illumination in a single frame. Instead, it traces a limited number of rays per frame and accumulates the results over multiple frames. This temporal accumulation is why Lumen lighting takes a moment to converge when you move the camera to a new area — you will see the indirect lighting "fill in" over a fraction of a second.
This design is intentional. By spreading the work across frames, Lumen keeps per-frame cost manageable. The downside is that fast camera movement or rapidly changing lighting can produce temporal artifacts — ghosting, light leaking, or slow convergence. Understanding this helps you make informed tradeoff decisions.
The 2-5ms Target Budget
At 60fps, your total frame budget is 16.67ms. A typical UE5 frame distributes that budget roughly as follows:
- Base pass (geometry, materials): 3-5ms
- Shadow rendering: 1-3ms
- Lumen GI + reflections: 2-5ms
- Post-processing: 1-2ms
- Game thread (logic, AI, physics): 3-5ms
- Remaining headroom: 1-3ms
The Lumen budget of 2-5ms is a guideline, not a hard rule. On a powerful GPU (RTX 4080 or equivalent), you might afford 5ms of Lumen cost and still hit 60fps comfortably. On a mid-range GPU (RTX 4060 or console), you need to keep Lumen under 3ms to leave room for everything else.
How to measure Lumen cost:
Open the console and type stat gpu. This gives you a per-category GPU timing breakdown. Look for these rows:
- Lumen Scene Update — cost of updating the Lumen Scene surface cache
- Lumen Screen Probe Gather — cost of the screen-space probe tracing for GI
- Lumen Reflections — cost of Lumen reflection tracing
- Lumen Radiosity — cost of the radiosity pass that distributes light between surface cache cards
The sum of these rows is your total Lumen cost. On the stat gpu readout, you can see exactly which component is eating your budget.
You can also use profilegpu for a single-frame detailed breakdown, or the Unreal Insights profiler for more granular analysis.
Console Variables That Matter Most
Lumen exposes dozens of console variables. Most of them are internal debug settings that you should not touch. Here are the ones that actually matter for shipping games.
r.Lumen.TraceMeshSDFs
Default: 1 (enabled)
This enables mesh distance field tracing. Disabling it forces Lumen to rely entirely on screen traces and the global distance field, which significantly reduces quality but also reduces cost. Generally you want this on. Only disable for extremely performance-constrained scenarios.
r.Lumen.ScreenProbeGather.TracingOctahedronResolution
Default: 8
This controls how many rays each screen probe traces. The value represents one dimension of an octahedral mapping, so a value of 8 means 8x8 = 64 ray directions per probe. Reducing to 6 (36 rays) or even 4 (16 rays) significantly reduces tracing cost but also reduces GI quality — you will see more noise, slower convergence, and less accurate color bleeding.
Recommendation: 8 for high quality, 6 for balanced, 4 for performance mode.
r.Lumen.ScreenProbeGather.ScreenSpaceBentNormal
Default: 1
Enables screen-space bent normal calculations that improve contact shadowing for indirect lighting. Costs approximately 0.2-0.3ms. Disable for a small performance gain if the visual difference is acceptable.
r.Lumen.Reflections.Allow
Default: 1
Enables Lumen reflections. Lumen reflections can cost 1-2ms on their own. If your scene does not have many reflective surfaces, or if you can get acceptable results with screen-space reflections (SSR) alone, disabling Lumen reflections is one of the biggest single savings available.
r.Lumen.Reflections.MaxRoughnessToTrace
Default: 0.4
Lumen only traces reflection rays for surfaces with roughness below this threshold. Increasing this value means more surfaces get ray-traced reflections (more expensive). Decreasing it means only very smooth/glossy surfaces get Lumen reflections, and rougher surfaces fall back to the GI probe data.
Recommendation: Keep at 0.4 or lower. Most surfaces with roughness above 0.4 do not show visually distinct reflections anyway.
r.Lumen.DiffuseIndirect.Allow
Default: 1
The master switch for Lumen diffuse GI. You almost certainly want this on — it is the primary reason to use Lumen. Disabling it removes all indirect bounce lighting.
r.LumenScene.SurfaceCache.MeshCardsMinSize
Default: 1.0
Minimum mesh size (in world units) for Lumen to generate surface cache cards. Meshes smaller than this value are skipped by the Lumen Scene. Increasing this value excludes small props from Lumen, reducing the Lumen Scene update cost.
Recommendation: For open-world scenes with thousands of small props, consider increasing to 10-25. Small rocks, debris, and grass should not contribute to the Lumen Scene.
r.Lumen.ScreenProbeGather.DownsampleFactor
Default: 16
Controls the density of screen probes. A factor of 16 means one probe per 16x16 pixel block. Increasing to 32 means one probe per 32x32 block — half the probes, roughly half the tracing cost, but noticeably lower quality with potential blockiness in indirect lighting.
Recommendation: 16 for shipping quality, 32 for aggressive performance mode.
Mesh Distance Field Resolution Tuning
Mesh distance fields are the backbone of Lumen's software ray tracing. Every static mesh in your project generates a distance field volume during import. The resolution of this volume determines how accurately Lumen can trace against the mesh.
Understanding Distance Field Resolution
Each mesh's distance field is stored as a 3D volume texture. The default resolution is calculated automatically based on the mesh's bounding box size. Larger meshes get higher resolution distance fields. You can override this per-mesh in the Static Mesh Editor under Build Settings > Distance Field Resolution Scale.
The problem with too-low resolution: The distance field becomes a poor approximation of the actual geometry. Lumen rays pass through thin walls. Indoor spaces leak light from outside. Concave surfaces are filled in, causing incorrect shadowing.
The problem with too-high resolution: Memory usage increases significantly (distance fields can consume 100+ MB of VRAM across a full scene), and the Lumen Scene update cost increases.
Practical Guidelines
Large architectural meshes (walls, floors, ceilings): Ensure these have adequate distance field resolution. If you see light leaking through a wall, increase the Distance Field Resolution Scale to 2.0 or 3.0 for that mesh. Architectural meshes are the foundation of correct indoor GI, so they are worth the extra memory.
Medium props (furniture, vehicles, large rocks): Default resolution is usually fine. These contribute to GI and reflections but rarely cause light leak issues.
Small props (cups, bottles, debris, foliage): Consider excluding these from distance field generation entirely by disabling "Generate Mesh Distance Field" on the static mesh. Alternatively, increase r.LumenScene.SurfaceCache.MeshCardsMinSize to globally exclude small meshes.
Foliage and vegetation: Foliage meshes are particularly problematic for distance fields because they consist of many small, thin polygons (leaves, blades of grass). The distance field for a tree often looks like a solid blob rather than a tree shape. For foliage, Lumen relies more on the surface cache and screen traces rather than accurate distance field hits. You can often reduce foliage distance field resolution without visible impact.
Memory Budget
Monitor your distance field memory with stat distancefields in the console. This shows total distance field texture memory. A reasonable budget is:
- Small/medium scenes: 50-150 MB
- Large open-world scenes: 150-400 MB
- Extreme cases: 400+ MB (consider optimization)
If you are over budget, sort your meshes by distance field size and reduce resolution on the largest offenders that are not architecturally important.
Lumen Scene Detail Settings
The Lumen Scene Detail setting in the Post Process Volume (or project settings) controls the resolution and coverage of Lumen's surface cache. This is distinct from distance field resolution — surface cache cards store material colors and lighting information, while distance fields store geometry shapes.
What Lumen Scene Detail Controls
At higher detail levels:
- More surface cache cards are generated per mesh
- Cards have higher resolution
- Smaller meshes are included in the surface cache
- The surface cache covers more of the scene
At lower detail levels:
- Fewer cards, lower resolution
- Small meshes are excluded
- The surface cache may miss surfaces, causing GI artifacts on uncovered areas
Practical Settings
Lumen Scene Detail = 1.0 (default): Good balance for most scenes. Costs approximately 1-2ms for Lumen Scene updates.
Lumen Scene Detail = 0.5: Significant cost reduction (can save 0.5-1ms). Works well for outdoor scenes where distant objects do not need precise surface cache coverage. Indoor scenes may show artifacts on surfaces that lose their cache cards.
Lumen Scene Detail = 1.5-2.0: Higher quality, useful for architectural visualization or scenes with many small objects that need to participate in GI. Adds 0.5-1ms cost.
Recommendation for 60fps: Start at 1.0 and reduce to 0.5 if you need to save budget. Only increase above 1.0 if you have specific quality requirements and budget headroom.
Reflection Optimization
Lumen reflections are often the single most expensive component of Lumen, sometimes exceeding the cost of GI itself. This is because reflection rays need to trace at higher quality to produce visually convincing results — low-quality GI is perceived as "soft lighting," but low-quality reflections are perceived as "broken reflections."
Strategies for Reducing Reflection Cost
1. Limit the number of reflective surfaces. This is the most effective optimization. Review your materials and ask: does this surface actually need accurate reflections? Concrete, wood, fabric, dirt, and any surface with roughness above 0.5 does not produce visible specular reflections. Only glass, metal, water, polished stone, and wet surfaces need Lumen reflections.
2. Use r.Lumen.Reflections.MaxRoughnessToTrace. Setting this to 0.3 instead of the default 0.4 excludes surfaces with moderate roughness from reflection tracing. This can eliminate 30-50% of reflection rays.
3. Consider disabling Lumen reflections entirely. If your scene does not feature prominent glossy surfaces, you can disable Lumen reflections (r.Lumen.Reflections.Allow 0) and rely on screen-space reflections (SSR) or reflection capture actors for any remaining reflective surfaces. SSR is much cheaper than Lumen reflections, though it only works for objects visible on screen.
4. Lower reflection quality. r.Lumen.Reflections.DownsampleFactor controls the resolution of the reflection tracing. Increasing from the default value reduces cost but introduces blur and noise in reflections.
5. Reflection probe fallback. Place reflection capture actors in key locations as fallback for when Lumen reflections are disabled or reduced. These capture actors are baked (or updated infrequently) and provide reasonable reflections at minimal runtime cost.
The Mirror Problem
Flat, perfectly smooth mirrors (roughness 0.0, metallic 1.0) are the worst case for Lumen reflections. They require high-quality ray tracing to look correct. If your game features mirrors, consider:
- Limiting mirrors to specific locations and using a render-to-texture approach (rendering a second camera view into a texture)
- Accepting slightly lower reflection quality on mirrors and relying on temporal accumulation to clean up noise
- Using planar reflections as an alternative for large flat reflective surfaces
How Scatter Density Impacts Lumen
If you are using our Procedural Placement Tool to scatter props, foliage, and environmental detail, the scatter density directly affects Lumen performance. Every scattered instance that generates a distance field contributes to the Lumen Scene.
The Compounding Cost
A single rock mesh with a distance field costs effectively nothing for Lumen. But scatter 5,000 rocks across a terrain, and Lumen now needs to:
- Store 5,000 distance field instances
- Trace against all visible instances during ray marching
- Potentially generate surface cache cards for each instance
With Procedural Placement Tool, this is easy to manage because the tool supports distance-based density falloff, biome zone restrictions, and LOD integration. The key settings for Lumen-friendly scattering:
Cull distance: Ensure scattered instances cull at reasonable distances. Rocks at 500 meters do not need to exist for Lumen. Set aggressive cull distances and rely on HLOD or impostor meshes for distant detail.
Distance field generation per mesh: In the Procedural Placement Tool scatter settings, you can flag certain scatter layers to use meshes with distance field generation disabled. Grass, small flowers, ground debris, and other tiny props should skip distance field generation.
Instance count budgets: Monitor your total instance count. As a rough guideline, keep Lumen-participating instances (those with distance fields) under 10,000-20,000 in any given streaming level. Beyond that, distance field tracing cost starts to climb noticeably.
Biome-zone awareness: The Procedural Placement Tool lets you define biome zones with independent density settings. For zones near the player's typical path (roads, towns, quest locations), you can afford higher density. For distant fill zones, reduce density and rely on billboard/impostor replacements.
MCP Automation for Lighting Configuration
Manually tweaking dozens of console variables across multiple levels is tedious and error-prone. Our Unreal MCP Server can automate Lumen configuration through its 207 tools across 34 categories.
What MCP Can Automate
Bulk console variable application. Define a "Lumen Performance Profile" as a set of console variable values and apply it across all levels in your project simultaneously. For example, create profiles for "Ultra," "High," "Medium," and "Low" quality presets that adjust Lumen settings appropriately.
Per-level lighting audits. Use MCP to iterate through every level, count shadow-casting lights, measure total distance field memory, and report which levels exceed your budget targets. Instead of manually opening each level and checking stat gpu, automate the data collection.
Post Process Volume configuration. MCP can create, modify, and configure Post Process Volumes with specific Lumen settings. If you need to add a performance-tuned Post Process Volume to 30 sublevels, MCP can do it in seconds.
Light actor management. Audit all light actors in a level — identify lights with unnecessarily high shadow resolution, lights that cast dynamic shadows when they should not, or point lights that could be converted to spotlights for better shadow performance.
Material property auditing. Scan all materials in a level for roughness values below 0.3 (which trigger expensive reflections) and generate a report. This helps you identify which materials are driving reflection cost.
With the Unreal MCP Server, these operations become scriptable through natural language commands to an AI assistant. Ask it to "set all post process volumes in the cave levels to use Lumen Scene Detail 0.5" and it handles the iteration, property changes, and verification.
Room-by-Room vs Open-World Strategies
Lumen optimization is fundamentally different for interiors and exteriors. The same settings that work for an open field will produce terrible results in a small room, and vice versa.
Interior / Room-Based Levels
Indoor environments are Lumen's sweet spot for quality but its worst case for performance. In a room, light bounces multiple times between walls, ceiling, and floor. This multi-bounce GI is what makes indoor Lumen lighting look stunning — warm light spilling around corners, color bleeding from colored walls, soft ambient fill in dark areas.
The performance challenge: indoor scenes have many occluded surfaces. Lumen rays hit geometry quickly (short trace distances), which means more surface cache lookups and more radiosity calculations. Additionally, indoor scenes tend to have more light sources in close proximity — ceiling lights, lamps, windows, emissive screens.
Optimization strategies for interiors:
- Reduce light source count. Consolidate multiple small ceiling lights into fewer, broader lights. Use emissive materials for visual detail but minimize actual light actors.
- Increase Lumen Scene Detail slightly (1.0-1.25). Indoor surfaces at close range need good surface cache coverage to avoid artifacts.
- Keep distance field resolution high on walls and ceilings. Light leaking through walls is immediately visible indoors.
- Use rect lights instead of point lights. Rect lights produce better soft shadows and integrate more naturally with Lumen's surface cache.
- Careful placement of Post Process Volumes. Use per-room Post Process Volumes with tuned Lumen settings rather than one global volume.
Open-World Levels
Open worlds have the opposite characteristics: long trace distances, fewer bounces that matter (the sky provides most ambient light), and vast numbers of scattered objects. The visual bar for GI accuracy is lower outdoors because players are accustomed to relatively flat ambient lighting in outdoor environments.
Optimization strategies for open worlds:
- Reduce Lumen Scene Detail to 0.5-0.75. Distant objects do not need high-resolution surface cache cards.
- Aggressive cull distances for distance fields. Only objects within 100-200 meters need to participate in Lumen tracing.
- Lower ScreenProbeGather resolution. Outdoor GI is dominated by sky lighting and a single directional light. Fewer probe rays are needed to capture this.
- Disable Lumen reflections outdoors. Unless you have a lake or other large reflective surface, SSR plus reflection captures handle outdoor reflections adequately.
- Use the Global Distance Field instead of per-mesh tracing for distant areas. The global distance field is a lower-resolution merged representation of all geometry. It is cheaper to trace but less accurate. For distant GI, this is an acceptable tradeoff.
Transitional Spaces
The hardest optimization challenge is transitions between interior and exterior — doorways, windows, cave entrances. In these areas, Lumen needs to handle both short indoor bounces and long outdoor traces simultaneously.
Strategies:
- Use occluder volumes or portal actors to help Lumen understand interior/exterior boundaries
- Place Post Process Volume boundaries at transitions to switch between indoor and outdoor Lumen presets
- Accept slightly lower quality at transitions and rely on temporal accumulation to smooth the blending
Hardware Ray Tracing with Lumen
When Hardware Ray Tracing (HRT) is enabled, Lumen can optionally use it for some or all of its tracing workload. Instead of tracing against mesh distance fields (which are approximations), HRT traces against actual triangle geometry using the GPU's dedicated RT cores.
When to Use Hardware RT Lumen
Use it when:
- You are targeting high-end PC hardware (RTX 3070+) and can afford the additional cost
- Your scene has geometry that distance fields represent poorly (thin walls, dense meshwork, complex concave interiors)
- Visual accuracy is a priority and you have frame budget headroom
- You are seeing persistent light leaking that distance field resolution increases cannot fix
Avoid it when:
- You are targeting consoles (PS5, Xbox Series X) where HRT Lumen is more expensive due to less capable RT hardware
- You are targeting 60fps on mid-range hardware
- Your scene is primarily outdoor with simple geometry that distance fields represent well
- You need to support GPUs without RT cores
Performance Characteristics
Hardware RT Lumen typically costs 1-3ms more than software (distance field) Lumen for GI. For reflections, HRT Lumen is more competitive because reflection quality benefits significantly from accurate geometry tracing.
A common hybrid approach: use software tracing for diffuse GI (where the approximation is acceptable) and hardware tracing for reflections (where accuracy matters more). This is configured with:
r.Lumen.DiffuseIndirect.HardwareRayTracing 0
r.Lumen.Reflections.HardwareRayTracing 1This gives you accurate reflections at a moderate cost increase, while keeping diffuse GI at the cheaper software tracing cost.
Hardware RT Settings
r.Lumen.HardwareRayTracing.LightingMode: Controls whether HRT uses hit lighting (evaluating materials at ray hit points) or surface cache lighting (looking up pre-cached lighting at hit points). Surface cache mode is cheaper. Hit lighting is more accurate for emissive surfaces and small bright lights.
r.RayTracing.Culling: Enables culling of objects from the ray tracing acceleration structure based on distance. Essential for open worlds where you do not want to trace against objects 500 meters away.
Common Mistakes and How to Avoid Them
Mistake 1: Too Many Small Light Sources
Every point light and spot light in your scene adds cost to Lumen's radiosity calculations and surface cache updates. A common mistake is placing dozens of small lights — one for each candle, lamp, or fluorescent fixture — when a few strategically placed lights would achieve the same visual result.
Fix: Use emissive materials for visual light sources and minimize actual light actors. A row of fluorescent lights can be represented by one or two rect lights rather than ten individual lights. Group nearby lights into a single light where possible.
Mistake 2: Ignoring Mesh Distance Field Warnings
The Unreal Editor shows warnings when mesh distance fields fail to generate or produce poor quality results. These warnings are easy to dismiss, but they indicate meshes that Lumen cannot trace correctly — leading to light leaking, missing GI, or incorrect shadows.
Fix: Address distance field warnings during content creation, not at optimization time. Ensure meshes are watertight (no holes), have reasonable polygon density, and do not have extremely thin sections.
Mistake 3: Setting Everything to Movable
When all objects are set to Movable mobility, Lumen treats them as potentially changing every frame. This forces more frequent Lumen Scene updates and prevents certain optimizations that apply to static geometry.
Fix: Set objects that never move to Static mobility. This allows Lumen to cache their distance fields and surface cards more efficiently. Reserve Movable for objects that actually move during gameplay.
Mistake 4: Not Using Lumen Scene Visualization
Lumen has built-in visualization modes that show you exactly what Lumen sees. These are accessible via the viewport show flags or ShowFlag.VisualizeLumenScene 1.
Fix: Regularly check the Lumen Scene visualization to verify that important surfaces have adequate surface cache coverage. If a wall is missing from the Lumen Scene visualization, it will not receive or contribute to GI correctly.
Mistake 5: Optimizing Without Measuring
The most common mistake is guessing at what is expensive. Developers disable features, reduce quality, and make their game look worse without knowing if those changes actually saved any meaningful performance.
Fix: Always measure before and after. Use stat gpu to get Lumen-specific timings. Use GPU profilers (RenderDoc, Nsight, PIX) for detailed analysis. Make changes based on data, not intuition.
Mistake 6: Forgetting About Final Gather Quality
Lumen's final gather (the step that combines probe data into per-pixel GI) has its own quality setting. If this is too low, you get visible probe artifacts — blocky indirect lighting that looks like a grid pattern.
Fix: Ensure final gather quality is high enough to avoid visible artifacts. If you are seeing grid-like patterns in indirect lighting, increase the final gather quality or reduce the downsample factor.
Benchmarks at Each Optimization Level
We profiled a representative urban environment (city block with buildings, props, vehicles, vegetation, and interior spaces) on three GPU tiers. Here are the Lumen-specific costs at each optimization level.
Test Scene Description
- 4 building interiors with furnished rooms
- Approximately 15,000 scattered props and vegetation instances (placed with Procedural Placement Tool)
- 28 light sources (12 outdoor, 16 indoor)
- One directional light with cascaded shadows
- 1920x1080 rendering resolution
Ultra Quality Settings
Settings: Default Lumen Scene Detail (1.0), TracingOctahedronResolution 8, Lumen Reflections enabled, MaxRoughnessToTrace 0.4, Hardware RT off.
| GPU Tier | GI Cost | Reflection Cost | Scene Update | Total Lumen |
|---|---|---|---|---|
| RTX 4080 | 2.1ms | 1.4ms | 0.8ms | 4.3ms |
| RTX 4060 | 3.8ms | 2.5ms | 1.2ms | 7.5ms |
| PS5/XSX | 4.2ms | 2.8ms | 1.4ms | 8.4ms |
At Ultra, only the RTX 4080 can comfortably hit 60fps. The RTX 4060 and consoles are in 30fps territory with Lumen alone consuming nearly half the budget.
High Quality Settings
Settings: Lumen Scene Detail 0.75, TracingOctahedronResolution 6, Lumen Reflections enabled, MaxRoughnessToTrace 0.3.
| GPU Tier | GI Cost | Reflection Cost | Scene Update | Total Lumen |
|---|---|---|---|---|
| RTX 4080 | 1.5ms | 1.0ms | 0.6ms | 3.1ms |
| RTX 4060 | 2.7ms | 1.8ms | 0.9ms | 5.4ms |
| PS5/XSX | 3.0ms | 2.0ms | 1.0ms | 6.0ms |
High quality is a solid 60fps on the RTX 4080 with headroom. The RTX 4060 is tight but achievable. Consoles still need further reduction.
Medium Quality Settings
Settings: Lumen Scene Detail 0.5, TracingOctahedronResolution 4, Lumen Reflections disabled (SSR fallback), MeshCardsMinSize 15.
| GPU Tier | GI Cost | Reflection Cost | Scene Update | Total Lumen |
|---|---|---|---|---|
| RTX 4080 | 0.9ms | 0.3ms (SSR) | 0.4ms | 1.6ms |
| RTX 4060 | 1.6ms | 0.5ms (SSR) | 0.6ms | 2.7ms |
| PS5/XSX | 1.8ms | 0.6ms (SSR) | 0.7ms | 3.1ms |
At Medium, all three GPU tiers hit 60fps comfortably. The visual quality is noticeably reduced — softer GI, less accurate color bleeding, SSR-only reflections — but still dramatically better than no GI at all.
Low Quality Settings (Fallback)
Settings: Lumen Scene Detail 0.25, TracingOctahedronResolution 4, DownsampleFactor 32, Reflections disabled, ScreenProbeGather.ScreenSpaceBentNormal off.
| GPU Tier | GI Cost | Reflection Cost | Scene Update | Total Lumen |
|---|---|---|---|---|
| RTX 4080 | 0.5ms | 0.2ms (SSR) | 0.3ms | 1.0ms |
| RTX 4060 | 0.9ms | 0.4ms (SSR) | 0.4ms | 1.7ms |
| PS5/XSX | 1.0ms | 0.4ms (SSR) | 0.5ms | 1.9ms |
Low quality is a last resort. The GI is noticeable but crude — it provides basic ambient direction and color tinting but lacks the subtlety of higher settings. Still, even this minimal Lumen setup looks meaningfully better than flat ambient lighting with no GI.
Key Takeaways from Benchmarks
- Reflections are the easiest win. Disabling Lumen reflections and falling back to SSR saves 1-2ms with a visual cost that many players will not notice.
- TracingOctahedronResolution is high-impact. Going from 8 to 4 reduces GI cost by approximately 50%.
- Lumen Scene Detail scales linearly. Halving the detail roughly halves the scene update cost.
- The gap between GPU tiers narrows at lower settings. At Ultra, the RTX 4080 is 2x faster than the RTX 4060 for Lumen. At Medium, it is only 1.7x faster.
Implementing Quality Scalability
For a shipping game, you should not pick one Lumen configuration. You should implement scalability settings that let players (or your auto-detection system) choose the right quality level for their hardware.
Using UE5's Scalability System
Unreal Engine's built-in scalability system (Engine > Config > Scalability) supports Global Illumination quality presets. You can customize these presets in BaseScalability.ini or your project's DefaultScalability.ini:
[GlobalIlluminationQuality@0]
r.Lumen.DiffuseIndirect.Allow=1
r.Lumen.ScreenProbeGather.TracingOctahedronResolution=4
r.Lumen.ScreenProbeGather.DownsampleFactor=32
r.Lumen.Reflections.Allow=0
r.LumenScene.SurfaceCache.MeshCardsMinSize=20
[GlobalIlluminationQuality@1]
r.Lumen.DiffuseIndirect.Allow=1
r.Lumen.ScreenProbeGather.TracingOctahedronResolution=6
r.Lumen.ScreenProbeGather.DownsampleFactor=16
r.Lumen.Reflections.Allow=0
r.LumenScene.SurfaceCache.MeshCardsMinSize=10
[GlobalIlluminationQuality@2]
r.Lumen.DiffuseIndirect.Allow=1
r.Lumen.ScreenProbeGather.TracingOctahedronResolution=8
r.Lumen.ScreenProbeGather.DownsampleFactor=16
r.Lumen.Reflections.Allow=1
r.Lumen.Reflections.MaxRoughnessToTrace=0.3
r.LumenScene.SurfaceCache.MeshCardsMinSize=5
[GlobalIlluminationQuality@3]
r.Lumen.DiffuseIndirect.Allow=1
r.Lumen.ScreenProbeGather.TracingOctahedronResolution=8
r.Lumen.ScreenProbeGather.DownsampleFactor=16
r.Lumen.Reflections.Allow=1
r.Lumen.Reflections.MaxRoughnessToTrace=0.4
r.LumenScene.SurfaceCache.MeshCardsMinSize=1These presets map to Low (0), Medium (1), High (2), and Ultra (3). The scalability system applies them automatically based on hardware detection or player choice.
Runtime Switching
Players should be able to change GI quality at runtime without restarting the game. Lumen supports this — changing console variables takes effect within a few frames as the temporal accumulation reconverges. Build your settings UI to apply these changes through UGameUserSettings or direct console variable modification.
Advanced: Per-Level Lumen Tuning with MCP
For studios with dozens or hundreds of levels, manually tuning Lumen settings per level is impractical. The Unreal MCP Server enables a systematic approach.
Automated Profiling Pipeline
- Scan each level for key metrics: total light count, total distance field memory, number of Lumen-participating instances, interior vs exterior ratio
- Classify levels into categories: outdoor-heavy, indoor-heavy, mixed, performance-critical (boss fights, cutscenes)
- Apply category-specific Lumen presets through Post Process Volume configuration
- Generate per-level performance reports that flag levels exceeding budget targets
This pipeline turns Lumen optimization from a per-level manual task into a project-wide automated process. When a new level is created, MCP can analyze it and suggest (or automatically apply) the appropriate Lumen configuration.
Integration with Procedural Placement Tool
If you are using the Procedural Placement Tool for environment population, MCP can cross-reference scatter density with Lumen budgets. If a scatter layer pushes the total instance count above the Lumen budget, MCP can flag it and suggest density reductions or distance field exclusions for specific scatter layers.
Conclusion
Lumen optimization is not about choosing between quality and performance. It is about understanding the system well enough to get the quality you need at the performance you require. The key principles:
- Measure first. Use
stat gpuand profiling tools before making any changes. - Reflections are the biggest lever. Disabling or reducing Lumen reflections typically saves 1-2ms with the least visual impact.
- Probe resolution and scene detail scale predictably. Use the benchmarks above as a starting point and adjust based on your specific scenes.
- Indoor and outdoor scenes need different settings. Do not use one global configuration.
- Automate with MCP. For projects with many levels, automate Lumen configuration and profiling using the Unreal MCP Server.
- Implement scalability. Ship multiple quality presets and let players or auto-detection choose.
The era of baked lightmaps is over. Lumen gives us dynamic global illumination that was previously impossible in real-time. With proper optimization, you can ship it at 60fps — even on mid-range hardware.