On this page

Houdini Engines for Unreal currently supports outputting the following types of geometries from Houdini Assets:

Geometries are outputted from the nodes that currently have the display flag set. For SOP type assets, the geometry are outputted from the display SOP node within the subnetwork. For Object type assets, the display node of each Object subnetwork are outputted.

By default, the plugin does not use the output nodes, but outputs the geometry of the nodes that have the display flag. If you turn on the use output nodes checkbox in the asset options in the details panel, the plugin uses the HDA’s output nodes. This only uses the display flag node if no output nodes are found.

Static Meshes

Most Houdini assets produces Static Meshes upon cook. The generated Static Meshes Components corresponding to the display nodes attaches to the Houdini Asset Actor, and listed in the Houdini Outputs section in the details panel. They can be baked to separate them from the asset and convert them to standalone Static Meshes available in the content browser.

The Houdini Outputs section also displays the materials assigned to each generated meshes. You can override them by drag and drop or selecting a Material in the drop down list.

Generated meshes can also have colliders and sockets assigned to them. Those can be visualized in the Static Mesh Editor by double LMB on the mesh thumbnail in the Details panel.

For more information on the mesh generation mechanism, see Meshes

Static Mesh creation time has been optimized and now uses Mesh Descriptions. You can use a faster Proxy Mesh generation while editing the HDA. The ProxyMeshes can be automatically refined to Static Mesh, either on a timer, when saving/playing the level, or manually.

Select Enable Proxy Mesh in the project settings to turn them on.

Proxy Meshes provides a faster visual feedback when modifying an HDA, but shouldn’t be considered as an asset’s final output. They only create their main level LOD, won’t have colliders, and can’t be instanced.

You can see an HDA is using proxy meshes as the proxy displays a Houdini Logo sprite.

To separate multiple meshes in your output, you can pack each mesh into a pack primitive before merging thenm in your asset’s output. A single pack primitive always creates a Static Mesh instead of an instancer with one instance.

You can use the unreal_output_name attribute to set the output mesh’s name.

Instancers And Foliage

When using packed primitives or attribute instancers, Houdini assets produces Instanced Static Mesh Components. All the instancers are listed in the Houdini Outputs sections of the details panel and labeled instancer.

Similar to Static Meshes, if the instanced static geometry was produced by the asset, it’s also listed in the Houdini Output Mesh section. It’s labeled as instanced to indicate that the mesh is used by one of the instancer in the HDA’s outputs.

The unreal_output_name attribute can set the output instancer’s name.

For more information, see Instancing.

You can also directly create Foliage instances instead of Instanced Static Mesh Components. Add the unreal_foliage int attribute to your instancer, and set its value to 1.

New foliage is created for the instanced meshes and the instances added to to the current level’s foligage actor.

When you modify the HDA, the plugin only modify/updates the foliage instances it creates and doesnt modify or remove manually placed foliage instances.


If your asset outputs one or multiple Heightfield node, then the resulting geometry creates a Landscape in Unreal.

Generated Landscapes and their materials lists in the Houdini Outputs section in the details panel.

The unreal_landscape_tile_actor_type attribute can be set to 1 to create LandscapeStreamingProxies and a SharedLandscapeActor instead of multiple Landscape Actors.

The unreal_output_name attribute sets the output landscape actor’s name. When using streaming proxies, the proxies' shared landscape actor name can be set using the unreal_landscape_shared_actor_name attribute, and the unreal_output_name attribute will control the proxies' names.

For more information, see Landscapes.

Data Tables

If an HDA output is a Houdini point cloud, it will generate an Unreal DataTable when added to the scene. The DataTable will be populated according to the point cloud’s attributes.

The Unreal struct to use as the basis for the data table is determined by the value of the unreal_data_table_rowstruct attribute of the points. The value of the first point will be taken. The value should be a string representing a valid Unreal object reference. If no structure is specified then one will be generated when cooking based off the table data.

The final baked output name of the table - and structure, if not specifed - created by Baking, can be specified by the unreal_object_name attribute.

The string that will be used as the row name (key) for each row of the data table is determined by the unreal_data_table_rowname attribute of the points. If no such attribute is given, the row names will be defaulted to NewRow_x where x is the index of the row, starting at 0.

The data table will be saved at the string specified by the unreal_object_path attribute. The string at the first point will be taken. This path should be a valid Unreal path (where /Game represents the Content folder). If no path is specified, a name for the data table will be automatically generated and it will be saved in the HoudiniEngine/Temp folder. If the specified data table path already exists, it will be overwritten.

Any other attributes that start with unreal_data_table_ are candidates to use for populating the data table. If the row struct for the data table already exists, these attributes will be matched to the variables of the row struct. Otherwise, variables will be added to the newly created row struct based on these attributes.

Point clouds generated by inputting a data table into Houdini as a geometry input will generate an identical data table when added to Unreal (with the exception of unsupported types that were converted to strings in Houdini, the values of these will be skipped).

