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.
| Component | Role | Typical concern |
|---|---|---|
| Mesh distance fields | Precise tracing near the camera | Memory and build time |
| Global distance field | Merged, coarse tracing for distant geometry | Loss of small details |
| Surface cache | Stores material and lighting at ray hits | Missing coverage on complex meshes |
| Screen space probes | Final gather for visible pixels | Noise in dark interiors |
| World space radiance cache | Stable lighting for long rays | Lag after sudden changes |
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.
| Aspect | Software ray tracing | Hardware ray tracing |
|---|---|---|
| Hardware requirement | Shader Model 5 GPU | GPU with ray tracing support |
| Geometry used | Distance field approximation | Real triangles from a BVH |
| Reflection quality | Blurry on smooth surfaces | Sharp, with optional hit lighting |
| Skinned and deforming meshes | Poorly represented | Represented accurately |
| Relative cost | Lower and predictable | Higher, scales with scene complexity |
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.
| Method | Dynamic lights and geometry | Runtime cost | Best use |
|---|---|---|---|
| Baked lightmaps | No, lighting is fixed | Very low | Static scenes, mobile, VR |
| Screen space GI | Yes, only visible surfaces | Low | Supplementary bounce light |
| Lumen | Yes, including off-screen surfaces | Medium to high | Open worlds, time of day |
| Path tracing | Yes, physically accurate | Very high | Cinematics and reference renders |
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.
| Setting | What it controls | Effect of raising it |
|---|---|---|
| Lumen Scene Lighting Quality | Resolution of the surface cache lighting | Fewer artifacts, higher cost |
| Final Gather Quality | Number of probes and rays per pixel | Less noise, higher cost |
| Lumen Scene Detail | Which small objects enter the Lumen Scene | More accurate occlusion |
| Max Trace Distance | How far rays travel before giving up | Better distant bounce, more cost |
| Scene View Distance | Range of the Lumen Scene around the camera | Lighting holds further away |
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.
| Symptom | Likely cause | Common fix |
|---|---|---|
| Light leaking through walls | Walls thinner than the distance field resolution | Use walls at least about 10 cm thick |
| Lighting lags after a change | Temporal accumulation across frames | Avoid instant changes or raise update speed |
| Splotchy noise indoors | Too few rays reach small openings | Add fill lights or raise final gather quality |
| Flickering small emissive objects | Tiny bright emitters undersampled | Pair emissive meshes with real lights |
| Black areas on complex meshes | Poor surface cache card coverage | Split meshes or adjust card placement |
- 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.