For those who don’t now the tool: Dynamic Flow is a Geometry Nodes based water add-on for Blender by Blender Procedural, aimed at fast environment lookdev rather than fluid accuracy. Rivers first, splashes later.

Water without waiting

Dynamic Flow is a real time water simulation add-on for Blender developed by Blender Procedural and distributed via the Superhive marketplace. The tool is designed as a lightweight alternative to traditional fluid simulation workflows, focusing on interactive feedback rather than physically accurate behaviour.

The add-on generates flowing water surfaces that respond to terrain in real time. It does not use Blender’s Mantaflow solver or particle based simulation. Instead, it relies on Geometry Nodes to drive surface motion procedurally, allowing timelines to be scrubbed and parameters adjusted without baking caches.

The stated goal is rapid iteration for environment scenes such as rivers, coastlines, lakes, and islands, where visual plausibility is sufficient and turnaround speed matters.

Geometry Nodes, not physics

Dynamic Flow is built entirely on Blender’s Geometry Nodes system. Flow direction and velocity are derived from the underlying terrain geometry, with the water surface adapting to slopes, banks, and obstacles.

Because the system is procedural, changes to terrain or scene layout update immediately. There is no simulation cache to manage and no rebaking when assets move. This makes the add-on suitable for look development, layout, and concept work where scene elements are still in flux. The developer states that a lightweight grid is used internally to evaluate surface flow.

Foam, collisions, and interaction

Dynamic Flow includes automatic shoreline foam generation driven by proximity to terrain and scene objects. Foam behaviour is controlled through exposed parameters inside the Geometry Nodes setup, allowing adjustments to width, intensity, and motion. The add-on supports collision with objects and collections. Objects intersecting the water surface can influence flow patterns and create visible disturbances. The precision of these interactions is not described in detail, and there is no indication that secondary effects such as splashes, spray, or droplets are simulated. The system is limited to surface motion and does not model volumetric water behaviour.

Rendering and compatibility

Dynamic Flow works with both Eevee and Cycles. The water surface is standard Blender geometry with animated attributes and uses regular materials and shaders. No custom rendering features are required. The add-on requires Blender 5.0 or later and installs as a standard Blender add-on through the Preferences panel.

Positioning and limitations

Dynamic Flow is not intended to replace full fluid simulation tools. It does not simulate turbulence, buoyancy, pressure driven motion, or complex fluid interactions. It is positioned as an artist controlled, predictable system for surface water movement.

Pricing and availability

Dynamic Flow is available via the Superhive marketplace for 6 Dollars. No subscription is required. As with any new production tool, artists should test Dynamic Flow carefully before deploying it in active pipelines or client projects, particularly where determinism and render consistency are required. This remains advisable even if early results appear stable and behave exaclty as expected.

The post Dynamic Flow makes water move without waiting first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The new CardCutter add-on for Blender converts texture masks into usable 3D geometry for Nanite-based projects in Unreal Engine 5. Created by developer Philipp Russo, the tool simplifies building game-ready foliage and decals by generating optimised meshes directly from source textures.

CardCutter operates as a geometry generation tool that converts 2D texture data, either alpha-masked colour images or greyscale masks, into fully triangulated 3D meshes suitable for Nanite rendering. The add-on functions within Blender’s Python API and supports Blender 4.0 or higher. According to the developer, the geometry output is designed to conform to Nanite’s mesh constraints, favouring dense, evenly distributed triangles over traditional quad-based topologies.

Each processed mask is interpreted as a binary image, with the alpha threshold defining the polygon contour. The tool applies an internal vectorisation step to trace the boundary of the visible region, followed by a polygon simplification algorithm to remove redundant vertices. It then uses a relaxation solver to re-distribute triangle density uniformly across the surface, creating stable topology for Nanite’s internal micro-polygon clustering.

Automatic atlas splitting

When the user provides a texture atlas (for example, a leaf sheet), CardCutter automatically detects discrete masked regions using connected-component labelling. Each detected region becomes a separate mesh object in Blender’s scene graph. This removes the need for manual cutting or polygon mask painting, which is typically required in foliage production. Each region retains its local UV coordinates, preserving the original texture mapping from the atlas. The output meshes can be exported directly as FBX or glTF, maintaining UV alignment and pivot orientation suitable for Unreal Engine import.

Geometry presets for performance tiers

CardCutter offers several density presets: Low, Medium, and High, which define the target number of triangles per pixel area. The lower settings generate lightweight meshes for background vegetation, while the higher settings produce Nanite-ready geometry that benefits from Unreal’s automatic cluster streaming.

