What is the difference between Lumen screen traces and hardware ray tracing?

Screen traces (the default) use the screen-space depth buffer and signed distance fields to approximate ray tracing on any hardware. Hardware ray tracing uses dedicated RT cores on supported GPUs to cast actual rays against triangle geometry, producing more accurate results with fewer artifacts but at a higher performance cost. Hardware ray tracing eliminates most screen-space artifacts like light leaking behind off-screen objects.

How do I fix light leaking through walls with Lumen in UE5?

Light leaking through walls is usually caused by insufficient mesh distance field resolution on the wall meshes or walls that are too thin for Lumen to trace against accurately. Increase the Distance Field Resolution Scale on the affected static meshes to 2.0 or higher, ensure walls have sufficient thickness (at least 10-20 cm), and consider enabling hardware ray tracing for Lumen reflections to eliminate screen-space trace artifacts.

Fix: Unreal Lumen Lighting Flickering and Artifacts

Quick answer: Lumen GI flickering is most commonly caused by mesh distance field resolution being too low, thin or small meshes that Lumen's screen traces cannot resolve accurately, or the Lumen Scene Detail setting being too low for the scale of your environment.

Here is how to fix Unreal Lumen lighting flickering artifacts. Lumen is Unreal Engine 5's default global illumination and reflections system, and when it works it is genuinely impressive — dynamic, fully real-time lighting without baking a single lightmap. But when it does not work, you get flickering indirect light, light that bleeds through solid walls, shimmering artifacts on surfaces, and shadows that dance every time the camera moves. These problems are solvable. They almost always come down to distance field resolution, scene detail settings, or a mismatch between your geometry and Lumen's tracing method.

The Symptom

You have a scene lit with Lumen global illumination. In motion, the indirect lighting flickers — surfaces randomly brighten and darken frame to frame, particularly in interior spaces. You notice bands of light on walls that were not placed by any light source, or bright patches that appear and vanish as you rotate the camera. In some areas, light visibly leaks through walls that should be completely opaque, casting impossible bounced light into rooms that should be dark.

The problem tends to be worst in enclosed spaces: hallways, rooms with thin walls, areas where geometry is tightly packed. Outdoor scenes with large open spaces often look fine, but step indoors and the flickering becomes obvious. It is especially noticeable on flat surfaces like walls and ceilings where even small variations in indirect light intensity are clearly visible against the uniform surface color.

You may also see shimmering artifacts around the edges of objects, particularly when the camera is in motion. Reflections on shiny surfaces might pop in and out or display obviously wrong colors. In extreme cases, entire surfaces flash bright white or deep black for a single frame before returning to normal. These are not random GPU glitches — they are systematic artifacts of how Lumen traces light through your scene.

What Causes This

1. Low mesh distance field resolution. Lumen's software ray tracing relies on signed distance fields (SDFs) generated from your static meshes. Each mesh gets a voxelized representation that Lumen traces rays against. When the distance field resolution is too low, the SDF does not accurately represent the mesh geometry. Thin features disappear, sharp edges become rounded blobs, and gaps appear in surfaces that should be solid. The result is light leaking through geometry that Lumen cannot "see" properly, and flickering as the tracing alternates between hitting and missing the poorly-represented surface.

2. Lumen Scene Detail too low for the environment scale. The Lumen Scene Detail setting controls the resolution of the voxelized scene representation that Lumen uses for its final gather. At the default value of 1.0, small-scale geometry and narrow passages may not be resolved accurately. Lumen may miss thin walls, small props, or tight corridors entirely, causing light to pass through them as if they do not exist. For architectural interiors or scenes with fine geometric detail, this value often needs to be 2.0 or higher.

3. Screen trace limitations. By default, Lumen uses screen-space traces as its first pass. These traces can only see what is currently visible on screen. If a bright light source or a reflective surface is just off screen, Lumen's screen traces cannot account for its contribution, leading to sudden changes in lighting as objects enter and leave the viewport. This is the primary cause of camera-motion-dependent flickering — the GI changes as the visible scene changes, even if the actual lighting conditions have not changed at all.

4. Geometry too thin for Lumen to trace against. Walls that are only a few centimeters thick in world units may not generate usable distance fields. Lumen needs geometry with actual volume to trace against reliably. Paper-thin planes, single-sided meshes, and walls modeled at real-world thicknesses below roughly 10 cm are common sources of light leaking. The distance field for these meshes collapses to near-zero width, and rays pass straight through.

The Fix

Step 1: Increase mesh distance field resolution on affected meshes. Select the static mesh assets that form your walls, floors, and ceilings. In the Static Mesh Editor, find the Distance Field Resolution Scale property under the Build Settings section and increase it from the default 1.0 to 2.0 or higher. For critical enclosure geometry, values of 3.0 to 5.0 may be appropriate. Then force a distance field rebuild.

// Console command to force rebuild all distance fields
// Run this in the editor console after changing resolution scales
r.DistanceFields.ForceRebuild 1

// To visualize distance fields in the viewport, use:
r.DistanceFieldAO.VisualizeDistanceField 1

You can also adjust the distance field resolution per mesh in C++ when importing or configuring assets programmatically. This is useful for batch-processing large numbers of meshes in a project.

// Adjusting distance field resolution on a static mesh in C++
#include "Engine/StaticMesh.h"

