Unreal Engine 5 Nanite & Lumen Guide for Indie Developers

Learn what Nanite and Lumen do, turn them on in a small test scene, check whether your machine can handle them, and decide when to leave them off.

Nanite and Lumen are two of the systems people mention most when they talk about Unreal Engine 5. They can make a scene look rich with less manual setup. They also ask a lot of your hardware, and they are not the right fit for every game.

This tutorial explains both in plain language, then walks you through a test scene you can build in an evening, using the editor’s own tools to see what each system costs on your machine.

What Nanite does

Normally, a detailed 3D model is expensive to draw. Developers handle that by making several simpler versions of each model, called levels of detail, and swapping them in as the camera moves away.

Nanite takes over much of that work. It breaks a mesh into small groups of triangles and decides, every frame, how much detail each part of the model needs for its size on screen. A rock far away gets drawn with few triangles. The same rock up close gets many more. You import one high-detail mesh and let Nanite scale it.

According to Epic’s documentation, Nanite can be enabled on Static Meshes and Geometry Collections. A static mesh is a model that does not bend or animate its vertices: rocks, walls, buildings, props, and terrain pieces. Geometry Collections are used for destructible objects.

When you enable Nanite on a mesh, the engine also creates a simpler fallback mesh. Unreal uses that fallback when Nanite is not available on a platform and for some engine features, such as complex collision.

Nanite also has a list of material and rendering features it does not support or handles differently. That list has changed between engine versions, so check the Nanite page in the documentation for your version before converting things like glass, water, or foliage.

What Lumen does

Lumen is Unreal’s system for dynamic global illumination and reflections.

Global illumination is the light that bounces. Sun hits a red wall, and the floor next to it picks up a faint red tint. A room with one window still has soft light in the corners. Without global illumination, anything not hit directly by a light tends to look flat or black.

Traditionally, games baked bounced light ahead of time, which breaks when lights or objects move. Lumen calculates bounce lighting and reflections while the game runs, so moving the sun or switching on a lamp updates the scene.

Lumen can trace in software, which uses mesh distance fields, or with hardware ray tracing on graphics cards and systems that support it. Epic’s documentation says new projects have Lumen enabled by default.

Where each one helps

Nanite helps most when you have:

• Detailed static models, such as photo-scanned rocks or sculpted architecture.
• Many copies of complex props spread across a large area.
• A workflow where building levels of detail by hand would slow you down.

Lumen helps most when you have:

• Lights that move or change, such as a day and night cycle or a flashlight.
• Interiors lit mostly by bounced light from windows or doors.
• Scenes where you want quick lighting feedback without rebuilding baked lighting.

Step 1: Create a test project

Open the Epic Games Launcher, install Unreal Engine 5 if you have not already, and create a new project from a blank games template. Choose Blueprint so you do not need a C++ compiler.

Make a new empty level. Add a directional light, a sky atmosphere, a sky light, and an exponential height fog, which gives Lumen a sun and sky to work with.

Step 2: Confirm Lumen is on

Open Edit > Project Settings and go to Engine > Rendering.

Find Dynamic Global Illumination Method and make sure it is set to Lumen. Find Reflection Method and set it to Lumen as well. Nearby, you will see the option to generate mesh distance fields, which Lumen’s software tracing relies on, and a setting to use hardware ray tracing when available. Leave hardware ray tracing off for your first test so you see the baseline.

If the editor asks you to restart after a change, do it.

Step 3: Add meshes and enable Nanite

Bring in a few detailed static meshes. Free sample assets from Epic or your own sculpts work well. Place a floor, several large rocks or wall pieces, and a simple room with one opening so you can see bounced light.

To enable Nanite on a mesh you already imported, open it in the Static Mesh Editor and turn on Enable Nanite Support in the Details panel, then apply the change. You can also right-click mesh assets in the Content Browser and look for the Nanite option to enable several at once. When importing new meshes, check the import dialog for a Nanite option.

Step 4: Check that both systems are working

The viewport has visualization modes that show what these systems are doing. Open the view mode menu at the top of the viewport.

Under the Nanite Visualization options, choose the triangles or clusters view. Meshes rendered by Nanite appear as colored patches that change density as you move the camera closer or farther away. Meshes that are not using Nanite look different, which makes it easy to spot one you forgot to convert.

Under the Lumen options, try the overview or surface cache views. These show how Lumen sees your scene. Areas that show up as missing or flat can explain lighting that looks wrong.

Now test Lumen directly. Rotate the directional light. Watch the inside of your room. Bounced light should shift and fade as the sun moves.

Step 5: Find out if your machine is struggling

Use the console, opened from the box at the bottom of the editor or with the backtick key, and try these commands:

• stat fps shows the current frame rate.
• stat unit shows how long each frame takes, split into game thread, draw thread, and GPU time. Whichever number is highest is your bottleneck.
• stat gpu breaks GPU time into categories, so you can see whether lighting, shadows, or geometry costs the most.
• ProfileGPU captures a single frame and opens a detailed breakdown.

Do a simple comparison. Record what stat unit shows with Lumen on. Then switch Dynamic Global Illumination Method to None, or try a lower Engine Scalability preset from the viewport settings, and look again. Do the same by disabling Nanite on your heaviest meshes. The difference tells you what each system costs on your hardware.

Also watch for practical signs: the editor stuttering when you move the camera, long shader compile waits, or video memory warnings. And remember that your players’ computers may be weaker than yours.

When to leave them off

Nanite and Lumen are tools, not requirements. Consider turning them off when:

• Your art is stylized. Flat colors, toon shading, or low-poly models gain little from dense geometry or physically based bounce light.
• Your lighting never changes. A static interior can use baked lighting and look great at a lower cost.
• Your graphics card is weak. If the editor is painful to work in, you will build less. Turning these off can make your daily work smoother.
• Your target platform does not support them. Support varies by platform and hardware, and some targets need a different setup. Check Epic’s platform notes for each system before you design around it.
• Your game is small. If a handful of simple meshes makes up your levels, Nanite has little to optimize.

You can also mix approaches: Nanite on your detailed environment pieces, regular meshes elsewhere, and baked or simpler lighting in parts of the game that do not need dynamic light.

Your plan for this week

Build the test scene. Turn each system on and off while watching stat unit. Then ask two questions about your real project: does my art benefit from this detail and lighting, and can my players’ hardware afford it? Let your measurements answer.