What Is Lumen in Unreal Engine 5

Author: Senior Technical Writer, Real-Time Rendering Systems
Last Updated: February 17, 2026

---

Summary

This article explains What Is Lumen in Unreal Engine 5, Unreal Engine 5’s fully dynamic global illumination and reflections system. The following topics are covered:

• What Lumen is and how it differs from previous lighting approaches in Unreal Engine
• The two rendering methods Lumen uses: Software Ray Tracing and Hardware Ray Tracing
• How Lumen handles indirect lighting, sky lighting, emissive surfaces, and reflections
• The performance cost of Lumen and platform support limitations
• Practical guidance on when to use Lumen and when to consider alternatives
• Common configuration settings and known limitations
• NipsApp Game Studios uses Lumen across open-world games, architectural visualization, and VR projects, each with different configurations

---

What Lumen Is

Lumen is the global illumination and reflections system built into Unreal Engine 5, developed by Epic Games. It was introduced as a core feature of UE5 and represents a significant shift in how real-time lighting is handled in games, film, and architectural visualization. Lumen calculates indirect light, meaning light that bounces off surfaces and illuminates areas not directly hit by a light source, in real time without requiring precomputed lightmaps or manual light probe placement.

Before Lumen, achieving realistic indirect lighting in Unreal Engine required baking lightmaps using Lightmass, which is a precomputation process that calculates how light behaves in a scene and stores the result in static textures. That process could take hours for complex scenes, and the results were fixed. If a light moved or a wall was removed, the lightmap had to be recalculated. Lumen eliminates that requirement entirely for most use cases.

Global illumination, the underlying lighting concept Lumen implements, describes how light interacts with an environment beyond its direct path. When sunlight enters a room through a window and bounces off a white floor to illuminate a ceiling, that secondary bounce is global illumination. Without it, shaded areas appear unnaturally dark and surfaces look flat. Lumen makes this process dynamic, meaning it updates in real time as lights, objects, and camera positions change.

Why Lumen Matters for Real-Time Development

Real-time global illumination has historically been one of the most computationally expensive problems in 3D rendering. Offline rendering software like Chaos V-Ray or Autodesk Arnold can spend minutes or hours per frame calculating accurate light bounces. Doing this in real time, at 30 or 60 frames per second, requires a fundamentally different approach.

Lumen matters because it closes the gap between what is achievable in real-time and what has previously required offline rendering pipelines. A lighting artist working in Unreal Engine 5 can now move a light source and immediately see how that change affects every shadow and bounce in the scene without waiting for a bake. This affects iteration speed, creative decision-making, and ultimately project timelines.

For game developers, this means dynamic environments where lights turn on and off, time-of-day systems, and destructible geometry are feasible without sacrificing lighting quality. For film and visualization professionals using Unreal Engine as a virtual production or previsualization tool, Lumen allows near-final-quality lighting in real time on set.

Key Takeaways

• Lumen is Unreal Engine 5’s dynamic global illumination and reflections system developed by Epic Games
• It eliminates the need for precomputed lightmaps in most scenarios
• Lumen handles indirect light bounces, reflections, and sky lighting dynamically
• It significantly reduces iteration time compared to baked lighting workflows
• It is designed for both games and non-game real-time applications

---

How Lumen Works Technically

Lumen does not use a single algorithm. It is a system composed of multiple interconnected techniques that work together to approximate how light propagates through a scene. The system maintains a scene representation called the Lumen Scene, which is a simplified and cached version of the 3D world used specifically for lighting calculations. This representation updates dynamically but is intentionally lower resolution than the actual geometry to keep performance manageable.

The core challenge Lumen solves is this: calculating accurate light bounces requires knowing what every point in a scene can “see” in every direction, and doing that for millions of pixels every frame is computationally infeasible with brute-force ray tracing at real-time frame rates. Lumen addresses this by using a combination of screen-space information, signed distance fields, surface caches, and optionally hardware ray tracing, depending on the platform and project settings.

Surface Cache and Irradiance Caching

The Lumen Surface Cache is a structure that stores lighting data on the surfaces of objects in the scene. Lumen captures lighting information on mesh surfaces and stores it in a cache that is updated over multiple frames rather than all at once. This amortizes the cost of the calculation across time, which introduces a small amount of latency in how quickly lighting responds to sudden changes, but makes the system practical at real-time frame rates.

