Natsura is a Houdini native vegetation and plant generation toolkit positioned as an end to end foliage authoring environment for games and VFX, spanning growth simulation, procedural modelling, meshing, scan extension, and export focused workflows (including Unreal Engine targets).
As of April 2026, Natsura is publicly distributed in Early Access and the Natsura website surfaces an “Early Access v0.6.0.3” build label.
What is Natsura for Houdini plant generation?
Natsura is described by its documentation as “a procedural foliage toolkit inside Houdini” that combines growth simulation, procedural modelling, and artist driven control to build trees, shrubs, grasses, and more without leaving Houdini.
A defining technical concept in Natsura’s workflow is the separation between authoring rules (building a growth graph) and executing rules (running a simulation pass). The Simulation documentation frames this as deferred evaluation: nodes like Grow/Split/Repeat describe rules, which are stored in an APEX graph; the Simulate stage then resolves those rules, applies mappings and effectors, and produces skeletons and final geometry.
This “graph first” approach matters in production because it supports iterative changes to behaviour and variation logic (for example, re driving growth parameters via attributes and mappings) without constantly reconstructing heavy downstream geometry networks, at least in the way Natsura’s own “Traditional procedural modelling vs Natsura” comparison is presented in its docs.
Natsura early access release: what’s included in version 0.6
Natsura’s release notes for 0.6.0.0 list its headline scope as modular effectors, Nanite assemblies, the Assembly Decorator, a revamped UI, analytics (opt in), scan extension, and Houdini 21.0 support, with the build targeting Houdini 20.5 and 21.0.
Within those release notes, several Early Access “production workflow” priorities stand out:
- Unreal focused Nanite assembly exports and wind tooling, described as “battle tested unreal nanite skeletal assembly support” plus multiple wind related nodes and Unreal wind JSON export.
- Assembly workflow for canopies, including nodes for importing/auto rigging module libraries and assembling canopy structures via the Assembly Decorator system.
- Modular effector system, positioned as bolt on simulation modifiers (including magnet/gravity/noise effectors), reducing the need for custom VEX for common shaping behaviours.
- Scan extension improvements, explicitly calling out procedural extension of “complex scans and sculpts with multiple trunks”.
Subsequent 0.6 patch notes (for example 0.6.0.3) continue to reference scan meshing fixes and Nanite assembly schema reintegration in scan pipelines, reinforcing that 0.6 remains active Early Access iteration rather than a “finished 1.0” stability milestone.
An external report contemporaneous with the 0.6 release summarises the update as adding new features for hybrid scanned/procedural trees (including multi trunk scan extension), introducing the Assembly Decorator for dense canopy building using USD, and adding modular effectors (including curves, magnets, and noise).
Houdini 20.5+ plant and tree generator plugin requirements
Natsura is distributed as a plugin/toolkit that runs inside Houdini, and its documentation explicitly states that it does not include Houdini itself: using Natsura requires a separate Houdini licence and compliance with both Natsura’s EULA and SideFX’s Houdini licensing rules.
Compatibility and installation requirements are stated in multiple places:
- Natsura is reported as compatible with Houdini 20.5+ in an external overview of the Early Access launch and pricing.
- Natsura 0.6.0.0 release notes list supported Houdini 20.5 and 21.0.
- A current Windows package based installation guide for Natsura requires Windows 10/11, SideFX Launcher, and Houdini 20.5 or 21.0 Python 3.11 production builds (explicitly excluding Houdini 20.5 Python 3.10 and daily/experimental builds in that guide’s “Before you start” checklist).
Where hardware baselines matter, SideFX’s Houdini 20.5 system requirements include minimum and recommended memory guidance, CPU instruction set requirements (SSE 4.2), and minimum graphics/OpenGL requirements.
Licensing related operational requirements can also be “workflow requirements” in practice. Natsura’s pricing/licensing page states that Natsura uses node locked licensing and includes an FAQ entry indicating that online access is required “for now” while using Natsura.
Natsura licensing and pricing for Houdini Indie users
Natsura’s licensing model is tiered by revenue and sold as subscription and/or perpetual options (depending on tier), with the pricing page describing Indie eligibility as revenue below USD 100,000/year and describing node locked licensing, install device limits, and an online connection requirement.
For concrete Indie price points during Early Access, an external pricing summary states that (for revenue under USD 100,000/year) perpetual Indie licences are priced at €180 (reported as “around $210”), while rental is €15/month or €125/year, and that the software remains in Early Access at the time of reporting.
Commercial use pairing between Houdini editions and Natsura editions is explicitly addressed in Natsura’s documentation: even if a higher Natsura tier can technically run while Houdini is in Apprentice mode, that does not convert Apprentice into a commercial licence, and “the strictest rule wins” if Houdini and Natsura terms differ.
Procedural tree creation in Houdini with botanical growth simulation
Natsura’s positioning blends procedural modelling with growth simulation concepts. In third party coverage of the Early Access release, Natsura is characterised as combining parametric modelling, botanical simulation, and rules based controls, with node based “recipes” that define a plant’s “DNA”.
The Natsura documentation details how this is structured in practice:
- Graph building nodes (Grow, Split, Repeat, Switch, Wrangle, Prune) define growth logic rather than immediately outputting meshes.
- The Simulation stage evaluates the APEX graph, applies mappings and effectors, generates internodes/skeleton, then applies decorations to generate geometry.
Because Natsura builds on APEX, it is useful to anchor the term: SideFX documentation defines APEX (All Purpose EXecution) as a graph evaluation framework that builds and runs graphs and outputs their results. Natsura’s simulation explanation aligns to this by stating that growth rules are stored in an APEX graph and resolved at Simulate time.
The practical “workflow benefit” implied by these mechanics is that high level rule changes (for example, driving pitch, width, fork probability, or environmental response via mappings/effectors) can be edited at the graph/parameter level and then re simulated, rather than forcing a geometry by geometry rebuild typical of immediate mode SOP chains.
Modular effectors for procedural tree growth (curves, magnets, noise)
Effectors in Natsura are defined as per point vector attributes used to control growth (a companion concept to Mappings, which handle scalar parameter control). The documentation frames them as a reusable mechanism for directional and spatial influences such as gravity, light direction, curve attraction, magnets, and noise fields.
Natsura 0.6.0.0 release notes explicitly introduce a modular effector stack and list new effector nodes including magnet attraction, gravitropism, and noise based perturbation, alongside an “effector base” node intended for extension via VEX.
This aligns with external reporting on 0.6 describing a “modular effector system” and naming curves, magnets, and noise as growth influences, which matches the product’s own effector concept (vector fields written as attributes, later read by growth logic through weights and mappings).
Natsura node based workflow: building species presets and variation libraries
Several Natsura sources describe its core output as a node based recipe or graph definition that can be reused with variation controls:
- A third party report characterises Natsura as generating node based recipes defining the “DNA” of a plant, which can be leveraged for dynamic effects such as wind.
- Natsura’s own Simulate node documentation similarly states that the graph defines the “DNA” of the plant, and Simulate grows the plant by executing that graph.
- Natsura’s features page describes “Define Species” as creating compact species definitions whose recipes respond to high level “hyper parameters” such as age, vigour, health, and shade (with the intent of building a vegetation library rather than only one off assets).
From a pipeline design perspective, this approach emphasises systems and libraries (species definitions + variation rules) rather than only meshes. Natsura’s own “build vs buy” style comparison content reinforces this framing by stating that recipes built from graph nodes can express species definitions, age variation, biomes, and art direction rather than only individual hero trees.
How to generate forests at scale in Houdini with attribute driven plant tools
Natsura describes scaling beyond “one tree” through attribute driven instantiation and simulation workflows. Its features page states that points carrying attributes from other Houdini systems can be passed into Natsura to generate “immense variation” and that “Seed Points” can be used to grow many trees or ecosystems via attribute-driven setups.
The “attribute driven” aspect is not merely marketing terminology in Natsura’s documentation: Mapping is explicitly documented as attribute driven scalar control that lets one parameter vary along a plant, change with age/time, react to world space information, and switch behaviour by conditions without requiring that every possibility be a hard coded slider on every node.
Combined with the Simulation model (APEX graph + deferred evaluation), the system is designed to evaluate growth logic and then generate geometry in one controlled execution pass, which is the structural basis for scaling one recipe across many seeds while still differentiating outcomes via attributes, mappings, and effectors.
Hybrid 3D scan and procedural tree generation in Houdini
Natsura explicitly targets hybrid workflows that begin with scanned trunks/high-poly sources and extend them procedurally into complete trees.
In Natsura 0.6.0.0 release notes, scan related workflow improvements include “procedurally extend complex scans and sculpts with multiple trunks” and continued scan suite development. Patch notes in 0.6.0.3 also reference scan meshing fixes, reintegrating Nanite assembly schemas in the scan pipeline, and introducing polyreduce controls for scan extension density via “Graft Mesh”.
External reporting on the 0.6 update similarly highlights new features for creating trees that combine 3D scanned and procedural elements, including options to extend scans with multiple trunks.
This hybrid positioning is reinforced by Natsura’s feature messaging around “Extend Scans” and producing game usable outputs via baking/LOD tooling, which places scan derived geometry in the same end to end authoring context as fully procedural trees.
Creating game ready trees for Unreal Engine 5 with Natsura
Natsura’s product messaging and release notes consistently emphasise Unreal Engine oriented export workflows and the practical needs of game production: author in Houdini, export optimised geometry packages, and iterate quickly.
Natsura’s site explicitly foregrounds Unreal focused tooling such as Nanite assembly exports and “Run Tools in Engine” workflows, alongside content creation utilities like atlas processing, scan processing, and baking (high to low bakes, LOD generation).
The pricing page FAQ states that Natsura is designed around Unreal workflows and supports Nanite ready exports (including Nanite skeletal mesh assembly), includes an Unreal export wizard for batch exports, and supports Unreal dynamic wind systems; it also notes that Instanced Skinned Meshes (ISKMs) support is experimental and may evolve with Unreal.
On the tooling side, Natsura 0.6.0.0 release notes list explicit Unreal export and wind-related nodes (including Unreal wind JSON export) and include updates to Unreal Nanite assembly export supporting both skeletal and static assembly and material support.
UE5 Nanite foliage workflow from Houdini using Natsura
Nanite is Unreal Engine’s virtualised geometry system and, in Epic’s documentation taxonomy, includes concepts like Nanite Assemblies and Nanite Foliage. Additional Epic community tutorial entries specifically reference “Nanite Assemblies in USD” workflows using Houdini tutorials, indicating an intended DCC to Unreal path involving USD structures for assemblies.
Within that context, Natsura’s Nanite oriented workflow is described across Natsura sources as:
- Dedicated support for creating UE5 Nanite foliage and “Nanite skeletal mesh assemblies”.
- Export tooling that targets Nanite assemblies from within Houdini, including export updates listed in Natsura 0.6.0.0 release notes (material support; skeletal and static assembly support).
- Wind authoring tools and export hooks designed for Unreal’s wind systems, as described in both the pricing FAQ and release notes.
For production planning, it is also relevant that SpeedTree’s Unreal integration has its own Nanite compatibility history: Unity’s SpeedTree documentation notes that as of Unreal Engine 5.1, SpeedTree .st9 files work with Nanite, while in Unreal Engine 5.0 they were incompatible with Nanite. This provides a baseline reminder that Nanite foliage adoption has been engine version sensitive and that any Nanite workflow should be validated against the exact Unreal version targeted for production.
Using Houdini Engine to author foliage inside Unreal with Natsura
Houdini Engine for Unreal is SideFX’s integration layer for bringing Houdini Digital Assets (HDAs) into Unreal Editor with procedural controls, where Houdini networks are cooked “under the hood” and results are pushed back to Unreal; SideFX also explicitly states this is not a runtime solution, but a content creation workflow.
SideFX’s Unreal plug in page also includes operational details relevant to environment/foliage pipelines: the Unreal plug in is shipped with the Houdini installer, Houdini Engine licences are available (including free licence options), and SideFX notes that Houdini Engine plug ins do not work with the free Houdini Apprentice licence and assets created in Apprentice do not work with Houdini Engine licences.
Natsura explicitly positions itself to take advantage of this in editor paradigm. Its features page states that tools can run live inside Unreal using Houdini Engine, referencing Project Elderwood as an example of in engine foliage authoring, repeatedly highlighting an Unreal export wizard for sending libraries/forests to Unreal.
This is reinforced by SideFX’s own Project Elderwood page, which instructs that Houdini Engine must be set up properly to work with the procedural assets in the Unreal project files and describes Natsura being used for live tree creation within that demo pipeline.
USD based tree canopy workflows in Natsura (Assembly Decorator)
Natsura 0.6 introduces an Assembly workflow aimed at building dense canopies from rigged branch/twig module libraries. In Natsura’s 0.6.0.0 release notes, this is reflected in new nodes such as an assembly resource importer/auto rigger, an assembly canopy decoration node, and rig simplification/classification tooling.
External reporting on Natsura 0.6 specifically states that the Assembly Decorator enables “extremely dense canopies” out of rigged libraries of branches using USD, positioning it as a USD based canopy authoring solution rather than a purely SOP mesh scatter.
The role of USD in “assembly” workflows is well defined in OpenUSD documentation. OpenUSD’s introduction describes USD as enabling non destructive assembly and organisation of large numbers of assets into sets/scenes/shots/worlds via a consistent scenegraph and composition engine. The OpenUSD glossary defines an “assembly” as a kind of model that aggregates other models into collections, often consisting primarily of references to other assets.
Natsura’s 0.6.0.0 release notes also reference USD oriented tooling via LOP context nodes (for example, a Nanite assembly node “for USD workflows”), connecting canopy assembly logic to broader USD scene assembly patterns and Unreal facing Nanite assembly workflows.
Project Elderwood Houdini environment demo and Natsura foliage tools
Project Elderwood is a SideFX tech demo described as exploring game-art workflows using Houdini and Unreal, with a focus on rich vegetation; SideFX states the project utilises the Natsura plugin for live tree creation and provides Unreal project files and tutorials.
SideFX additionally notes that users can get early access to Natsura while it is in beta, and the Elderwood page includes a SIGGRAPH Asia event entry crediting Natsura’s tools as developed by Feike Postmes and George Hulm.
Independent coverage of Project Elderwood also points to Natsura as a primary foliage tool used in the demo, framing it as a third party vegetation toolkit used to generate game ready vegetation in that environment.
Natsura vs SpeedTree: which vegetation tool is better for production?
SpeedTree is widely established as a dedicated vegetation authoring solution, and Natsura’s own comparison article frames SpeedTree as a proven standalone tree modeler with a substantial feature set and library, contrasted with Natsura as a Houdini native growth graph engine intended to live inside Houdini pipelines rather than as a separate DCC.
From a vendor neutral standpoint, several “production decision” axes can be grounded in documentation from each ecosystem:
SpeedTree’s Unreal integration and compatibility are well documented through its official manuals: Unity’s SpeedTree documentation states that SpeedTree 9 .st9 files are supported in Unreal Engine 4.27+ and notes Nanite compatibility (Nanite support for .st9 as of Unreal Engine 5.1; incompatible with Nanite in Unreal Engine 5.0). Unity’s SpeedTree Modeler manual also frames SpeedTree Modeler as a dedicated product with its own learning and installation path.
On the SpeedTree roadmap side, third party industry coverage of SpeedTree 10’s release describes Unity maintaining a SpeedTree Library and SpeedTree SDK alongside the Modeler, and highlights new modelling features (such as a Vine generator and pruning/trim tools) that reflect ongoing development investment.
Natsura’s “production advantage” argument is primarily about pipeline unification and extensibility inside Houdini: its comparison content emphasises that vegetation can live in the same procedural space as layout/FX/USD/PDG/world building, and that growth rules, mapping, and effectors can be adapted to project specific concepts through an open node system rather than only fixed UI parameters.
A practical summary of “which is better” depends on what “production” means for a specific studio:
- For teams prioritising a specialised standalone vegetation authoring package with established importers and a mature “tree modeler + library” ecosystem, SpeedTree’s track record and its documented Unreal pipeline support remain strong factors.
- For teams prioritising Houdini native procedural integration including attribute-driven forests, USD oriented assembly concepts, Houdini Engine in editor workflows, and deep customisation via mappings/effectors and Houdini’s tooling Natsura is explicitly designed around that foundation.
In other words, SpeedTree optimises for a dedicated vegetation authoring environment with established exporters, while Natsura’s core promise is consolidating vegetation generation into Houdini’s procedural ecosystem (and therefore into studio specific pipeline logic) with Unreal-focused export hooks.
Frequently Asked Questions (FAQs)
- What is the current Natsura Early Access version?
Natsura’s site labels the current Early Access build as “v0.6.0.3”, and the changelog lists Natsura 0.6.0.3 as a patch dated April 2026. - Which Houdini versions does Natsura 0.6 support?
Natsura 0.6.0.0 release notes list Houdini 20.5 and Houdini 21.0 as supported, and the Windows installation guide targets Houdini 20.5 or 21.0 Python 3.11 production builds. - Is Natsura compatible with Houdini 20.5+?
Yes external coverage of the Early Access release states Natsura is compatible with Houdini 20.5+, and Natsura’s own 0.6 release notes list 20.5/21.0 compatibility. - Does Natsura support Unreal Engine workflows, Nanite, and wind?
Natsura’s pricing FAQ states support for Nanite ready exports (including Nanite skeletal mesh assembly), an Unreal export wizard, and Unreal dynamic wind systems; Natsura 0.6.0.0 release notes also list Nanite assembly and wind authoring/export nodes. - Can assets created with Natsura be sold or used commercially?
Natsura’s pricing FAQ states that “Customer Assets” created with Natsura belong to the customer and can be sold/used in commercial projects on paid tiers; it also states that Houdini Apprentice is non-commercial only. - Is an internet connection required to use Natsura?
Natsura’s pricing FAQ states that, for now, Natsura requires online access to the licensing service while in use. - Can a paid Natsura tier be used with Houdini Apprentice for commercial work?
Natsura’s Commercial Use documentation states that higher Natsura tiers can technically run in Apprentice mode, but this does not make Houdini Apprentice commercial; Houdini’s restrictions and EULA still apply, and the strictest rule wins. - What is the Indie revenue threshold for Natsura licensing?
Natsura’s pricing page describes Indie eligibility as revenue under USD 100,000/year, and external reporting of Natsura’s Indie pricing references the same threshold. - Is Natsura subscription-only, or are perpetual licences available?
Natsura’s pricing page distinguishes subscriptions versus perpetual licences and states that perpetual licences are intended as a one time purchase for a major version family, with Early Access FAQ details describing how perpetual coverage applies during Early Access. - How does SpeedTree Nanite compatibility compare at a baseline level?
Unity’s SpeedTree documentation notes that SpeedTree .st9 files work with Nanite as of Unreal Engine 5.1, while Unreal Engine 5.0 is noted as incompatible with Nanite for SpeedTree models, highlighting that Nanite foliage workflows can be dependent on engine version.
Conclusion
Natsura’s Early Access positioning centres on bringing vegetation generation into Houdini as a first class procedural system author growth rules as graphs, simulate via deferred evaluation using APEX, and scale variation through attribute driven mappings and vector effectors.
Version 0.6 is a major Early Access milestone that expands Unreal facing workflows (Nanite assemblies and wind authoring), introduces an Assembly Decorator canopy workflow associated with USD based assembly concepts, and strengthens hybrid scan to procedural tree authoring through scan extension and meshing fixes.
For Houdini Indie users, Natsura’s Indie tier is structured around the same sub USD 100k revenue threshold logic common in the Houdini ecosystem and is paired with node locked licensing and Early Access pricing; however, commercial compliance remains bounded by the strictest applicable terms between Houdini and Natsura.
Sources and Citations
- Natsura official site (Early Access build label, features, and positioning)
Natsura official site - Natsura official changelog and 0.6.0.0 / 0.6.0.3 release notes
Changelog | Natsura 0.6.0.0 | Natsura 0.6.0.3 - Natsura documentation (overview, simulation/deferred evaluation, mapping, effectors, commercial use, installation guidance hub)
Documentation overview | Simulation | Mapping | Effectors | Commercial Use - SideFX documentation and tech demo pages (Project Elderwood, Houdini Engine for Unreal, Houdini 20.5 system requirements, APEX definition)
Project Elderwood | Houdini Engine for Unreal | Houdini 20.5 system requirements | APEX graph basics - CG Channel reporting on Natsura Early Access and version 0.6
Houdini plant-generation toolkit Natsura is now in early access | CG Channel Natsura tag page - Unity SpeedTree documentation (SpeedTree to Unreal import compatibility and Nanite notes)
Importing into Unreal Engine (ST9 Format) - OpenUSD documentation (USD scene assembly concepts and glossary definition of “assembly”)
USD Terms and Concepts — Assembly | Introduction to USD - 80 Level coverage of Project Elderwood’s vegetation / Natsura emphasis
Get Free Houdini Tools From SideFX’s New Project Elderwood
Recommended
- WWE 2K26 Hands-On Preview: Gameplay Changes, New Modes, Roster Updates, and Release Details
- The Sims 4 Will Open an Official Marketplace to Let Content Creators Sell Mods: Release Date, “Moola” Currency, and Maker Program Explained
- Walton Goggins Shares Unexpected Inspiration Behind The Ghoul In Fallout 76 & Fallout Season 2: Behind the Voice, Character, and Gaming Legacy
- MetaHuman Creatures: Crafting Non-Human Characters with Unreal Engine’s MetaHuman Framework
- Devil May Cry Anime: Original Series and Netflix Adaptation Guide
- Human Pro for Blender: Achieving Hyper-Realistic 3D Characters with Advanced Skin Addons, Face Controls, and Hair Assets
- How The View Keeper Speeds Up Animation Rendering in Blender
- DualSense Touchpad Support in UE5: Setup, Input Mapping, and Troubleshooting Guide
- Best Render Farm: Guide to Top Cloud Rendering Solutions for 3D Artists & Game Developers
- Devil May Cry Vergil: Complete Guide to Dante’s Iconic Rival, Powers, and Storyline