The generated meshes are particularly intended for organic and irregular silhouettes like leaves, vines, ivy, ferns, but the developer also notes suitable use cases in flat debris, stickers, posters, and paper scraps, where alpha planes normally create overdraw problems.

In Nanite rendering, alpha cutouts are computationally expensive since masked fragments are still rasterised. By converting them into actual geometry, CardCutter removes the transparency pass entirely, allowing the GPU to perform visibility culling at the triangle level. This is beneficial for scenes with dense foliage or decal overlays.

Export workflow and integration

Meshes generated by CardCutter can be exported directly from Blender using Unreal’s standard FBX pipeline. The add-on does not alter material data; instead, it preserves UV maps for external shading setups. Unreal users can apply the same texture as an opacity mask or base colour without modification.

CardCutter also supports consistent vertex orientation to avoid flipped normals during export. According to the developer, all geometry is manifold and suitable for Nanite import without further cleanup, though it may require triangulation if the user modifies topology post-generation.

Pricing and licensing

CardCutter is distributed via Gumroad. The Individual/Freelance licence costs €12 and includes full functionality, updates, and one user seat. The Studio/Enterprise licence, priced at €50, allows unlimited installations within one facility and provides priority support for pipeline integration. Both include lifetime updates and are maintained by Philipp Russo under The Triangle Forge label.

Technical limitations and notes

At the time of publication, CardCutter is compatible exclusively with Blender 4.0 or newer. The add-on does not currently support real-time texture-to-mesh previews or batch automation through the command line.

Users should test export consistency when integrating the tool into complex Unreal foliage systems that depend on hierarchical instancing or runtime material overrides. The add-on outputs static geometry only, without procedural modifiers or animation rigs.

The post CardCutter turns texture into Nanite meshes first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Kiri Engine is a photogrammetry app that turns real-world captures into 3D models, targeting artists in VFX, games, and visualisation. Its ecosystem now extends into Blender with a set of free add-ons designed for environment work. Mesh Wrap is the latest entry in this toolkit, joining other utility plug-ins for scan preparation and scene layout.

A Free Add-on for Wrapping 3D Terrain Scans

Kiri Engine has released Mesh Wrap, a free add-on for Blender designed to simplify how artists integrate terrain scans into base meshes. Unlike Blender’s default shrinkwrap modifier, Mesh Wrap is built specifically for photogrammetry-based environments. It projects surface-scanned meshes, such as rock faces or terrain tiles, onto clean base geometry while preserving scan detail and alignment.

The add-on supports Blender 4.5 and newer and is available for free download via a Kiri Engine account. It is intended for terrain and surface data, not for closed or solid meshes.

Two Workflows: Planar and Scatter

Mesh Wrap provides two distinct workflows. Planar Wrap handles the projection of a single mesh onto a base surface. Scatter Wrap distributes and wraps multiple scan meshes across a terrain, enabling fast environment coverage without manual placement. Both tools rely on a ray-casting projection system, with direction controls for world or object axes. A visible gizmo helps users verify projection direction and adjust wrapping behaviour. Misaligned objects trigger a “surface not found” warning, an indicator of an incorrect projection axis or displaced origin.

Mesh Preparation Tools

Before wrapping, the add-on offers mesh-preparation utilities to correct rotation, fix skewed origins, and align object pivots. The Auto Rotate feature attempts planar alignment, while origin controls allow setting to the lowest, highest, or median point of the mesh. These adjustments directly influence how accurately the scan conforms to the target surface.

Precision Controls and Cleanup

Mesh Wrap introduces displacement-strength adjustments, overlap handling, and boundary-snap features. These tools refine how the wrapped scan adheres to the base terrain and resolve clipping or intersecting faces. The Overlap Cleanup menu includes modes to remove or smooth intersecting faces and distance-based masking to recover deleted geometry. The Snap Boundary to Surface option ensures that edge vertices align seamlessly with the target mesh, creating clean joins between tiles or blended terrain segments.

Scatter Workflows and Performance

For larger environments, the Scatter Wrap workflow distributes multiple terrain scans across a defined surface. Users can select a single mesh or a collection and enable automatic Decimate modifiers to lower polygon counts. Scatter methods include Grid (planar distribution) and Normal-Aligned (surface-conforming), both offering controls for density, scale, and scatter seed randomisation.

Performance optimisation is a recurring theme. Kiri advises scattering only within the camera’s field of view and applying modifiers once layouts are final. Since all scattered instances are “realised” geometry, high-poly scenes can quickly affect viewport responsiveness. Applying and cleaning geometry after wrapping is recommended.