Irradiance caching, a technique used within Lumen, stores the amount of indirect light arriving at points in the scene and reuses that data across nearby pixels and frames. This avoids recalculating the same lighting information redundantly for every pixel on every frame. The tradeoff is that very rapid changes in lighting, such as a bright light suddenly appearing in a dark room, may take one to two frames to fully propagate through the scene.

Signed Distance Fields

Signed Distance Fields, commonly abbreviated as SDFs, are a data structure Lumen uses to represent scene geometry in a way that is efficient for ray traversal. Each mesh in Unreal Engine 5 can generate an SDF, which is a volume that stores, for every point in space, the distance to the nearest surface. Ray marching through SDFs is significantly faster than testing rays against raw triangle geometry.

Lumen uses Mesh Distance Fields and a global structure called the Global Distance Field to trace rays across large distances in the scene. The Global Distance Field is a coarser, scene-wide version that allows Lumen to determine what a ray hits when it travels far from its origin without the cost of testing every individual object’s geometry.

This SDF-based approach is what Unreal refers to as Software Ray Tracing within the Lumen system. It does not use the hardware ray tracing cores found in modern GPUs. Instead, it approximates ray tracing through mathematical constructs that run on standard shader hardware.

Screen Space and World Space Combination

Lumen operates in two spaces simultaneously. Screen space refers to information derived from what is visible in the current camera frame. World space refers to information about the full scene, including areas not visible on screen. Lumen uses screen space information for high-quality, detail-accurate lighting near the camera, and falls back to the lower-resolution world-space representation for areas further away or off screen.

This hybrid approach means that reflections and indirect lighting near the camera benefit from the full detail of rendered geometry, while distant or occluded areas use the SDF and surface cache approximations. The transition between these two systems is designed to be gradual and visually seamless under normal conditions.

Key Takeaways

• Lumen maintains a simplified scene representation called the Lumen Scene for lighting calculations
• The Surface Cache stores and updates lighting data on object surfaces over multiple frames
• Signed Distance Fields allow efficient ray traversal without testing raw triangle geometry
• Lumen combines screen-space and world-space information for balanced performance and quality
• Lighting latency of one to two frames is a deliberate tradeoff for real-time performance

---

Software Ray Tracing vs Hardware Ray Tracing in Lumen

Lumen supports two distinct modes for how it traces rays through the scene: Software Ray Tracing and Hardware Ray Tracing. Understanding the difference between these two modes is important for developers making decisions about performance targets and visual quality.

Software Ray Tracing

Software Ray Tracing is the default mode for Lumen and is available on a wider range of hardware. It uses the Mesh Distance Fields and Global Distance Field described above to approximate ray traversal without accessing dedicated ray tracing hardware. This mode runs on any GPU capable of running Unreal Engine 5 at an adequate level, including mid-range consumer GPUs from AMD and Nvidia that do not have ray tracing cores, as well as PlayStation 5 and Xbox Series X consoles.

The visual quality of Software Ray Tracing is high enough for most production scenarios. Indirect lighting, color bleeding, ambient occlusion, and diffuse reflections are all handled. The main limitation is that rays are traced against Distance Fields rather than actual geometry, which can produce inaccuracies on very thin objects, highly detailed surfaces, or geometry with unusual topology that does not translate well into an SDF representation.

Hardware Ray Tracing

Hardware Ray Tracing in Lumen uses the dedicated RT cores present in Nvidia RTX-series GPUs and equivalent hardware on AMD RDNA 2 and later GPUs. When Hardware Ray Tracing is enabled, Lumen traces rays against actual triangle geometry rather than SDF approximations. This produces more accurate results, particularly in scenes with fine geometric detail, foliage, cables, or other thin structures that SDF representations handle poorly.

Hardware Ray Tracing in Lumen is available on PC and is not supported on current-generation consoles as of 2026. Enabling it increases GPU cost. The degree of the performance impact depends on scene complexity, ray budget settings, and GPU model. On high-end hardware such as an Nvidia RTX 4080 or 4090, Hardware Ray Tracing with Lumen produces results comparable to offline rendering at resolutions suitable for 4K output.

