Nanite is the virtualized micropolygon geometry system of Unreal Engine 5 that renders meshes with millions of triangles by streaming and drawing only the detail that is visible on screen. Among modern game engines, it changed how artists treat polygon budgets: instead of authoring several hand-made levels of detail (LODs), a team imports a high-resolution source asset and lets the engine select per-cluster detail at runtime.
In gaming, Nanite matters because geometric complexity used to scale with draw calls, memory and manual optimization work. Nanite decouples scene complexity from rendering cost, so frame time depends mostly on screen resolution and visible pixels rather than on the raw triangle count of the level. It works alongside Lumen for lighting and Virtual Shadow Maps for shadows, but it is a separate system with its own rules and limits.
How Nanite builds and renders geometry
Nanite works by preprocessing each mesh into a hierarchy of triangle clusters and then choosing, every frame on the GPU, the coarsest clusters that still look correct. During import, the engine splits the mesh into clusters of roughly 128 triangles, groups neighboring clusters, simplifies each group, and repeats the process until a single coarse root remains. The result is a directed acyclic graph of cluster groups rather than a simple chain of discrete LOD meshes.
At runtime, a GPU-driven culling pass walks this graph and picks clusters whose simplification error projects to less than about one pixel on screen. Because neighboring cluster groups share locked boundary edges during simplification, adjacent regions can sit at different detail levels without visible cracks. Visible clusters then pass through frustum culling and a two-pass hierarchical depth occlusion test, so hidden geometry is rejected before rasterization.
Rasterization itself is split. Small triangles that cover only a few pixels go to a software rasterizer written in compute shaders, which is faster than fixed-function hardware for micropolygons. Larger triangles go to the hardware rasterizer. Both write into a visibility buffer that stores triangle and instance identifiers per pixel, and materials are evaluated afterward in a deferred material pass. This keeps shading cost tied to pixels rather than triangles.
The table below summarizes the main stages and what each one contributes to performance.
| Stage | When it runs | What it does |
|---|---|---|
| Cluster building | Asset import or build | Splits the mesh into small triangle clusters and simplifies groups |
| Compression and paging | Asset build | Packs cluster data into compact pages for disk and memory |
| LOD selection | Every frame on the GPU | Picks clusters whose error stays below about one pixel |
| Occlusion culling | Every frame on the GPU | Rejects instances and clusters hidden behind closer depth |
| Rasterization | Every frame | Software path for tiny triangles, hardware path for large ones |
| Material pass | After rasterization | Shades visible pixels from the visibility buffer |
Streaming, memory and data size
Nanite treats geometry like virtual texturing treats texels: only the pages needed for the current view are resident in GPU memory. A fixed-size streaming pool holds cluster pages, and the engine requests finer pages as the camera approaches a surface and evicts pages that are no longer needed. This is why a level can contain billions of source triangles while the frame draws only a few million.
On disk, Nanite meshes are stored in a compressed format that is often comparable to or smaller than a traditional mesh with a full LOD chain, although the exact ratio depends on topology, vertex attributes and UV seams. Meshes with many UV seams and hard normals compress less efficiently, because split vertices break cluster continuity. Each Nanite mesh also keeps a fallback mesh, a low-polygon proxy used for collision, some ray-tracing paths and platforms that cannot run Nanite.
Nanite compared with traditional LOD workflows
The key difference between Nanite and classic LODs is granularity: traditional LODs swap a whole mesh at distance thresholds, while Nanite adjusts detail continuously across individual regions of one mesh. The comparison below shows where each approach stands in a modern rendering pipeline.
| Aspect | Manual LOD meshes | Nanite |
|---|---|---|
| Detail switching | Whole mesh at set distances | Per cluster, continuous |
| Artist effort | Several LODs authored or generated | One high-resolution source |
| Visible popping | Common at LOD transitions | Largely eliminated |
| Draw call cost | Grows with object count | Batched by GPU-driven rendering |
| Small triangle efficiency | Poor on hardware rasterizer | Handled by software rasterizer |
| Platform reach | Works almost everywhere | Needs modern GPUs and APIs |
Nanite does not remove the need for good asset hygiene. Excessive vertex attributes, unnecessary material slots and broken topology still cost memory and build time. It also does not replace texture streaming, because surface detail from normal maps and textures remains a separate budget.
Supported content and platform requirements
Nanite supports opaque static meshes first and foremost, and its coverage has expanded with each Unreal Engine 5 release. Later versions added masked materials, World Position Offset for animated foliage, spline meshes, experimental Nanite tessellation with displacement, and experimental support for skeletal meshes. The exact feature set depends on the engine version, so teams should verify support in the version they ship with.
Hardware requirements are significant. Nanite needs DirectX 12 with Shader Model 6 or an equivalent Vulkan or Metal path, and it runs on current consoles such as PlayStation 5 and Xbox Series X and S. Older GPUs and many mobile devices fall back to the proxy mesh, which means a project that targets broad hardware must still check how its fallback geometry looks.
The table below lists common content types and how well they suit Nanite.
| Content type | Suitability | Reason |
|---|---|---|
| Rock, terrain props, architecture | Excellent | Dense, opaque, rigid geometry |
| Photogrammetry scans | Excellent | Very high triangle counts are the target use |
| Foliage with masked leaves | Good with care | Overdraw and masked shading add cost |
| Translucent glass or water | Not supported | Visibility buffer stores one opaque surface per pixel |
| Characters with deformation | Limited | Skeletal support is newer and version dependent |
| Tiny decorative clutter | Mixed | Many instances can still stress culling |
Performance pitfalls and common mistakes
The most frequent Nanite problem is overdraw from stacked geometry, where many thin or overlapping surfaces, such as dense grass or layered debris, defeat occlusion culling. Another is assuming that Nanite makes geometry free: memory, build times and shading cost still grow, and Virtual Shadow Maps must re-render pages when Nanite geometry with World Position Offset moves. Profiling with the engine’s Nanite visualization modes, such as overdraw and cluster views, is the reliable way to find these costs.
| Symptom | Likely cause | Fix |
|---|---|---|
| High GPU time in foliage areas | Overdraw from layered masked cards | Use modeled geometry or reduce layers |
| Shadow cost spikes | Animated World Position Offset invalidates shadow pages | Limit animation distance or disable it on far meshes |
| Blurry or low-detail surfaces | Streaming pool too small | Increase pool size or reduce source density |
| Large package size | Many UV seams and attributes | Clean topology and remove unused channels |
| Bad look on older hardware | Coarse fallback mesh | Raise fallback triangle percentage |
- Do not enable Nanite on translucent or heavily deforming meshes without checking support first.
- Do not judge performance in the editor viewport alone; profile packaged builds on target hardware.
- Do not drop texture budgets because geometry got denser, since materials remain a separate cost.
In simple terms
Nanite is a way for Unreal Engine 5 to draw extremely detailed 3D objects without slowing the game down. Imagine a map that shows street names only when you lean in close. When you step back, it shows only highways. Nanite does the same with shapes. It shows fine detail up close and simpler shapes far away. It also works piece by piece, not object by object.
As a result, artists can use movie-quality models directly in a game. The computer spends effort only on the detail a player can actually see.
A practical example
A small studio builds a canyon level for an exploration game using photogrammetry scans of real rocks. Each scanned cliff contains about two million triangles, and the level uses roughly three hundred instances. With traditional LODs, the team would need to generate and tune four LODs per asset and still accept visible popping as players climb.
With Nanite enabled, the artists import the scans directly. On a current console at 1440p, the frame draws only a few million triangles because most cliff detail is either distant or hidden. Profiling reveals one problem: layered grass cards at the canyon floor cause heavy overdraw. Replacing them with fewer modeled grass clumps brings the scene to a stable 60 frames per second target, and the team saves weeks of manual LOD work.