Practical Notes

The add-on’s defaults are tuned for planar, Z-axis-oriented wrapping. Artists can switch projection axes for vertical surfaces, such as cliffs or walls. Decimation ratios are adjustable per object, and modifiers can be baked for performance. A small “tick” icon applies modifiers directly from the panel.

Availability and Requirements

Mesh Wrap is free for all Blender users with a Kiri Engine account. It installs through Blender’s standard add-on interface. Documentation and video guides are available on Kiri Engine’s YouTube channel. As with any new production tool, artists should evaluate stability and compatibility before deploying it in critical pipelines.

The post Terrain Wrapping Made Easy: Kiri Engine’s Free Blender Add-on first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Houdini can read in external data in various ways. The most comprehensive is certainly a self-written Python parser, but that is not necessary here, because Houdini comes with the Table Import Node as standard. This makes it possible to import tables in CSV format. If you look under the bonnet of the table import node, you will of course find a Python script there anyway. This is one of the reasons why I like Houdini so much: almost everything is open and can be studied or adapted to your own needs.

Import

The CSV format contains values that are separated by commas (CSV = comma separated values). These can be words or numbers. Most spreadsheet programmes can save or export tables as CSV. I use Google Sheets here, and it works great: the table import node initially only creates points, which then contain these values in attributes. I use the attributes:

@word, @pscale, @font.

@word gets the values from column A, which is the first column. In Houdini, counting usually starts with zero, hence Column Number 0. The attribute type is a string.

@pscale is a special attribute specified by Houdini. @pscale stands for Point Scale, i.e. the size of a point. This is Column Number 1, and the type in this case is a float, i.e. a floating point number. I could therefore also have entered 1.5 or 2.3 as values in the table.

i have defined @font as type integer, i.e. as an integer. As I want to use three different fonts, I have entered 0, 1 or 2 as values in the table.

The Table Import can also translate (e.g. Lat/Long to Sphere), but the Translator is not needed here.

The second node is Enumerate. This creates an @index attribute with which the points are counted in order to be able to assign them later. The group type must be changed from “Primitives” to “Points”. The next two nodes are not absolutely necessary, but as I wanted to create other sizes and these should be somewhat random, I first used Attribute Expression to convert the @pscale values 1,2,3 into 1.5, 2 and 2.5. To do this, “Custom” must be entered in the node attribute and “pscale” as the name and “Float” for the type. I use the VEXpression for this: “1 self * .5”.
And of course, I could have entered these values in the table straight away, but I didn’t. The zero named here as “OUT_points_with_attributes” is not necessary for the function, but is part of good style.

Loop it!

Now the first loop comes into play. This is a For Each Point loop. It contains 3 font nodes, one for each font. Firstly, I created a font node for this and added the spare input required later. To do this, click on the cogwheel and select “Add Spare Input”.

This font node was then referenced twice using drag-and-drop with the Shift, Ctrl and Alt keys held down. For the copies, I then held down the Shift and Ctrl keys and clicked on Font to remove the reference link. Alternatively, this can also be done with the right mouse button menu and “Delete Channels”.

Fonts

The most important node when it comes to text is of course the font node. It can generate both polygons and Bezier curves or both at the same time. I use polygons here. I have set the level of detail to 4 so that the tessellation is nice and fine.

Working with Bezier curves is also great, but unfortunately not useful here, as the UV layout node used later cannot process them. Now it gets a little more magical or technical. In the “Spare Input0” parameter, the “../foreach_begin1” node is referenced by drag-and-drop or, if you want and like typing, you can do that too. The text to be created is normally simply entered in the text field, but we want to read it in from the CSV table, which has already been converted into points. Backticks can be used here to execute code.

The command required here is “points”, whereby it is not about several points, but about string values from points. The “s” at the end stands for “string”. The first spare input is addressed with “-1”. The zero after it is the first point, here it is always just one point anyway, as we are looping over the points. Then “word”, because we want to read the @word attribute. Brackets around it and a backtick and that’s it.

As an aside and for the sake of completeness, “Add Text Attributes” should also be mentioned here. It is not needed here, but is very cool for other text gimmicks. If the box is ticked, the attributes @textindex, which indicates the number of letters in the word, and @textsymbol, which indicates which letter it is, are created for each letter or primitive. However, this is an ASCII value, i.e. a number. “f”, for example, is then 102.

