The first version of the engine every later release is built on. It runs a graph that spawns a segment of plant, grows it, and then evaluates what should happen at the end of it.

Advances the plant. Takes the geometry that exists so far, adds length to the growing tips, and passes the result to the next node in the graph.

Turns one growing tip into two. Every branch in a Natsura plant originates from a split.

Send growth down one path or another depending on a condition, so a plant can behave differently in different places on itself.

Runs a section of the graph repeatedly, so a small number of nodes can describe a whole tree instead of a single segment.

Write VEX directly into the growth logic, for the cases the other nodes do not cover.

A parameter stopped being one number. It became something that could vary across the plant, driven by anything the simulation knows about the point it is growing from.

In its first form maps were chained one after another in a stack, each one working on the value the one before it produced.

Places geometry onto a grown skeleton. Until this release the simulation produced a skeleton and nothing renderable; decorations are what turn that skeleton into a surface.

Build a surface along the grown strands: the trunk, the limbs and everything continuous.

Place clustered geometry onto the plant: the original way foliage and detail got onto a tree. Superseded by Assembly Decoration and deprecated during the 0.7 line.

The first tool for working with scanned trees: takes a scan and produces a usable rig from it.

Extracts texture from scan data so a scanned surface can be used as material and not only as geometry. It shipped in 0.4 under the name Scan Extract Texture.

The first version of choosing which parts of a plant a decoration applies to, instead of applying it everywhere.

A utility for bringing your own meshes in and decorating with them.

Point attributes on the source point cloud pass straight through into mapping, so what you bring in can drive how the plant grows without any setup in between.

A simple conifer recipe added to the library, alongside a long run of meshing work on Elderwood.

natsura.com opened. Anyone could sign up, download the tools and start on a free Apprentice licence, rather than being let in by hand.

Looping, forking, splitting and switching stopped being separate nodes and moved into Grow as parameters, each of them mappable.

Choose between two mapping chains on a condition, inside the mapping graph rather than around it.

Blend several maps together, for control that changes gradually instead of switching.

Switch and Wrangle gained mapping chains of their own, so attribute-driven logic and gating stopped needing a detour outside the graph.

Extend and graft scanned trunks, with a highpoly workflow attached.

Groups geometry into named modules that the cluster decorator can place. This is the direct predecessor of the assembly system introduced in 0.6.

Defines the points from which plants are grown, including how many there are, where they sit and what attributes they carry into the simulation.

The 0.4 utility became a node: load meshes into the cluster decoration workflow as part of the graph rather than as a step beforehand.

The first attempt at what-you-see-is-what-you-get export to Unreal.

Bake detail from a high poly surface down onto a low poly one, in COPs.

Graft a scanned trunk and grow more of it procedurally, so a scan can be a starting point rather than a fixed asset.

One place for examples, documentation, Discord and the website, rather than hunting for each of them. Replaced by the Natsura Hub in 0.6.

A panel of prepared mapping presets that can be applied to a parameter in one click, instead of building an equivalent map chain by hand.

Cleaner layout, smaller buttons, and view modes: skeleton, preview and decorated, so you can see the stage of the tree you are actually working on.

Panels moved to JSON-backed definitions with preferences that persist, instead of being built in code one at a time.

Overused dive targets were removed, which allowed Houdini to resume instancing nodes natively. Long-standing split and ID assignment bugs in the core graph were fixed at the same time.

Wind Init, Wind Config and Unreal Wind, alongside multi-trunk rig support and much sturdier cluster rigging.

Carve and maximum-joint-count reduction, chainable, with reskinning going from thirty seconds to two tenths of one.

Decorators stopped each interpolating attributes their own way. One contract says what a decorator receives and what it returns, and rig attributes transfer back in a single pass.

A spiral parameter that can override inherited phyllotaxy, the effector stack built in, instant colour preview, and map construction deferred into Grow so graphs compile faster. Grow 1.0, 1.1 and 1.2 kept working; scenes retype to 2.0 on load during the 0.7 line.

Bolt-on simulation modifiers. Stack them on a Grow, weight each one by a value or a map, and shape a tree without writing VEX. The base effector is there if you do want to write VEX.

The first four ready-made ones: make a tree aware of its own shape, grow towards a direction, perturb growth with noise, and pull or push branches within a sphere you place in the viewport.

Import a mesh library and auto-rig it, so a folder of twigs and branches becomes something the simulation can place.

Place library modules onto a tree, picking them by trait and transforming instance hierarchies with rigid rotations. Fully mappable.

Tag modules by trait, so the decorator can be told what kind of thing it needs rather than which file.

Simplify a rig hierarchy as a step you can chain, with multi-stem support.

Wind Init, Wind Config, Wind Previs and Unreal Wind: assign wind classes along the tree and export them as DynamicWindSkeletalData for UE5.

Export to Unreal as a Nanite assembly, skeletal or static, with materials and wind data alongside. It has had a lot of production use since.

A LOP wrapper that builds a Nanite assembly inside a USD workflow, rather than only at the SOP level.

The nodes the wizard drives, usable directly: bring source imagery in, trace and remesh it, lay tiles out, build the atlas mesh, emboss detail, and assign the material.