void AMyActor::FixDistanceFieldResolution()
{
    UStaticMesh* WallMesh = LoadObject<UStaticMesh>(
        nullptr,
        TEXT("/Game/Environment/Meshes/SM_Wall_Interior")
    );

    if (WallMesh)
    {
        // Increase distance field resolution scale
        WallMesh->SourceModels[0].BuildSettings.DistanceFieldResolutionScale = 3.0f;

        // Force rebuild of the distance field
        WallMesh->Build(false);
        WallMesh->PostEditChange();

        UE_LOG(LogTemp, Log, TEXT("Distance field rebuilt for %s"),
            *WallMesh->GetName());
    }
}

Step 2: Raise Lumen Scene Detail and adjust update speeds. Open your PostProcessVolume (or create one that covers the entire level with Infinite Extent enabled). Under the Lumen Global Illumination section, increase Lumen Scene Detail. For interior-heavy scenes, 2.0 is a good starting point. Also increase the Lumen Scene Lighting Update Speed and Final Gather Lighting Update Speed to reduce the temporal lag that causes flickering during fast camera movement.

// Configuring Lumen settings on a PostProcessVolume via C++
#include "Components/PostProcessComponent.h"
#include "Engine/PostProcessVolume.h"

void AMyLevelScriptActor::ConfigureLumenSettings()
{
    // Find the post process volume in the level
    TArray<AActor*> FoundActors;
    UGameplayStatics::GetAllActorsOfClass(
        GetWorld(), APostProcessVolume::StaticClass(), FoundActors
    );

    for (AActor* Actor : FoundActors)
    {
        APostProcessVolume* PPV = Cast<APostProcessVolume>(Actor);
        if (PPV)
        {
            FPostProcessSettings& Settings = PPV->Settings;

            // Raise Lumen Scene Detail for better small-geometry tracing
            Settings.bOverride_LumenSceneDetail = true;
            Settings.LumenSceneDetail = 2.0f;

            // Increase update speeds to reduce temporal flickering
            Settings.bOverride_LumenSceneLightingUpdateSpeed = true;
            Settings.LumenSceneLightingUpdateSpeed = 2.0f;

            Settings.bOverride_LumenFinalGatherLightingUpdateSpeed = true;
            Settings.LumenFinalGatherLightingUpdateSpeed = 2.0f;

            // Increase final gather quality to reduce noise
            Settings.bOverride_LumenFinalGatherQuality = true;
            Settings.LumenFinalGatherQuality = 2.0f;

            UE_LOG(LogTemp, Log, TEXT("Lumen settings configured on %s"),
                *PPV->GetName());
        }
    }
}

Step 3: Enable hardware ray tracing for Lumen if your target hardware supports it. Hardware ray tracing eliminates the screen-space limitations that cause the camera-dependent flickering. It traces against actual triangle geometry rather than distance fields and screen buffers, producing significantly more stable and accurate results at the cost of requiring an RTX or RDNA 2+ GPU.

// Enable hardware ray tracing for Lumen at runtime via console variables
// Typically set in DefaultEngine.ini or via C++ during initialization
#include "HAL/IConsoleManager.h"

void AMyGameMode::EnableHardwareRayTracing()
{
    // Enable hardware ray tracing support
    static IConsoleVariable* RTVar =
        IConsoleManager::Get().FindConsoleVariable(
            TEXT("r.RayTracing")
        );
    if (RTVar)
    {
        RTVar->Set(1);
    }

    // Set Lumen GI to use hardware ray tracing
    static IConsoleVariable* LumenHWRT =
        IConsoleManager::Get().FindConsoleVariable(
            TEXT("r.Lumen.HardwareRayTracing")
        );
    if (LumenHWRT)
    {
        LumenHWRT->Set(1);
    }

    // Also enable HW ray tracing for Lumen reflections
    static IConsoleVariable* LumenReflHWRT =
        IConsoleManager::Get().FindConsoleVariable(
            TEXT("r.Lumen.Reflections.HardwareRayTracing")
        );
    if (LumenReflHWRT)
    {
        LumenReflHWRT->Set(1);
    }

    UE_LOG(LogTemp, Log,
        TEXT("Hardware ray tracing enabled for Lumen GI and reflections"));
}

If you cannot require hardware ray tracing from your players, you can provide a scalability option that falls back to software tracing. The key is to pair software tracing with higher distance field resolution and Lumen Scene Detail values to compensate for the inherent limitations of screen-space methods.

Related Issues

If you are seeing similar artifacts specifically in Lumen reflections rather than global illumination, the fix is closely related but involves the reflection-specific quality settings in the PostProcessVolume. If your scene uses Nanite meshes and those meshes appear to have incorrect lighting, ensure that Nanite's mesh representation is generating valid distance fields — some Nanite meshes with very high triangle density can produce unexpectedly coarse distance fields at default settings.

For performance-related flickering where the GI quality degrades under heavy GPU load, consider reducing Lumen's Max Trace Distance or lowering the Final Gather Quality before reducing Scene Detail, as trace distance has a larger performance impact with less visual consequence in enclosed spaces. If you are building for both high-end and low-end hardware, the scalability system's sg.GlobalIlluminationQuality console variable lets you define per-quality-level Lumen settings.

Bump the distance field resolution first. It fixes the problem more often than anything else.