Overview

Natsura is a procedural foliage toolkit inside Houdini.
It combines growth simulation, procedural modeling, and artist-driven control to build trees, shrubs, grasses, and more — all without leaving Houdini.

This page gives a bird’s-eye view of how Natsura is structured, what the major node categories are, and where to start depending on your level of experience.

The Big Picture

At its core, Natsura is a graph system:

• Graph-building nodes like Grow, Split, Repeat, and Switch construct an Apex graph that deals with internodes, attributes, and growth logic.
• Mapping and Effectors feed variation and environmental response into sockets.
• Simulate executes the graph to generate geometry and apply decorations.

Think of it as authoring the rules first (the graph), then running them later (the simulation).

Node Layers

Natsura’s node system is organized into three conceptual layers:

1. Wrappers (artist-facing)

Nodes designed for everyday use by artists.
They package useful assemblies of logic with a streamlined UI and sockets.
Examples:

• Grow
• Switch
• Repeat
• Split
• Prune
• Wrangle (for advanced custom logic)

2. Core Nodes (technical building blocks)

Low-level verbs that wrappers are built from.
Granular, explicit, and closer to Houdini’s primitives.
Examples:

• grow_core
• repeat_core
• split_core
• switch_core
• wrangle_core
• kill_core

3. Execution

The node that actually runs the graph:

• Simulate — traverses the graph, resolves mappings/effectors, applies decorations, and outputs geometry.

Mappings, Effectors, and Decorations

These three concepts make the graph dynamic and expressive:

• Mappings (Map)
  Attribute-driven remaps that control parameters over space and time. Chained linearly, each Map blends into the next.
  Upcoming: Map If and Map Blend for non-linear logic.
• Effectors
  Bring in world-space influences like gravity, light, or collisions. Plugged into sockets to guide growth responsively. (See Effectors)
• Decorations
  Post-simulation geometry (leaves, bark, clusters). They don’t affect the growth graph, only the rendered appearance. (See Decorations)

Typical Workflow

1. Start with Simulate — place a Simulate node with default settings.
2. Add a Grow — connect a Grow node to define the first branch structure. Increase its scope using built-in repeat and branching.
3. Expand the recipe — attach additional Grow, Switch, or Repeat nodes to develop complex architectures (trees, shrubs, tufts).
4. Promote parameters to mappings — convert constants into Map chains for taper, probability, tropisms, or other spatial/temporal variation.
5. Decorate — enrich the structure with Decorations like trunks, bark, clusters, and leaves.
6. Optional advanced steps — bring in leaf atlases via Atlas Processing, integrate high-poly assets with Highpoly Processing, and composite them into assemblies for export to Unreal or other DCCs.

Who Uses What

• Artists — work mainly with wrappers (Grow, Switch, Repeat, Split, Prune) and mappings.
• Technical artists — dive deeper into Wrangles and Core Nodes for custom logic or specialized workflows.
• Pipeline developers — may extend Natsura with custom wrappers or integrate with external data.

Next Steps

• Start with Grow to understand how a single growth step works.
• Read Core Nodes if you want the technical foundations.
• Explore Mapping, Effectors, and Decorations to control and enrich growth.
• Finally, learn Simulate to bring it all together.

Notes

• Natsura is evolving. Some features (conditions, advanced mapping logic) are work in progress.
• Attribute-driven pruning and time-dependent changes are currently limited, except via Wrangle.