Guided atlas processing, and the main place you set an atlas up for the decorators to use.

A leaf decoration node was added to the build but left unexposed and incomplete. It is the basis of the leaf and foliage work in 0.9.

Three more map types: a fixed value, a random one, and one that reads a geometry attribute.

VEX taken out of the core path, prims deferred to the nodes that need them, and specialised map variants instead of one general one.

Everything moved into one natsura package with the HDAs holding thin wrappers, so logic changes without republishing an asset.

The output of one Simulate can be connected directly to the input of another, so growth can be carried out in more than one pass.

Extend complex scans and sculpts procedurally across several trunks rather than one.

A place inside the Simulate to chain geometry fixes after growth: recompute normals, drop construction attributes, adjust topology, without leaving the graph and losing dependencies.

Graph metadata updates were parallelised. On a large scene the update time fell from about sixteen seconds to under a tenth of a second.

The single welcome panel became a tabbed hub with independent modules: home, projects, examples, settings and feedback, each dockable on its own.

A panel that follows what you are working on and tells you about it, with pinning, images and your own notes.

Toolbar and attributes in one docked layout, rather than two panels you arrange yourself every time you open Houdini.

Recent projects, examples and documentation on open, so getting back to what you were doing is one click rather than a file browser.

Node creation regrouped so the tab menu holds the nodes you make by hand and hides the ones that only ever appear inside something else.

Every Natsura node was given a distinct icon, so nodes can be identified by shape and colour in a large graph rather than by reading each label.

A desktop preference that lays Houdini out for this kind of work, with the panels where they need to be, so you are not rebuilding the layout on every machine you sit at.

A hundred and seventy five nodes organised into a real library, fewer of them in the tab menu, better submenus, and written help for the ones you reach for most.

Natsura runs on 20.5 and 21.0, with a compatibility layer over the Qt change underneath.

Anonymous usage data, off by default, with consent asked once and a local fallback that never leaves your machine.

Simulate a set of branches or a whole tree, decompose it into modules, and decorate another simulate with them. Build a canopy by decorating one simulated tree with another.

Packs a rigged Simulate down into a single mesh stream that the decorators can place. It is the internal step that makes Rig to Assembly work.

The rig operations opened up as nodes you can use directly: merge two rigs across a join, rename, delete and collapse joints, rebind skin weights, and find the joints nothing uses. Rig to Assembly is built out of them, and so is anything you build yourself.

Import a library, auto-rig it using nearpoint lookup with cycle removal, tag its modules by trait, and place them on a tree. Tested against libraries substantially larger than the sizes we designed for.

Pull repeated geometry out into instanced modules, fixing up the rig and the skin as it goes, with Order Branches alongside it for traversal.

Bounds, VDB, medial axis or particles from an assembly, with optional leaf removal.

Split a large library into chunks so it can be processed in parallel.

Displays the motion, pivots, rig hierarchy and debug colours of an assembly directly, so a library can be inspected without inferring its state from the decorated output.

Assembly Edit and Pivot Edit, for the per-element corrections a library always needs.

Passes the output of one Simulate into the next, so a tree can be grown in distinct stages rather than in a single pass. The parameter contract is not final and is expected to change.

Grow was reduced to a socket that executes code generated entirely by the mapping graph. It spawns a segment with basic properties, and mapping determines everything else: orientation, branching, and how growth responds to its environment. This broke compatibility with 0.6 scenes deliberately, on the basis that it was cheaper to do while the user base was small.

One form for a mappable parameter across the whole toolkit: the value, and the map that drives it. The map drives the parameter directly instead of through an expression link.

Every map, decorator and effector slot gets a picker, grouped by what is already on this Grow, what is on other Grows, and what is orphaned, with unlink, duplicate, jump-to and replace available on each slot. It removed roughly eleven hundred lines of Python and a comparable amount of dialog script.

Orbit, align and level up-vector modes, so you can control the frame a branch grows in rather than only the direction it heads.

Read vectors from the parent, the grandparent and further up the lineage, so a branch can respond to where it came from. The direction effector landed alongside it, and the same effector can go on one node several times, each with its own response.

Traits on Assembly Decoration became a fixed set of slots with a picker, drawing from the trait node and from skeleton attributes, with an edit-on-geometry action per row. The old list rebuilt itself on every cook and took Houdini down past about ten traits.

Grow, fuse, skin, export, USD, wired through as one path, with a wind sidecar written alongside the USD.

Cook triggers taken out of every piece of code that runs outside a cook: interface, menus and the graph layer. Nodes declare what they are, and readers read the declaration. Ghost cooks followed in 0.6.2.0, where the Python interfering with live cooks was removed outright.

Toolbar plus guide, attributes and spans in one docked layout, with any tab pulled off and floated where you want it.

Python panels organised into folders, with the developer panels moved into a project of their own so they stop appearing in your menus.

The tips panel became Guide: markdown, searchable across both names and content, with previous and next navigation and more than one library.

The toolbar shows grow, switch or split depending on what you have selected, with the developer tools moved out of the way and a main menu holding licence, updates, projects, examples and docs.