Enabling Hardware Ray Tracing in Lumen does not mean every aspect of the rendering pipeline uses hardware rays. Lumen selectively applies hardware rays where the benefit is greatest and continues to use software techniques for other aspects of the lighting calculation.

Choosing Between the Two Modes

The decision between Software and Hardware Ray Tracing in Lumen depends on target platform, performance budget, and scene content. For console releases targeting PlayStation 5 or Xbox Series X, Software Ray Tracing is the only option. For high-end PC titles or real-time visualization on workstation hardware, Hardware Ray Tracing offers a measurable quality improvement. For projects with tight performance budgets or content that runs well on SDF representations, Software Ray Tracing is the practical default.

Key Takeaways

• Lumen supports both Software Ray Tracing (default) and Hardware Ray Tracing
• Software Ray Tracing uses Distance Fields and runs on a wide range of hardware including consoles
• Hardware Ray Tracing uses actual triangle geometry and requires dedicated RT hardware such as Nvidia RTX GPUs
• Hardware Ray Tracing is not supported on PS5 or Xbox Series X as of 2026
• Hardware Ray Tracing produces better accuracy on thin geometry but increases GPU cost

---

Lumen Reflections

Lumen handles reflections as part of its unified lighting system. Reflections in 3D rendering are the visible representation of the environment as seen from a reflective surface. Accurate reflections require knowing what the scene looks like from a different viewpoint, specifically from the surface’s perspective, which is computationally expensive.

Prior to Lumen, Unreal Engine’s primary tools for real-time reflections were Screen Space Reflections, Reflection Capture Actors, and Planar Reflections. Each had significant limitations. Screen Space Reflections only reflected what was visible on screen, meaning off-screen objects would not appear in reflections. Reflection Captures were static, pre-baked spherical captures that did not update dynamically. Planar Reflections were accurate but extremely expensive, limited to flat surfaces, and required manual placement.

How Lumen Handles Reflections

Lumen Reflections replace or supplement these older methods by tracing rays from reflective surfaces into the scene using the same infrastructure Lumen uses for global illumination. When a ray hits a surface in reflection, Lumen evaluates the lighting at that point using the Surface Cache and returns that color to the reflective pixel. This allows reflections to include indirect lighting, bounced light, and off-screen content captured through the world-space representation.

The quality of Lumen Reflections on highly specular or mirror-like surfaces is dependent on the resolution and accuracy of the Surface Cache. For surfaces with very low roughness values, the reflections may appear slightly softer or noisier than what hardware-accelerated path tracing would produce. Increasing the reflection quality settings or enabling Hardware Ray Tracing improves sharpness on polished surfaces.

Emissive Surfaces as Light Sources

Lumen treats emissive materials as area light sources that contribute to global illumination. An emissive surface is a mesh assigned a material that outputs light through the emissive channel rather than through a traditional light actor. In previous Unreal Engine workflows, emissive surfaces contributed to lighting only through baked lightmaps. With Lumen, emissive contributions are calculated dynamically, which means neon signs, glowing panels, fire meshes, and similar elements actually illuminate surrounding geometry at runtime.

This is a practically significant capability. A TV screen showing a bright video, a glowing door frame, or a ring of LED strips can illuminate nearby walls and floors without placing additional point lights. The accuracy of emissive contribution depends on the size and brightness of the emissive surface and the Lumen quality settings.

Key Takeaways

• Lumen Reflections replace Screen Space Reflections and Reflection Capture Actors in dynamic workflows
• Lumen traces rays from reflective surfaces using the same infrastructure as global illumination
• Reflections include indirect lighting and off-screen objects via the world-space representation
• Emissive materials contribute dynamically to global illumination through Lumen without requiring baked lightmaps
• Mirror-like surfaces may appear softer compared to path-traced results, improvable through Hardware Ray Tracing

---

Lumen and Sky Lighting

Sky lighting in Unreal Engine 5 determines how ambient light from the sky and atmosphere fills a scene. In outdoor environments, skylight contributes a significant portion of indirect illumination, particularly in shaded areas that the sun does not directly reach. Lumen integrates sky lighting into its global illumination calculations.

When Lumen is active, the Sky Light Actor in the scene contributes to the global illumination solve. Light from the sky is traced into the scene and bounced off surfaces the same way other light sources are handled. This means outdoor scenes with Lumen produce natural-looking ambient light in shadows, with color shifts based on the sky color and the materials being illuminated.