If the row struct already exists:

  • If the attribute names following the prefix start with an integer followed by an underscore, that integer will be treated as the index of the variable to match with.

    • The variable at that index must have an identical name to the attribute name with the prefix and index (including the underscore).

      • For example, the attribute unreal_data_table_2_type will be matched with the second variable of the row struct if its name is type. It will not be matched if the name is not type.

  • If no index is present in the attribute name, it will be matched with any variable that shares the same name after the prefix.

    • For example, the attribute unreal_data_table_type will be matched with a variable of the row struct with name type. If no such variable exists, it will not be matched.

  • If no match is found, the attribute will be skipped.

  • The attribute type and the matched variable type must satisfy the following constraints:

    • The variable type must be one of the following:

      • Any numeric type

      • Vectors

      • Rotators

      • Transforms

      • Colors

      • Linear Colors

      • Strings

    • They must have the same number of components (they are both single values, or are tuples of the same size).

      • Rotators have 3 components, transforms have 10 (4 component quarternion, 3 component scale and translation), colors and linear colors have 4.

    • If the attribute type does not exactly match the variable type, one of the following must be true:

      • They are both numeric types (in which case the attribute values will be forcefully converted to the variable type and overflow may occur).

      • The attribute is numeric and the variable is a string type (String, Name, or Text).

  • Transforms are handled as a special case. Attributes will be matched to a variable with a transform type only if there are 3 separate attributes with the standard name, but appended with rotation, scale, and translate. The rotation attribute must be a tuple of size 4, and the others must have size 3. This reflects the way transform variables are converted to Houdini attributes when a data table is used as a geometry input.

If the row struct does not already exist:

  • Transform variables will be created if 3 attributes match the naming pattern described above.

  • Otherwise, a variable will be created for each attribute with the prefix.

    • The best matching Unreal type will be used. For tuples, generic vector types will be used.

    • Tuple sizes cannot exceed 4.

Spline Component

The HDA can output curves as Spline Components in Unreal. To do this, add the unreal_output_curve int attribute to the curve, with its value set to 1.

For more information, see Curve Output.

Geometry Collections

The HDA have the ability to output Geometry Collections, allowing compatibility with Unreal’s Chaos Physics. Geometry collection outputs are generated from packed primitive that have a non-zero unreal_gc_piece primitive attribute. You can achieve this using the Voronoi fracture node, with the unreal_gc_piece attribute.

For more information, see Chaos (Geometry Collections).

Skeletal Mesh

The Houdini Engine for Unreal plugin can output Skeletal Meshes from KineFX. To export a Skeletal mesh back to Unreal properly, you will need to use the KineFXtoUnreal node for your output, with the Rest Geometry and Capture Pose.

For more information, see Skeletal Mesh.

Landscape Splines

For more information, see Landscape Splines.

Templated Geo Output

When the Output Templated Geos asset option is on, the plugin displays an asset’s templated geos. You can display helper geometry used to produce the HDA’s output, without creating an output.

Templated geos outputs use a specific wireframe default material. They will not be baked, and be hidden in-game by default. Only templated meshes are supported, and display geos are never considered templated.


Currently, guide geometries are not supported, but only nodes with the templated flags.

Mesh Build Settings

A number of properties that control the behaviour/creation of the generated Static Meshes (ex. the default collision presets, the use of MikkTSpace, and Distance Field) can be modifed directly on the details panels.

Those properties are found in the Static Mesh Components details or in the Static Mesh Editor. They are listed under Static Mesh Generation in the Houdini Asset’s details, as Static Mesh Generation properties and Static Mesh Build Settings.

They allow overriding the default build settings values set in the plugin settings per Houdini Asset Component. Additionally, they can also be modified procedurally via attributes by using generic property attributes (detail attributes only).

i@unreal_uproperty_UseFullPrecisionUVs = 1;


Getting started


Using Houdini Engine


Houdini Engine for Unreal Engine is a plug-in that allows integration of Houdini technology into Unreal. Session Sync and Node Sync are two features of the Houdini Engine Plugin to interact with a live session of Houdini.

This plug-in brings Houdini’s powerful and flexible procedural workflow into Unreal Engine through Houdini Digital Assets. Artists can interactively adjust asset parameters inside the editor and use Unreal assets as inputs. Houdini’s procedural engine will then “cook” the asset and the results will be available in the editor without the need for baking.

General information:


Currently, the plugins has binaries that have been built for UE5.3, 5.2, 5.1, 5.0, UE4.27 and UE4.26, and is linked with the latest production build of Houdini.

Source code for the plugin is available on this repository for UE5.3, 5.2, 5.1, 5.0, UE4.27, UE4.26.


UE5.1 and UE5.0 use the same source files/branches, the 5.0 sources are also intended to be used with 5.1.

Support and reporting bugs:


The Houdini Engine SessionSync feature allows you to connect to a session of Houdini Engine running inside Houdini with its GUI. It supports all the features of the regular Houdini Engine workflow and additional features specific to Session Sync.

Houdini Engine uses a non-UI version of Houdini while Session Sync lets you see and interact with the Houdini session through Houdini’s user interface. It also synchronizes changes made in either Unreal or Houdini so both programs can make changes and see the same results.


NodeSync is a feature for the Houdini Unreal Engine Plugin that enables sharing assets between Unreal and Houdini Session Sync. It works for Skeletal and static meshes.

You can send and receive data to and from Unreal without a dedicated HDA. It works with Static and Skeletal meshes as well as Actors.

Houdini Niagara

The Houdini-Niagara plugin allows you to exchange point cloud data between Houdini and Unreal’s Niagara system using the HoudiniNiagara Data Interface. You can export Houdini’s attribute data as HoudiniPointCache assets. These can then be imported into Unreal to use the Niagara systems and emitters to create complex effects and particle systems.