Fix: Unreal Lumen Flickering on AMD GPUs

You ship an Unreal Engine 5 game with Lumen enabled. NVIDIA players report beautiful lighting. AMD players report that interiors look like a disco — lights shimmer, dark areas flicker, and the whole scene feels unstable. The bug reports all come from Radeon RX cards. This isn’t a driver bug you can complain to AMD about (well, not only) — it’s a setting you can fix on your side.

Why Lumen Flickers Differently on AMD

Lumen uses a combination of software ray tracing against Distance Fields (SDFs), Surface Cache for captured lighting, and screen probe gather for final bounce lighting. Each of these steps produces noisy intermediate results that are then denoised and temporally accumulated to produce the final stable image.

The denoiser and temporal accumulation rely on floating-point precision in compute shaders. AMD’s RDNA 2 and RDNA 3 drivers have had a few generations where precision edge cases in specific shader paths produced subtly different results than NVIDIA’s drivers. These differences cascade through the temporal filter and show up as visible flickering, especially in:

• Interior scenes with strong indirect lighting
• Surfaces with high specular that reflect from multiple bounce paths
• Areas where the camera moves quickly, stressing the reprojection logic
• Scenes with emissive surfaces near reflective geometry

Step 1: Confirm It’s AMD-Specific

Filter your bug reports by the GPU metadata field. If all or most Lumen flickering reports come from AMD Radeon RX cards (especially 6000 and 7000 series), you have an AMD-specific issue. If the reports are spread across NVIDIA and AMD, the issue is probably a general Lumen quality setting and the AMD concentration is coincidence.

// Unreal crash report metadata capture includes GPU automatically
FString GPUName = FPlatformMisc::GetPrimaryGPUBrand();

// Tag Lumen-related reports with this field
// Then filter in your bug dashboard:
// "lumen flickering AND gpu:Radeon"

Step 2: Switch to TSR

Temporal Super Resolution (TSR) is Unreal’s successor to TAA and handles temporal noise from ray-traced and path-traced sources much more robustly. Switch from TAA to TSR as your default anti-aliasing method. In most cases this single change eliminates the majority of visible flickering.

// Console variable (can be set in DefaultEngine.ini or at runtime)
r.AntiAliasingMethod 4    ; 0=None, 1=FXAA, 2=TAA, 3=MSAA, 4=TSR

// In DefaultEngine.ini
[/Script/Engine.RendererSettings]
r.AntiAliasingMethod=4
r.TSR.History.R11G11B10=0    ; Use higher precision history buffer
r.TSR.ShadingRejection.Flickering=1    ; Enable flickering rejection

The r.TSR.ShadingRejection.Flickering CVar is specifically designed to suppress the kind of frame-to-frame variation that causes flickering in Lumen output. Turn it on. The performance cost is small.

Step 3: Increase Lumen Quality Settings

The default Lumen quality is tuned for broad compatibility and performance, which leaves some noise in the output that different GPUs amplify differently. Pushing the quality up produces more stable results at a performance cost:

; Lumen quality bumps for AMD stability
[/Script/Engine.RendererSettings]

; Screen probe gather - more probes = less noise
r.Lumen.ScreenProbeGather.RadianceCache.NumProbesToTraceBudget=400
r.Lumen.ScreenProbeGather.ScreenTraces.HierarchicalPool=1

; Final gather - higher quality = more stable
r.LumenScene.FinalGather.Quality=2

; Surface cache - higher res means better sampling
r.LumenScene.SurfaceCache.ResolutionScale=1.5

; Reflection quality
r.Lumen.Reflections.Quality=2
r.Lumen.Reflections.ScreenTraces=1
r.Lumen.Reflections.HierarchicalScreenTraces=1

; Temporal filter stability
r.Lumen.ScreenProbeGather.TemporalFilterProbes=1
r.Lumen.ScreenProbeGather.Temporal.DistanceClampOnlyOffScreen=1

Put these in a quality preset called “High Stability” or “AMD Optimized” and expose it in your graphics settings menu. Don’t force them on everyone — players with NVIDIA cards have no issue and don’t need the extra cost.

Step 4: Consider Hardware Lumen on Newer AMD Cards

On RDNA 2 (RX 6000) and RDNA 3 (RX 7000) GPUs, hardware ray tracing is available and Lumen can use it. Hardware Lumen produces cleaner results than software Lumen because it’s not constrained by Distance Field precision. The tradeoff is significant GPU cost.

; Enable hardware ray tracing for Lumen
[/Script/Engine.RendererSettings]
r.Lumen.HardwareRayTracing=1
r.Lumen.HardwareRayTracing.LightingMode=2  ; Hit lighting for reflections
r.RayTracing.Shadows=1                      ; Hardware shadows

Expose this as a “Hardware Ray Tracing” toggle in your graphics settings. Default it off, let players who have compatible hardware turn it on. Many AMD players with RX 6800 or better will happily accept the performance cost for noise-free lighting.

Step 5: Detect and Warn on Known Bad Driver Versions

Some AMD driver versions have known Lumen issues that were later fixed. At launch, check the driver version and warn players on the affected versions. This can be done on game startup:

void UMyGameInstance::CheckGPUDriverVersion()
{
    const FString GPUBrand = FPlatformMisc::GetPrimaryGPUBrand();

    if (GPUBrand.Contains("AMD") || GPUBrand.Contains("Radeon"))
    {
        const FString DriverVer = FPlatformMisc::GetPrimaryGPUDriverVersion();
        UE_LOG(LogTemp, Log, TEXT("AMD driver: %s"), *DriverVer);

        // Known-bad driver versions (example, update with current data)
        TArray<FString> KnownBadVersions = {
            "23.12.1",   // example
            "24.1.1"     // example
        };

        for (const FString& BadVer : KnownBadVersions)
        {
            if (DriverVer.Contains(BadVer))
            {
                ShowDriverWarningDialog(DriverVer);
                break;
            }
        }
    }
}

The dialog should tell the player the specific driver version has known issues with Lumen rendering and recommend updating to the latest WHQL driver. Don’t be alarmist — just informative. Most players respond well to a heads-up about their drivers.

Testing the Fix

You need actual AMD hardware for testing. BrowserStack-style GPU cloud services don’t always represent consumer AMD cards accurately. Buy a used RX 6700 XT or RX 7600 for around $200-$300 and put it in a test rig. Run your game through every scene that had flickering reports, compare before and after.

Capture video of the before/after. Flickering is a temporal artifact that screenshots won’t show. A 30-second clip of the affected scene before and after your settings change is the only way to prove the fix worked.

Related Issues

For Lumen lighting flicker in general, see Fix: Unreal Lumen Lighting Flickering Artifacts. For broader Unreal rendering debugging, check Unreal Engine Crash Log Analysis. For GPU-specific performance profiling, see Unreal Insights Performance Profiling Guide.

When a bug only appears on one GPU brand, the fix is usually a quality setting, not a driver update.