Nanite and Lumen explained: how Unreal Engine 5 draws a world

Nanite is Unreal Engine 5’s virtualised geometry system: it lets a game draw extremely detailed meshes by splitting them into small clusters of triangles that stream in and out and change detail on their own with distance. Lumen is its dynamic global illumination and reflections system: light bounces off surfaces in real time, so moving the sun or opening a door changes the whole scene without baked lighting. Together with Virtual Shadow Maps, MegaLights and TSR, they are the core of how UE5 draws a world in 2026.

This guide explains each one with Epic’s own documentation and numbers, the limits that marketing tends to skip, and two lessons from using them to render an entire planet in COLONIZED.

The five technologies at a glance

Technology	What it solves	What it costs or limits	Status in UE 5.8
Nanite	Very dense geometry without hand-made levels of detail	Opaque and masked materials only; up to 16 million instances; needs DirectX 12 and Shader Model 6	Production; Nanite Foliage experimental since 5.7
Lumen	Real-time global illumination and reflections	About 4 ms per frame for 60 fps at 1080p on console; changes in global light take seconds to settle	Production; Lumen Lite new in 5.8
Virtual Shadow Maps	Sharp, consistent shadows at any distance	Animation and moving geometry invalidate the cache every frame	Production
MegaLights	Many shadow-casting lights at a nearly constant cost	Quality drops when lighting gets complex; not for water or clouds	Production-ready in 5.8
TSR	Upscaling a lower internal resolution to a sharp output	Needs several frames to converge after something new appears	Production

Nanite: geometry without levels of detail

Traditionally, every 3D model needed several versions with fewer and fewer triangles, swapped as the camera moved away. Nanite removes most of that work. At import, a mesh is converted into an internal compressed format and split into hierarchical clusters of triangle groups. At runtime, the engine streams only the clusters the camera needs, at the detail the screen can actually show, and swaps them without cracks. Nanite renders in its own pass, without traditional draw calls, and Epic recommends an SSD because of the streaming.

In the 5.x series Nanite has grown well beyond static rocks: it supports skeletal meshes, landscapes, splines, instanced meshes and foliage painting, plus tessellation for runtime displacement. Nanite Foliage, experimental since 5.7, combines voxels for distant vegetation with assemblies and skinning for wind.

The documented limits matter as much as the features:

• Up to 16 million instances in a scene.
• Only opaque and masked materials; nothing translucent.
• No morph targets, forward rendering or MSAA.
• Ray tracing uses a fallback mesh by default; tracing Nanite geometry directly is still experimental.
• It requires DirectX 12 with Shader Model 6.

Lumen: light that bounces in real time

Global illumination is the light that arrives indirectly: the sun hits sand, the sand lights the underside of a rock. Before Lumen, most games baked it into textures, which meant it could not change. Lumen computes it every frame, with “infinite” diffuse bounces, at scales from millimetres to kilometres, and it handles reflections too.

It can trace in two ways:

• Software tracing uses signed distance fields: the first two metres against each mesh’s own distance field, the rest against a global one. It needs Shader Model 6 and, according to Epic, a GTX 1070 or better.
• Hardware ray tracing traces real triangles and needs an RTX 2000 series, a Radeon RX 6000 series, or a current console.

To shade what the rays hit, Lumen keeps a surface cache: it captures each mesh’s materials from a set of “cards” generated offline. Areas without card coverage do not bounce light.

Lumen has a budget and a set of rules. Epic targets 8 ms per frame at 30 fps and 4 ms at 60 fps, at 1080p internal resolution on console, and each scalability level costs roughly half of the one above. In software mode, the Lumen scene covers 200 metres around the camera (extendable to 800). Walls should be at least 10 cm thick to avoid light leaks. Global changes, such as switching off the sun, can take several seconds to propagate. UE 5.8 adds Lumen Lite, based on irradiance fields, which Epic describes as twice as fast as Lumen at high quality.

Virtual Shadow Maps, MegaLights and TSR

Virtual Shadow Maps give every light a virtual 16k × 16k shadow map split into 128 × 128 pages, and render only the pages the camera needs, cached between frames. For the sun, a set of clipmaps covers from 64 cm to about 40 km. With Nanite, Epic recommends them as the shadow method. Their weak point: anything that moves (animation, wind, moving geometry) invalidates the cache every frame.

MegaLights traces a fixed number of rays per pixel towards the most important lights and denoises the result, so hundreds of shadowed lights cost almost the same as a few. It was experimental in 5.5, beta in 5.7 and became production-ready in 5.8. Its cost is nearly constant, but quality drops as lighting gets more complex, and Epic still recommends Virtual Shadow Maps for the sun.

Temporal Super Resolution renders at a lower internal resolution and reconstructs a sharp image using previous frames. With a 1080p input, Epic says it approaches native 4K quality at around half the GPU time. It needs a few frames to converge: at 50 % resolution and 60 fps, a newly revealed area takes about 66 ms to fill in.

Five myths, corrected

1. “Nanite means unlimited polygons for free.” It makes dense geometry practical, but it has limits on instances, materials and ray tracing.
2. “Nanite is only for static meshes.” In 5.x it also covers skeletal meshes, landscapes, splines and, experimentally, foliage.
3. “Lumen needs an RTX card.” Software tracing runs on Shader Model 6 GPUs from a GTX 1070 up; hardware tracing is optional.
4. “MegaLights is experimental.” Not since 5.8, where it is production-ready.
5. “TSR gives native 4K.” It approaches it; it reconstructs from a lower resolution and needs several frames.

How COLONIZED uses them, and two things we learned

The development build of COLONIZED runs on Unreal Engine 5.8 and renders with Nanite, Lumen (software tracing by default, with hardware ray tracing tested but not promised) and Virtual Shadow Maps, with TSR on graphics cards without DLSS. A planet is a hard case for all of these, because its terrain is not an imported mesh but geometry generated on the GPU, chunk by chunk, as you move.

A planet can be invisible to Lumen. Software Lumen traces distance fields, and our terrain chunks are dynamic meshes that do not generate one. To software Lumen, the ground simply did not exist: it concluded that light could not reach places it obviously reached, which showed up as black patches and straight cuts at the edges of the global distance field. The fixes are either to make the terrain generate distance fields or to trace it with hardware ray tracing, where real triangles count; we have tested both paths, and this is still work in progress.

Lumen built cards for every pebble. Lumen’s surface cache creates cards for every mesh above a small size, and in a desert full of scattered stones and grass, that is an enormous number of tiny cards. The result was not slowness but a GPU timeout during take-off. Raising the minimum mesh size that gets cards removed the timeouts with Lumen still on, and the bounce light that matters, on rocks and buildings, stayed the same.

The third lesson, about switching Lumen off because it made a desert darker, is in our October 2026 devlog. How we brought the video memory of a planet from 12.5 GB to 5.3 GB is in the PC optimisation guide.