Natsura in the Unreal foliage ecosystem

Unreal Engine 5.7 changed the foliage conversation:

• The Procedural Content Generation framework (PCG) is now a production-ready graph system for populating environments at scale.
• PCG Editor Mode adds spline / paint / volume tools built on PCG graphs for in-editor worldbuilding.
• The Procedural Vegetation Editor (PVE) is a graph-based tool for creating and customising vegetation inside Unreal, with direct Nanite skeletal assembly output.
• Nanite Foliage is a geometry system that renders dense, high-detail foliage using Nanite voxels and assemblies, with support for assets from PVE and external DCCs via USD.

Natsura fits into that stack as an upstream growth engine in Houdini that supplies Unreal with well-structured trees, species libraries, and ecosystems.

1. What Unreal now gives you out of the box

Unreal’s foliage stack today looks roughly like this:

• PCG framework & Editor Mode
  A graph system inside Unreal for generating content (including foliage) from rules and samples – with editor tools to draw splines, paint, or define volumes and drive PCG graphs.
• Procedural Vegetation Editor (PVE)
  A vegetation-focused layer built on PCG: graph-based authoring of assets in-engine, with the ability to output Nanite skeletal assemblies and plug directly into Nanite Foliage.
• Nanite Foliage
  A geometry system designed to render dense, high-detail foliage using Nanite voxels and Nanite Assemblies / Skinning, with support for assets from PVE and trees imported from external tools via USD.

It’s a strong in-engine environment stack. Natsura’s job is to feed it with species, hero trees, and libraries that match your projects and remain useful beyond a single game.

2. Natsura’s job: upstream growth engine, not another layout tool

Inside Houdini, Natsura gives you:

• A growth graph engine – nodes like Grow, Split, Repeat, Switch, all executed by Simulate.
• A clean split between structure (growth, branching, species logic) and meshing (via Decorations).
• Artist-facing wrappers on top of that engine so building trees still feels like modelling, not like programming.

From Unreal’s point of view, Natsura is:

A way to author structured, Nanite-ready trees and ecosystems in Houdini,
then hand them to PCG, PVE, Nanite Foliage, and your existing tools.

3. Natsura + PCG: who owns what?

A clean division of labour:

• Natsura handles growth and structure
  • Species and family definitions.
  • How age, stress, or style affect form.
  • How scans are extended into full trees, roots, and forests.
  • How much geometry exists at each scale, Nanite or otherwise.
• Unreal’s PCG handles distribution and context
  • Where trees go on a specific map.
  • Density, biomes, and gameplay-driven variation.
  • Streaming, runtime behaviour, and performance tuning.
  • Feeding instances or assemblies into Nanite Foliage.

In practice:

1. Build species / recipes in Natsura.
2. Export Nanite meshes, skeletal assemblies, or instanced forests to Unreal.
3. Use PCG graphs and Editor Mode tools to place and manage those assets per level.

Natsura cares about what your vegetation is. PCG cares about where and how often it appears.

4. Natsura and the Procedural Vegetation Editor

Procedural Vegetation Editor sits in a useful spot:

• It’s graph-based and runs entirely in Unreal.
• It can output Nanite skeletal assemblies and talk directly to Nanite Foliage.
• It’s designed for in-editor procedural shaping and adjustment.

Natsura complements that by living one layer up:

• You define species in Natsura – including hero trees and full libraries.
• You export hero trees as skeletal mesh assemblies directly when you want full control and high detail.
• You can export entire libraries of assemblies or forests of instances for PCG-driven worlds.
• Where you want designers to retain procedural shaping control directly inside Unreal for non-hero vegetation, you can also export Natsura trees into forms that PVE can consume and use as inputs to its own graphs.

So you get a clear pattern:

• Natsura for authoring and species work.
• PVE for in-editor procedural adjustment where that’s useful.
• Both feeding the same Nanite Foliage and PCG setup.

5. Author once, use across projects (and engines)

Building vegetation purely in Unreal graphs ties your definitions to a single engine.

With a Houdini + Natsura layer:

• A species recipe – Grow, Split, Mapping, Effectors, Decorations – is engine-agnostic.
• The same recipe can export to UE5 + Nanite Foliage, other engines, offline renders, or future platforms.
• Unreal-specific logic (PCG graphs, Blueprints, runtime swaps) sits on top of that, rather than owning the whole definition.

If you expect to ship multiple projects or support multiple engines, keeping growth in Houdini and worldbuilding in Unreal pays off quickly.

6. Nanite, classic LODs, and rigged trees

Natsura’s outputs are intentionally straightforward from Unreal’s perspective:

• For Nanite pipelines
  • Nanite static meshes for dense instance-based foliage.
  • Nanite-ready skeletal mesh assemblies when you need structured wind and deformation.
• For non-Nanite pipelines
  • Traditional static meshes with authored LOD chains.
  • Card / billboard style assets for distance use.
  • Instance-friendly meshes for existing foliage volumes and painters.

In all cases:

• Trees come with clear hierarchy, attributes, and naming so your wind, animation, and destruction setups can treat them like any other rigged asset.
• Hero trees, set pieces, and background forests can all be driven from the same Natsura recipes with different export targets.

Whether your project is all-in on Nanite or still using classic LODs, the same growth engine feeds both.

7. Live Houdini inside Unreal when you need it

Sometimes you want Houdini-side control inside Unreal:

• Parametric dials for species.
• Scene-aware nudges before baking.
• Project-specific tools.

Because Natsura is a set of Houdini nodes and HDAs, you can:

• Wrap Natsura graphs in HDAs.
• Bring them into Unreal through Houdini Engine.
• Expose a curated subset of parameters to designers or technical artists.

From there you can bake:

• Static meshes and assemblies into Nanite Foliage.
• Instances into PCG graphs or standard foliage tools.

You keep the deep authoring in Houdini, while Unreal gets the controls it needs for day-to-day work.

8. How it feels day to day

A practical Unreal-centric pipeline with Natsura might look like:

1. Build species and hero trees in Natsura
   • Trees, shrubs, grasses, hero trunks, roots.
   • Extend scans, define age ranges, stress variants, and styles.
2. Export to Unreal
   • Nanite meshes and skeletal assemblies for hero assets and dense forests.
   • Classic static meshes + LODs where Nanite isn’t on the table.
   • Optional: export non-hero trees in forms that PVE can use as procedural inputs.
3. Worldbuilding in Unreal
   • Use PCG graphs and Editor Mode for placement.
   • Use PVE where direct in-editor shaping is helpful.
   • Feed everything into Nanite Foliage or existing foliage systems.
4. Iterate
   • When a biome or gameplay zone needs a new look, adjust the recipe in Natsura, regenerate, and let your PCG / PVE graphs reuse the updated assets.

9. When Natsura is worth adding to your Unreal stack

Natsura is likely worth its place in an Unreal-heavy pipeline if:

• You care about building and owning a vegetation library.
• You expect to work with foliage-dense worlds and want tighter control over structure than presets allow.
• Houdini is already in your toolchain, or you’re comfortable bringing it in for vegetation.
• You want a complete foliage package which offers more control.

If you’re thinking in terms of libraries, ecosystems, and the next few projects, Natsura gives you a growth engine that fits naturally alongside Unreal’s foliage stack.

10. Next steps