The three font nodes are then connected with a switch that reads the @font attribute. I have also created a spare input for this. This time it is the “point” command and not “points”, as only a number is read out here and not a string. So “point(-1,0, “font”,0)”. In this case, “-1” is again the spare input, “0” is the first point, “font” is the attribute and the last “0” is a necessary argument, which doesn’t really make sense here. However, if we wanted to read out a vector, “0” would be X, “1” would be Y and “2” would be Z. This is also only mentioned here for the sake of completeness.

Copy to points

Okay, Houdini! Now we come to the copy to points node. First of all, some information in passing: This node will change a lot in H18 and make actions like this easier. No matter. Pack and Instance is not needed here. Transform Using Point Orientation is also not required here, but can also be on. Copy Points Attributes is used because we still need @index. So enter “index” under Set/To Primitive. Delete everything else.

Now you should be able to see a bunch of fonts on top of each other. Before, there was nothing to see in the viewport except a dot in the centre, at most. Tip: In the “foreach_end1” node you can set to “Single Pass” for debugging, then only one iteration of the loop is executed. And always keep an eye on the geometry spreadsheet, where you can see the values of attributes.
Now we come to the UV layout node, which is used here to distribute the words in a shape. In the picture, I have coloured the shape green. I have left space for the two logos of DP and DIGITAL PRODUCTION. Connecting this shape to the second input of the UV layout node should not be too complex. Of course, the words with the @index attribute go into the first one.

UVs

The UV layout node normally uses the @island attribute to delimit the UV parts from each other and the @uv attribute for the positions of the vertices on the UV map. Since there are no UV coordinates here at all, we replace “uv” twice with “P”.

in Houdini, @P is the position of the vertices. For Axis Alignment we select “none” and for Island Rotation Step we set “No Rotations”. If you want to create a Word Cloud with rotated words, they should either be rotated beforehand or you should select 90°, for example, so that no words are upside down.

Padding is the distance between the shapes to be distributed, in this case words, and Scale should be set to “Largest Packable”. The “Advan…” settings are also interesting. This must stand for Advanced. There are iterations here. Here the node randomly tries different layouts and then uses the layout with the best space utilisation. However, each iteration takes time, and 4 is sufficient for this purpose. Different layout versions can be generated with “Random Seed”.
That’s it as far as the layout is concerned, but now we want it in 3D. To switch to a so-called Packed Workflow, we need an @name attribute with a string, i.e. text content. At the moment, we only have an @index attribute, and these are numbers. We do this with an attribute wrangle node.

Select “Primitives” under Run Over and enter the following VEXpression: “s@name = sprintf(“%d”, i@index);”. This creates an @name attribute, which then contains the number as a string. For more details on this VEX function, please refer to the Houdini documentation, which would go beyond the scope of this article.

Now the whole thing is packed, i.e. each word is now represented by a point. This is practical because it is now easier to select the words, for example, in order to make manual corrections to the positions. Simply use an Edit Node to do this.

Before or after the edit node, I used an attribute copy node to write the attributes from the beginning @font, @pscale, @word back to the points, which now contain the packed geometry. Again, @index is used to assign the source and target points (Attribute to Match). Only @pscale is actually needed, but never mind. If you want, you could customise this even more variably and select words more easily or, for example, extrude them differently depending on the font.
Now rotate another loop and extrude the words. To do this, create a For-Each Primtive Loop and place an Unpack followed by a Pack Node. A polyextrude is placed in between.

Then either drag and drop the “foreach_begin3” into the spare input created or enter “../foreach_begin3”. I have set the parameter “distance_multiplier” to 0.025.
The magic is in the Distance parameter; enter “point(-1,0, “pscale”,0)*ch(“distance_multiplier”)” enter. Now @pscale is used to control the thickness of the letters. Do not forget to tick the “Output Back” box, otherwise the letter will be open at the back.

Finally, a file node to save the geometry. It can then be integrated into the rendering scene. The outline plate behind the words was also created procedurally, unfortunately no longer part of this article. But this much can be revealed: I converted a geo into a volume, more precisely into an SDF/VDB. Then enlarged it as an SDF or made it thicker. Then “vdbsmooth” and converted it into a mesh. An Intersection Aanalysis followed by Polypath, then Resample, then Fit and Resample again, and the outline is ready.

Outlook

I would also have liked to have written something about splines, i.e. curve modelling and editing. This works very well in Houdini, even if it takes some getting used to. I would also have liked to discuss rounded edges. But I ran out of pages – we’ll just do that in one of the next issues.

The post Blergh! Word Art! In Houdini? first appeared on DIGITAL PRODUCTION and was written by Olaf Finkbeiner.