Placing a Grow arrives with its trunk preview, decorator slot and follow rows already populated, and does not cook a second time to do it.

Hotkeys are loaded from a file through Houdini’s own hotkey system, so they appear in the hotkey editor and can be reassigned like any other Houdini binding.

Stand-in geometry on the assembly decorator so you can see where modules are going before the real thing cooks. Cycle trunk, monopodial and sympodial stand-ins from the toolbar, and move and scale them in the viewport.

Gaps in scan coverage no longer come through as holes in the mesh or as missing attributes downstream of it.

Natsura runs on Houdini 22. Before this it did not start there at all: no desktop, no logging, no background service, and no error saying why.

The bake node gained supersampling and MikkT tangent space, which is what a game engine expects to receive.

An example scene in the examples browser that works through the entire Rig to Assembly path, from library import to decorated canopy. It is one worked example rather than a library; the library itself is a 1.0 deliverable.

Bindings survive on instanced prototypes, where previously only the trunk arrived bound and every prototype came through empty. Cluster materials that cannot auto-fill on export are still to come.

Draw a tree skeleton by hand and use it either as the base of your tree or as a module to be placed.

Import a skeleton from SpeedTree and use it as either the base skeleton or a cluster.

This set of features will provide a variety of shaping options:

• Resampling the given splines as a post-process.
• Mappable parameters for more control over the mesh shape. For example, linking the width with the height of the plant.
• Other controls we are looking to add include spiraling, smoothing, UV modifications, and endcaps.

Effectors have been a powerful addition to the Grow. We are also adding them to Decorations. Effectors will be included on the Surface Decoration and Assembly Decoration.

Instancing is an important part of generating a nice surface. Here are a couple of examples of assets that you might want to scatter on your surface:

• Bark Peel
• Knots
• Patches of Moss
• Small Dead Branches
• Decals for damage/scars

A sweep that lets you shape the trunk based on the branches it actually carries, so the cross-section swells and flattens the way a real trunk does around what it is feeding.

Blend between materials across the plant, driven by age, depth, light exposure or any custom attribute you come up with.

Blend scanned material into procedural material in the shader rather than in the geometry, so the join between a scanned trunk and everything grown on top of it stops being a visible line.

Production-quality trees and parts libraries, built with partners, along with the free learning content that keeps coming.

One wind sidecar per tree instead of a single merged file, and USD written as organized layers: shared prototypes in their own library, one assembly layer per tree, and a small root that stitches them together. Prototypes are referenced rather than duplicated, so a forest of the same part costs one copy.

Substeps with mappable segments, interpolation and enhancement, plus their own Effector stack. This feature is off by default; to enable it, turn on 'Enable Post-process'.

The common functions you would expect from a shader graph, available inside the mapping framework as nodes rather than VEX: maths, ramps, curves, noise and blending.

A selection node in the core set, so choosing what a downstream operation acts on is a first-class step rather than something you improvise.

A licence tier for schools and students, so Natsura can be taught.

One licence covering everyone at a named studio location, instead of a seat count that has to be allocated and tracked. Aimed at studios where counting seats costs more administration than the seats are worth.

Every release from the first growth engine through to 1.0, with what shipped in each one, what is being built now, and what is coming without a version attached to it. Published so that progress can be checked against the record rather than taken on trust.

A page describing what Natsura is, who builds it, and how it is made.

Select 'Save to Disk' and the tree will appear in your content browser. The files still go via the disk, but only the 'Import this' instruction travels to the editor.

Capture a Natsura network by selecting a simulate and all connected nodes and bake this down into a small, shareable graph. This makes it easier to share with other users and run in game engines like Unreal Engine, without the massive downsides of a large node graph.

Bake data from the skeleton down onto the mesh as vertex color, so that the standard Unreal and Megascans material functions work without a manual step in the middle.

Support for LOD Generation:

• LOD Chain produced as a normal part of generation/exporting
• Baking cards into the LODs (including hLOD workflows)

A simplified static mesh for collision and proxy use, out of the same export.

Proper UDIM support and control over how islands are arranged across tiles.

Proper blending options for where the trunk meets the roots. Root flare and buttressing that transitions smoothly into the trunk, instead of the roots meeting the trunk at a visible seam.

Get more out of an atlas by deliberately editing and packing UV islands. Choose which region of the atlas each part draws from, so several trunk variants can share one texture file instead of each needing its own.

A mode you enter to work on a tree by hand: pose it, prune it and add branches where the simulation didn't put any. Local overrides that survive without regrowing the tree to get the rest back.

Single-quad stand-ins that hold up at distance, so a forest costs what a forest should cost.

Seats check out and return, so you buy for your peak concurrent usage rather than for your headcount.

Bark that lifts and detaches from the trunk and the major limbs as geometry, rather than being represented as a flat texture on a cylinder. It is still being scoped and is the least defined item in this release.

Bake per-branch pivot position, rotation axis and hierarchy depth into UV channels and vertex colours, in the layout Unreal’s pivot painter workflow expects, so wind is evaluated in the vertex shader rather than on a skeleton. This is the low-cost wind path, and the one large numbers of trees can use.