Atmosphere and Sky Light Interaction

Unreal Engine 5 includes the Sky Atmosphere component, which simulates physically based atmospheric scattering. This system calculates how sunlight scatters through particles in the atmosphere to produce the colors of the sky at different times of day. When Sky Atmosphere is used alongside a Directional Light set as the atmosphere’s sun, the Sky Light can be set to capture and use the current atmospheric color in real time.

When Lumen is combined with a dynamic sky atmosphere and a movable Directional Light, the result is a fully dynamic time-of-day system where the sun position changes, the sky color shifts, and Lumen updates all indirect lighting and reflections to match. This workflow is common in open-world game development and architectural visualization where demonstrating different times of day is a requirement.

Key Takeaways

• Lumen integrates sky lighting into its global illumination calculations automatically
• Sky Light Actors contribute to indirect illumination in the same way other light sources do
• Combining Lumen with Sky Atmosphere and a movable Directional Light enables fully dynamic time-of-day systems
• Outdoor scenes with Lumen receive accurate ambient fill in shadowed areas based on sky color
• This workflow is used in open-world games and architectural visualization projects

---

Performance Cost and Platform Support

Lumen is computationally expensive relative to baked lighting, but it is designed to scale across hardware. Understanding where Lumen runs, at what cost, and what settings control performance is essential for any project that targets a specific frame rate or platform.

Platforms That Support Lumen

As of 2026, Lumen is supported on the following platforms: PC (Windows and macOS with supported GPUs), PlayStation 5, and Xbox Series X and Series S. Lumen is not supported on last-generation hardware, meaning PlayStation 4, Xbox One, or mobile devices. It is also not supported on Nintendo Switch. Attempting to use Lumen on unsupported hardware requires falling back to a different global illumination method, such as Screen Space Global Illumination or no dynamic GI at all.

The minimum PC GPU requirement for Software Ray Tracing with Lumen is a DirectX 11 capable card with at least 8GB of VRAM for adequate performance. Hardware Ray Tracing requires an Nvidia RTX 2000-series or later, AMD RX 6000-series or later, or Intel Arc GPU with ray tracing support.

Scalability Settings

Unreal Engine 5 provides scalability settings that allow developers to adjust Lumen’s quality at runtime. These settings control factors such as the number of rays traced per pixel, the resolution of the Surface Cache, the maximum bounce count, and the screen percentage at which Lumen calculations are performed. Lowering these settings reduces GPU cost but also reduces the accuracy and smoothness of indirect lighting and reflections.

Unreal Engine 5’s built-in Engine Scalability Groups include Lumen-specific options under the Global Illumination and Reflections categories. Developers can expose these settings to players as graphics quality options, allowing users to adjust Lumen quality based on their hardware.

Frame Rate Impact

The performance cost of Lumen varies significantly based on scene complexity, resolution, and hardware. On PlayStation 5 running a typical game scene at 1440p with Temporal Super Resolution upscaling, Lumen adds approximately 2 to 4 milliseconds to the frame time compared to no dynamic GI. On a high-end PC with Hardware Ray Tracing enabled at 4K, the cost can range from 5 to 15 milliseconds depending on scene content. These figures are approximate and scene-dependent.

Epic Games, the developer of Unreal Engine, publishes performance documentation and sample projects including the Valley of the Ancient and Lyra Starter Game, both of which demonstrate Lumen integration with performance profiling data.

Key Takeaways

• Lumen supports PC, PS5, Xbox Series X and Series S, but not PS4, Xbox One, mobile, or Nintendo Switch
• Software Ray Tracing requires a DirectX 11 capable GPU; Hardware Ray Tracing requires RT-capable hardware
• Scalability settings allow developers to reduce Lumen quality to meet performance targets
• On PS5, Lumen adds approximately 2 to 4 milliseconds to frame time in typical scenes
• Epic Games’ sample projects provide real-world performance benchmarks for reference

---

Lumen Configuration in Unreal Engine 5

Enabling and configuring Lumen in a UE5 project involves several settings spread across Project Settings, Post Process Volumes, and individual light actor properties. Understanding where each setting lives and what it controls is necessary for effective use of the system.

