Nanite Foliage in Unreal Engine 5.7: what breaks before you ship

Turn on Nanite Foliage in Unreal Engine 5.7 and your first dense forest either renders at a rock-solid frame rate or grinds to a crawl with popping instances and wind animation that never fires — and the difference usually comes down to three settings you set once, per mesh, before you place a single instance. Nanite Foliage shipped in 5.7 as an Experimental rendering system: check Support Nanite in Project Settings, set Shape Preservation to Voxelize on each Static Mesh, and pick a mesh type — regular versus Nanite, static versus skeletal — that decides whether your leaves move in the wind at all. Epic's own release notes admit collision, physics, and wind animation are incomplete in this first ship, so here's what to check before you commit an open world's worth of vegetation to it.

What Nanite Foliage actually changes

Nanite Foliage renders through the same virtualized geometry pipeline as any Nanite mesh, which means draw call cost stays flat no matter how many instances you place — a handful of trees and a few million read the same on the GPU's command buffer. Teams tuning voxel density report rasterization time dropping to around 3.2ms, and on a 60fps target with a 16.67ms frame budget, that typically leaves 30–40% of the frame for all Nanite work combined, vegetation and terrain and structures included. The Procedural Placement Tool will generate placement data for a 4km² landscape in 15–30 seconds on a modern workstation, scattering several million instances by rule instead of by hand. None of that is free — it moves the bottleneck off draw calls and onto shadow cost and gameplay readability. A forest that renders fine can still read as visual noise to a player trying to spot movement inside it.

Turn it on: the exact settings

Three settings, in order. First, Project Settings → Engine → Rendering → Support Nanite. Nothing below this works until it's checked, and it forces a shader recompile, so budget a few minutes on a large project. Second, select the Static Mesh, open its editor, and in the Details panel find Nanite Settings → Shape Preservation. Set it to Voxelize. That's the flag that swaps the mesh off Nanite's default hard-surface path and onto the representation Nanite Foliage actually uses for thin, overlapping leaf and branch geometry — leaving it on the default is the single most common reason a foliage mesh looks fine alone and falls apart in a dense cluster. Third, confirm the mesh has exactly one entry in its Elements array at LOD0. Light and shadow maps are shared across every LOD level in Nanite Foliage, so if your LODs don't share identical UV unwrapping, shadows break the moment the mesh switches LOD in the distance.

If you're bringing in a foliage pack rather than one hero tree, get the meshes into the project first — BitSoul's UE5 plugin drops GLB assets into the Content Browser at correct scale, which matters here because Nanite's voxel budget is resolution-dependent, and an asset that imports 100× too large wastes voxel density rendering air.

Shape Preservation itself isn't in the documented Python API yet, so voxelizing fifty meshes in a pack still means fifty manual clicks in 5.7. You can at least audit which ones already have Nanite enabled before that pass, from the selected assets in Content Browser:

# audit Nanite status across every selected Static Mesh
import unreal

for data in unreal.EditorUtilityLibrary.get_selected_asset_data():
    mesh = data.get_asset()
    if isinstance(mesh, unreal.StaticMesh):
        ns = mesh.get_editor_property("nanite_settings")
        print(f"{mesh.get_name()}: nanite_enabled={ns.enabled}, "
              f"keep_tris%={ns.keep_percent_triangles*100:.0f}")

Anything printing nanite_enabled=False is your click-through list.

Pick the mesh type that keeps your wind

Nanite Foliage exposes four mesh type combinations, and picking the wrong one is how teams lose wind animation without noticing until a playtest.

That last row carries the catch: Epic's 5.7 notes flag wind animation, physics, and collision as incomplete on the Nanite Skeletal path in this first ship. If a playtest build needs foliage that reliably sways, keep it on regular Skeletal Mesh until a later patch closes the gap. A workable split for most scenes is Nanite Static Mesh for everything in the background and regular Skeletal Mesh for the handful of plants a player will actually stand next to.

Nanite Assemblies for branches and fronds

A single redwood's branch structure is thousands of near-identical, repeating pieces — exactly the case Nanite Assemblies were built for. An Assembly treats a small detailed piece — one frond, one leaf cluster, one bark chunk — as a micro-instance and can pack up to 65,000 instances of it into a single mesh asset, so the tree's silhouette gets full geometric detail without you hand-placing every branch. It's the same micro-instancing idea as GPU instancing at the engine level (see the GPU instancing guide for Unity, UE5, and Godot for the non-Nanite version), except Assemblies handle it inside a single Nanite mesh instead of at the draw-call level.

A model with real branch and canopy density, like Redwood Tree, is a reasonable stand-in for testing this before committing a whole pack to it: import it, set Shape Preservation to Voxelize, and check whether the canopy still reads correctly at 50+ meters. A free account's two monthly downloads cover evaluation; commercial use is included with paid memberships (pricing).

What's still broken in this first ship

Treat all of the above as Experimental, because Epic does. Wind animation on Nanite Skeletal Mesh is inconsistent — expect frames where fronds simply don't move. Collision on voxelized meshes doesn't always match the visual silhouette, so a player can clip through leaves that should block them or catch on branches that look passable; test collision explicitly instead of trusting the Nanite proxy. Physics — anything that expects foliage to react to an explosion or a vehicle pushing through it — isn't reliable yet either. None of this blocks background dressing, where Nanite Foliage is a genuine win on frame time; it blocks anything gameplay depends on being correct.

If you're populating a level procedurally alongside this, the PCG framework for scattering 3D assets reached production status in the same 5.7 release and pairs naturally with Nanite Foliage: scatter placement with PCG, render the result with Nanite Foliage, and keep anything gameplay-critical on the traditional Skeletal Mesh path until Epic closes the physics and collision gaps.

This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.

Build with real assets: grab game-ready nature 3D models on the BitSoul marketplace and drop them straight into your project.