Lumen · Unreal Engine

On this page 7

Lumen is the fully dynamic global illumination and reflections system built into Unreal Engine 5, which calculates how light bounces between surfaces in real time instead of relying on precomputed lightmaps. Among game engines it is one of the most visible examples of a production-ready real-time GI solution, and in gaming it changed how teams light open worlds, interiors and scenes with moving light sources.

Lumen replaces the traditional bake step with a hybrid tracing pipeline that combines signed distance fields, a surface cache and optional hardware ray tracing. Not to be confused with the lumen as a unit of light output used for lamps and bulbs.

How Lumen computes indirect lighting

Lumen works by tracing rays from the visible pixels into a simplified representation of the scene, gathering the light that arrives from other surfaces and the sky. Because a full path tracer would be far too expensive at game frame rates, Lumen trades accuracy for speed through several cooperating structures.

The Lumen Scene is a coarse parallel version of the world. Each mesh is described by mesh distance fields for tracing and by cards, small captures of its material properties such as albedo, normal and emissive color, stored in the surface cache. When a ray hits a surface, Lumen reads the cached lighting at that point instead of evaluating the full material, which keeps every bounce cheap.

Final gathering happens through screen space probes placed adaptively over the visible image, plus a world space radiance cache for distant lighting. Results are filtered and accumulated over several frames, so Lumen delivers multiple bounces of diffuse light at a cost that a game can afford. The table below summarizes the main building blocks.

ComponentRoleTypical concern
Mesh distance fieldsPrecise tracing near the cameraMemory and build time
Global distance fieldMerged, coarse tracing for distant geometryLoss of small details
Surface cacheStores material and lighting at ray hitsMissing coverage on complex meshes
Screen space probesFinal gather for visible pixelsNoise in dark interiors
World space radiance cacheStable lighting for long raysLag after sudden changes
Core components of the Lumen pipeline

Software and hardware ray tracing in Lumen

Lumen offers two tracing modes, and the choice affects quality, performance and the hardware a project can support. Software ray tracing runs on any GPU that supports Shader Model 5 and traces against distance fields, while hardware ray tracing uses the dedicated ray tracing units of DirectX 12 class graphics cards and current consoles.

In software mode, Lumen traces detailed mesh distance fields within roughly two meters of each pixel and switches to the global distance field beyond that range. Hardware mode traces the actual triangles, which gives sharper reflections and fewer leaks, and it can optionally evaluate hit lighting for mirror-like reflections at a higher cost.

AspectSoftware ray tracingHardware ray tracing
Hardware requirementShader Model 5 GPUGPU with ray tracing support
Geometry usedDistance field approximationReal triangles from a BVH
Reflection qualityBlurry on smooth surfacesSharp, with optional hit lighting
Skinned and deforming meshesPoorly representedRepresented accurately
Relative costLower and predictableHigher, scales with scene complexity
Comparison of the two tracing modes

Many studios ship with software tracing as the baseline and offer hardware tracing as a higher quality option on PC, because it keeps a single lighting setup working across a wide range of machines.

Lumen compared with other lighting approaches

Lumen sits between static baked lighting and offline path tracing: it is less exact than a path tracer but far more flexible than lightmaps. Understanding where it fits explains why some projects still bake lighting even in Unreal Engine 5.

MethodDynamic lights and geometryRuntime costBest use
Baked lightmapsNo, lighting is fixedVery lowStatic scenes, mobile, VR
Screen space GIYes, only visible surfacesLowSupplementary bounce light
LumenYes, including off-screen surfacesMedium to highOpen worlds, time of day
Path tracingYes, physically accurateVery highCinematics and reference renders
Lumen and alternative global illumination methods

Lumen pairs naturally with Nanite, the virtualized geometry system, because high-density meshes and dynamic lighting together remove much of the manual work of lightmap UVs and level-of-detail authoring. The two systems are independent, however, and each can be enabled without the other.

Configuring Lumen for a project

Lumen is enabled through project settings and post process volumes, where the Global Illumination Method and Reflection Method are both set to Lumen. Software tracing also requires the project to generate mesh distance fields, which increases build time and memory use.

Epic designs Lumen around frame budget targets on current consoles: the Epic scalability level aims at 30 frames per second, and the High level is tuned for 60 frames per second with reduced quality. Actual cost depends on resolution, scene complexity and upscaling, so profiling on target hardware is essential.

SettingWhat it controlsEffect of raising it
Lumen Scene Lighting QualityResolution of the surface cache lightingFewer artifacts, higher cost
Final Gather QualityNumber of probes and rays per pixelLess noise, higher cost
Lumen Scene DetailWhich small objects enter the Lumen SceneMore accurate occlusion
Max Trace DistanceHow far rays travel before giving upBetter distant bounce, more cost
Scene View DistanceRange of the Lumen Scene around the cameraLighting holds further away
Frequently adjusted Lumen settings

Limitations and common artifacts

Lumen produces convincing results quickly, but its approximations create recognizable artifacts that artists must design around. Most problems trace back to the simplified scene representation and the temporal accumulation that hides noise.

SymptomLikely causeCommon fix
Light leaking through wallsWalls thinner than the distance field resolutionUse walls at least about 10 cm thick
Lighting lags after a changeTemporal accumulation across framesAvoid instant changes or raise update speed
Splotchy noise indoorsToo few rays reach small openingsAdd fill lights or raise final gather quality
Flickering small emissive objectsTiny bright emitters undersampledPair emissive meshes with real lights
Black areas on complex meshesPoor surface cache card coverageSplit meshes or adjust card placement
Typical Lumen problems and fixes
  • Translucent materials receive only simplified Lumen lighting, so glass and particles may look flatter than opaque surfaces.
  • Lower-end hardware and mobile platforms are generally not suited to Lumen, and those builds usually fall back to baked or simpler lighting.
  • Highly reflective scenes expose the limits of software tracing, where hardware ray tracing is often the better choice.

Put simply

Light in the real world does not stop where it first lands. Sunlight entering a window bounces off the floor and walls, which is why a room is not pitch black in its corners. Lumen is the part of Unreal Engine that imitates those bounces while the game is running.

Older games often painted this bounced light into textures ahead of time, much like a photograph glued onto the walls. That looked good until something moved. Lumen recalculates the light every moment, so a door opening, a lamp switching on or the sun setting changes the whole room naturally. The price is extra work for the graphics card and a little blur or delay in difficult spots.

In practice

A small studio building a survival game with a full day and night cycle first planned to bake lighting for every hour of the day. The bake times and memory cost made that impractical, so the team switched to Lumen with software ray tracing and enabled mesh distance fields for the whole project.

Cabins in the game initially showed light leaking through their thin plank walls. The artists rebuilt the walls with about 20 cm of thickness and added a weak fill light inside each cabin to calm the noise in dark corners. On console, the team used the High scalability level to reach 60 frames per second, keeping the Epic level for a 30 fps quality mode.

The result was a world where sunrise light pours through doorways and torches light caves dynamically, with no lightmaps to rebuild whenever a level designer moved a rock.