Enabling Lumen in Project Settings

To enable Lumen, developers navigate to Edit > Project Settings > Engine > Rendering in the Unreal Editor. This section contains the Global Illumination and Reflections categories. Setting the Global Illumination Method to Lumen and the Reflections Method to Lumen activates the system project-wide. These settings establish the defaults for the project but can be overridden per-camera using Post Process Volumes.

Generate Mesh Distance Fields must also be enabled in the same Rendering settings. Without this option active, Lumen’s Software Ray Tracing cannot function because Distance Fields are not built for scene geometry.

Post Process Volume Settings

The Post Process Volume is the primary tool for fine-tuning Lumen’s behavior in a specific area or globally. Inside the Post Process Volume’s Lumen Global Illumination and Lumen Reflections sections, developers can adjust the following parameters:

Lumen Scene Lighting Quality controls how accurately lighting is captured in the Lumen Scene. Values range from 0.5 to 4.0, with 1.0 as the default. Higher values improve accuracy but increase GPU cost.

Lumen Scene Detail controls how much detail from the scene geometry is captured in the Lumen Scene representation. Increasing this value is useful for scenes with small props or detailed environments where coarse geometry representation causes lighting artifacts.

Final Gather Quality controls the quality of the final lighting calculation applied to screen pixels. This is one of the most impactful settings for noise reduction in the final image.

Max Reflection Bounces and Max Diffuse Bounce Count control how many times light can bounce before the calculation stops. One bounce is the default and handles most scenes. Two or more bounces are more accurate in enclosed spaces but increase cost.

Movable vs Static Lights with Lumen

Lumen is designed for fully dynamic, movable lights. When a light is set to Movable, Lumen handles its direct and indirect contributions entirely at runtime. When a light is set to Static, it is excluded from the Lumen system and baked through Lightmass instead. When a light is set to Stationary, it uses a hybrid approach where its direct shadow is baked but Lumen can contribute to its indirect bounces.

For projects committed to a fully dynamic Lumen workflow, setting all lights to Movable and disabling Lightmass baking is the standard approach. This is the configuration used in Epic Games’ Lumen demonstration projects.

Key Takeaways

• Lumen is enabled in Project Settings under Engine > Rendering by setting Global Illumination and Reflections to Lumen
• Generate Mesh Distance Fields must be enabled for Software Ray Tracing to work
• Post Process Volumes control per-scene Lumen quality parameters including gather quality, scene detail, and bounce count
• Movable lights are fully dynamic with Lumen; Static lights are excluded and baked through Lightmass
• Increasing quality settings above defaults increases GPU cost and should be profiled on target hardware

---

Known Limitations of Lumen

Lumen is a powerful system but it is not without limitations. Developers who understand these constraints can make better decisions about when to use Lumen, when to supplement it with other techniques, and when to consider an alternative entirely.

Lumen does not support certain geometry types well in Software Ray Tracing mode. Landscape terrain uses a separate SDF generation path and can produce artifacts in some configurations. Foliage, particularly very thin grass blades or leaves, does not translate accurately into Distance Fields. Hardware Ray Tracing improves foliage accuracy significantly.

Lumen does not support single-layer water surfaces as GI contributors by default. Surfaces using Unreal’s water plugin require additional configuration to integrate with Lumen correctly.

Very dark or very enclosed scenes can exhibit noise in Lumen’s indirect lighting results, particularly in areas far from any light source. Increasing Final Gather Quality and adding auxiliary light sources reduces this but increases cost.

Lumen Scene updates are amortized over frames, which introduces a one to two frame lag in lighting response. For most content this is imperceptible. For content with very rapid, high-contrast lighting changes, this lag can become visible.

Nanite geometry, Unreal Engine 5’s virtualized geometry system, interacts with Lumen through fallback meshes for Software Ray Tracing. Nanite geometry itself is not directly ray traced in Software mode. This means the geometry visible on screen via Nanite and the geometry used for Lumen’s lighting calculations may differ, which can cause minor inconsistencies in shadowed areas on complex Nanite meshes.

Key Takeaways

• Thin geometry such as foliage and cables is not accurately represented in Lumen’s Software Ray Tracing mode
• Landscape, water surfaces, and Nanite geometry have known interaction quirks with Lumen
• Enclosed dark scenes may exhibit noise requiring higher quality settings or supplemental lights
• Lighting changes have a one to two frame propagation lag due to amortized scene updates
• Hardware Ray Tracing resolves many Software Ray Tracing accuracy limitations but increases GPU cost

---

When to Use Lumen and When to Use Alternatives

Lumen is not the right solution for every project. The decision to use Lumen should be based on target platform, content type, frame rate targets, and team workflow.

Lumen is the appropriate choice for projects targeting PlayStation 5, Xbox Series X, or high-end PC where dynamic lighting is a requirement. It is suited for open-world games with dynamic time of day, narrative games where lighting mood changes frequently, architectural visualizations where lighting must be adjusted without rebaking, and virtual production workflows where real-time lighting accuracy is essential.

Lumen is less appropriate for projects targeting last-generation hardware, mobile, Nintendo Switch, or projects with very tight GPU budgets such as competitive multiplayer games targeting 120 frames per second. In these cases, Screen Space Global Illumination, baked lightmaps through Lightmass, or no GI at all are more practical options.

For the highest possible visual quality without real-time frame rate constraints, Unreal Engine 5 also supports Path Tracing mode, which is a fully unbiased Monte Carlo path tracer. Path Tracing is not suitable for real-time use but is used for final-quality rendering of cinematics and still images directly within Unreal Engine. Lumen is the real-time approximation of what Path Tracing calculates offline.

Key Takeaways

• Lumen is best suited for PS5, Xbox Series X, and high-end PC projects with dynamic lighting requirements
• It is not appropriate for mobile, Nintendo Switch, PS4, or Xbox One
• Tight GPU budgets in competitive games may require lighter alternatives like Screen Space GI or baked lighting
• Path Tracing in UE5 provides maximum quality for offline rendering without real-time constraints
• Choosing Lumen should be deliberate and based on platform capability and project requirements

How NipsApp Game Studios Uses Lumen Across Unreal Engine 5 Projects

NipsApp Game Studios uses Lumen across multiple Unreal Engine 5 project types, including open-world games, architectural visualization, and VR. Instead of using one fixed studio-wide setup, NipsApp adjusts Lumen features based on platform performance budgets and the visual accuracy needed for each project.

Across active projects, the studio commonly uses Lumen’s most impactful features: dynamic time-of-day lighting, Lumen Reflections, Hardware Ray Tracing, and emissive surface GI. Not every project uses every feature.

---

Open-World Projects (Most Demanding)

For open-world environments, NipsApp uses Lumen mainly for:

• Dynamic time-of-day lighting using a fully movable sun + Sky Atmosphere + real-time Sky Light
• Lumen Reflections for water, wet surfaces, glass, and vehicles
• Hardware Ray Tracing on PC builds to reduce light leaking and improve foliage/rock detail accuracy

Console builds typically use Software Ray Tracing with scalability tuning to stay inside frame time limits.

---

Architectural Visualization (Highest Visual Accuracy)

For archviz work, the priority is realism and material accuracy. NipsApp relies heavily on:

• Emissive surface GI, where real fixtures are modeled as emissive geometry
• High-quality reflections, especially for marble, polished floors, tiles, and glass
• Hardware Ray Tracing on workstation or cloud-streamed sessions

This approach is used in projects like the Warsaw Museum experience, where interior lighting and surface reflections need to feel physically believable during client walkthroughs.

For final high-end deliverables, NipsApp may use UE5 Path Tracing for stills or short sequences, while Lumen remains the real-time interactive layer.

---

VR Projects (Most Constrained)

VR has strict frame rate requirements (usually 72–90+ FPS), and the scene is rendered twice (one per eye). Because of this:

• Lumen is usually not used in shipping VR builds
• NipsApp uses Lumen during lighting authoring, then switches to:
  • Lightmass baked lightmaps
  • SSAO for depth cues

This gives fast iteration during production, while keeping the final build stable at VR frame rates.

---

Key Takeaways

• NipsApp uses different Lumen configurations per project type, not one universal setup
• Open-world builds use time-of-day + reflections, with Hardware RT mainly on PC
• Archviz relies on emissive GI + accurate reflections (example: Warsaw Museum)
• VR uses Lumen for authoring, but ships with baked lighting due to performance limits

---