Bend It targets a familiar pain: you want bend, taper, twist, or shear, but you do not want to build a whole 3D scene just to get there. The macro applies those deformation modes to a 2D source, using a mesh-based approach and controls that aim to feel closer to a 3D deformer than a plain 2D warp.

The macro includes bend, taper, twist, and shear modes, and it can process horizontal and vertical deformation in sequence with a user-defined order. It also adds transform controls for both the mesh and the texture, so you can animate deformation and placement without rebuilding the setup.

If you live in Compositing and you keep re-inventing the same rig every month, this sits right in the spot where you normally lose an afternoon.

Mesh density you can animate, not babysit

Bend It exposes mesh subdivision controls that scale with the deformation amount. A minimum subdivision level applies when deformation sits at zero, and the macro ramps toward a maximum as horizontal or vertical deformation approaches its extremes.

The macro also offers a render mode that can show mesh, texture, or both, which helps when you need to diagnose jagged edges or wobble in the texture mapping. The mesh subdivision note comes with a practical warning: shear does not benefit much from higher polygon counts unless you specifically want the wireframe look. About one third into setup tinkering, you will probably start calling this a wrokflow improvement. That is allowed. Just do not say it near a supervisor.

Factors, edges, and a sneaky tiling trick

Bend It includes factor controls that can scale back transformations made in the main controls. Sliding factors down can effectively reset deformation and transforms, which makes for quick animation beats and quick sanity checks. The macro also separates factor locking across mesh and texture if you want independent control.

There is also a practical trick for partial tiling: reduce texture scale and increase mesh scale by the same amount to get an area with repeated texture detail. Edge controls become relevant in that case, because they only make sense when texture scale drops below 1.0. This macro leans into the idea that you should be able to steer both the deformation and the sampling behavior without building a separate rig. If you like compact rigs, you will still need self-control. The settings count is not small.

Lighting and material options, if you insist

Bend It can run with optional direct and ambient lighting, plus basic bump and reflection support. It also includes controls to drive bump, reflection, and specular behavior using a single map, with toggles for inverting individual channels. When you only render the mesh, a diffuse color can be used to set mesh color without enabling lighting.

There is also a direct light widget meant to help visualize light direction. The macro recommends turning it off before final rendering, unless you enjoy explaining UI overlays in finals. The macro uses an orthographic camera. That keeps the tool aligned with 2D results, but it also means depth of field does not function in this setup.

Requirements, quirks, and the stuff that bites at 2 am

Bend It requires Fusion 19.1+, because it uses the Switch node. The Switch tool in DaVinci Resolve 19.1 supports multiple inputs, with a slider that adds up to nine and a Number of Inputs field that can be typed higher.

The macro notes a few known issues and workarounds. The viewer may occasionally show a black frame, but playback or touching settings tends to refresh it, and renders are not described as affected. Motion blur reportedly refused to work on frame zero in one setup, tied to how camera scale checks source ratio on that first frame. A workaround used a Time Speed node with a negative one-frame delay, and a later version changes that approach.

There is also a hard warning: adding an expression to the AA Filter Type setting on a Renderer3D node caused Fusion to crash and could corrupt the comp file. If you take one lesson from this: do not stress-test your production file with experimental expressions five minutes before delivery.

https://www.steakunderwater.com/wesuckless/viewtopic.php?p=57053

The post Fridays for Fusion: Bend It first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

What Flow Looper actually does

Flow Looper aims at a very specific pain point: making a still image feel alive without turning it into a full animation project. The core idea centers on drawing a corridor with two splines, then pushing pixels down that corridor and looping the motion with a cross-fade.

That puts it in the same general family as classic flow mapping workflows, but packaged as a Fuse that lives where a lot of Resolve artists already spend their time: the Fusion page. If you ever built a “moving texture down a path” rig in node compositing, you already know the appeal. The win is not that the math exists. The win is that you can hand this to an editor who occasionally opens Fusion, and they might still come back with something usable.

Corridor animation, not a full 2D puppet show

Flow Looper focuses on motion constrained to a defined corridor. You draw the corridor, then the tool handles the continuous movement and looping behavior. The creator describes using several Flow Loopers on a single image to animate different regions. Oh, well.

That corridor constraint matters. It gives you a clear place to cheat motion into a still without needing to invent a full deformation rig. Think steam, fire, drifting energy, or anything that reads as “directional movement” once it repeats cleanly.

The approach also means you can stack multiple instances for layered motion: one corridor for flames, another for smoke, another for embers, each with its own behavior. That layering idea shows up directly in the shared example of a dragon breathing fire, animated by combining multiple instances. At some point, someone will try to animate a face with it. That is fine. That is also how plug-in comment sections become performance art.

Controls: speed shaping, noise, and edges

The feature set goes beyond “make pixels move” and into “make pixels move in a way that does not look like a conveyor belt.” Flow Looper includes start and end flow length controls intended to create acceleration-like behavior, or to keep one end static while the other moves. In practice, that kind of control usually helps sell motion that ramps in, ramps out, or stays anchored so the loop does not scream “tile.”

There is also a turbulence control that varies direction per pixel using noise so the motion does not stay perfectly linear along the corridor.That is the difference between “demo” and “could pass in a shot.” Even small directional variation can break the mechanical look. Edge fading controls aim to blend the flowing region on top of the image more naturally.

The Gumroad listing for Flow Looper shows a price of $12, Which is well worth it, if ou ever had to do something like this, and didn’t have the time for it.

Where this sits in real world Resolve workflows

If you live in editorial and only step into Fusion when the timeline needs “a little something,” Flow Looper looks designed to be that little something, but repeatable and controllable. If you live in Fusion, the tool still has a place, because corridor-constrained motion loops show up constantly in motion graphics and stylized comps. It is also a relatively friendly concept to hand off. “Here is the corridor, here is the direction, here is the loop” is a better brief than “make this still feel alive.”

Tangenten Puppet Pin brings mesh warping to Resolve

For artists browsing the Tangenten tag archive, this is the second clear theme: Fuse tools that try to make Fusion friendlier without pretending nodes do not exist. Finally, check performance. Fusion can handle a lot, but it can also punish you for stacking clever tools on top of each other. Multiply a heavy operation by six instances and your interactive session becomes a slideshow. New tools and innovations should be tested before use in production, ideally on a clone of the job, not the only copy of the job.

https://tangenten.gumroad.com/l/FlowLooper

The post Fridays for Fusion: Flow Looper animates stills in Resolve first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

For those who don’t know the tool: OctaneRender is a GPU renderer with DCC plugins like Blender, Cinema 4D, and Houdini. It ships via Studio+ and has a macOS stepsibling called Octane X.

Virtual textures, now allowed on the farm

OTOY shipped OctaneRender 2026.3 with a headline change that matters to anyone who has ever watched a heavy lookdev scene bully a GPU: network rendering now supports virtual textures. Virtual textures arrived earlier in the 2026 cycle, and 2026.3 extends that system beyond the local box so you can run the same approach in distributed jobs instead of treating it like a workstation-only party trick.

If your pipeline leans on huge texture sets, this is the kind of change that can reduce the amount of manual babysitting around what fits where. It does not magically fix bad asset hygiene, but it can remove one common excuse for why a scene behaves differently on an artist’s machine versus a render node. The release notes also call out a reduction in time to first sample in render nodes when scenes contain large image counts, which pairs naturally with the idea of texture-heavy shots that take too long just to begin doing anything visible.

One practical footnote: the release notes explicitly say that virtual textures are not supported for texture displacement. That line sits inside a crash fix description, but the constraint itself matters. If your assets rely on displacement driven by high-resolution maps, you still need to plan for the old reality there, even while the rest of the texture stack gets more flexible.

Trace sets, shadow catchers, and other production glue

2026.3 continues to sand down workflow edges around features introduced earlier in the 2026 line. Trace set visibility rules can now also apply to shadow catchers, which sounds small until you are trying to art-direct what reflects in what while keeping plate integration sane. Shadow catchers often sit at the intersection of lighting cheats and comp expectations, so anything that reduces the number of special cases usually pays back quickly.

There is also an update to USD import preferences: you can override point instances so they can be used to instance other external geometries. That is a very specific knob, but pipelines that move a lot of set dressing through USD tend to accumulate a lot of “why does this instance not behave like that instance” questions. Having an explicit override in the import preferences at least gives TDs another lever that lives in the tool instead of in an external patch script.

The same release adds support for importing float and colour primvars from USD curves, and it fixes an issue where motion blur was not visible when using USD curves. If you push curves for hair, cables, trails, or procedural motion guides, this is the kind of boring detail that stops being boring the moment it breaks a shot.

For readers tracking platform standards, this is another reminder that renderer updates are increasingly about interchange stability as much as raw features. You still want speed, but you also want fewer surprises when assets cross DCC borders.

MaterialX displacement support gets more real

The 2026.3 release adds MaterialX import support for displacement shader sub graphs. It also fixes a handful of MaterialX-related issues, including proper operation for TransformNormal and TransformPoint, errors when loading scenes with Time and Frame nodes, alpha blending in HexTiledImage for color4 outputs, and import issues around bi-tangent inputs that could break normal mapping.

If your studio has been treating MaterialX as “great in theory, wobbly in practice”, this is a concrete step toward the practical side. A step, not the finish line! Not even for Scandinavian Studios! It does not claim perfect parity with every other tool, but it does show attention to the unglamorous parts: node correctness, error spam, and consistent interpretation of common transforms. A separate behavior tweak affects anisotropy: rotation in Standard Surface now matches OpenPBR and other renderers, and existing scenes are not affected. Hopefully

NRC memory use drops, plus a grab bag of fixes

OTOY says memory usage has been reduced when using the Neural Radiance Cache, referred to as NRC. The same notes mention fixes for render artifacts when using volume media in combination with NRC, plus a crash fix when rendering starts while virtual textures compile and are used in texture displacement, with the earlier reminder that virtual textures do not support texture displacement.

There is also a long list of resolved issues touching a lot of interchange formats and stability landmines: fixes for Alembic loading with materials saved as non-constant FaceSet objects, multiple FBX importer and exporter issues around vertex attributes and vertex animations, crashes on unsupported or invalid SPZ files, and potential application crashes upon initialisation on Windows and Linux.

A small but very real quality-of-life fix: empty file name nodes no longer get replaced with the directory of the containing OCS file, and they stay empty. That is the sort of bug that creates invisible path issues that only show up in a farm run at 3 a.m. on a Saturday night, while you are trying to remember what these things called “Weekends” were, the strange people in the group called “Friends” on Discord are blabbing about. Random example.

Drivers, OS baselines, and what your IT team will ask

The release notes list two explicit minimums. The minimum NVIDIA driver version required is R555, and it is R572 for GeForce RTX50 series. The minimum version of macOS required is 14.5.

Lua API tweaks for pipeline tinkerers

2026.3 includes Lua API changes that target data handling and introspection. Several octane.node functions now accept raw C arrays for cases where the API expects an array, and there are new helpers for querying animator types and retrieving animator data as a raw C array. It also states that for non-array attributes, you are allowed to set animators with different channel counts from that of the attribute type.

If your facility uses Lua to automate scene setup, tool integration, or pipeline hooks, or just is full of Autohotkey-Nerds (My People!) these are the kind of changes that can reduce wrapper code and make scripts less fragile. It is not the most glamorous section , but it is often where studios quietly win back hours.

Pricing and availability

OctaneRender 2026.3 is available via downloads linked from the release notes, including standalone builds for Windows, Linux, and macOS, plus node builds for Windows and Linux, and demo downloads for Windows and Linux.

Pricing is subscription-based via Studio+. The OctaneRender Studio+ subscription is 24€ per month billed monthly, and 20€ per month billed yearly for an annual subscription. There is also an OctaneRender Offline USB Dongle for 49 euros.

Even if the feature list sounds perfect for your exact setup, treat it like any other renderer update: test it on your own scenes, with your own texutres, on your own farm, before you let it anywhere near a delivery schedule.
https://render.otoy.com/forum/viewtopic.php?t=85624

The post OctaneRender 2026.3 adds virtual texture netrender first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

For those who don’t know the tool: OctaneRender is a GPU renderer that sits after lookdev and before finals, and it talks fluently with DCC plugins plus OpenUSD and MaterialX, when it is in a good mood.

The alpha, the scope, the fine print

OctaneRender 2027.1 Alpha 1 is out as a public development build intended for testing by experienced users, and it is explicitly not positioned as production ready. Scenes saved in this alpha are not guaranteed to stay compatible with future builds. The build is Windows only right now, the minimum required NVIDIA driver version is 572. The downloads listed for this alpha are the standalone Windows installer and a ZIP archive. Other build types are planned for subsequent releases.

Real time neural viewport, now with thunderbolt energy

The headline feature is a new real-time neural viewport mode that replaces the previous real-time mode. It is built on the neural radiance cache framework introduced in OctaneRender 2026. The alpha describes the new mode as enabling near noise-free interactive rendering at very low sample counts compared to traditional path tracing. The mode is designed to preserve the spectral path-tracing behaviour while improving interactive feedback, even under complex lighting conditions. It combines internal research with NVIDIA DLSS Ray Reconstruction.

In the UI, the alpha notes a dedicated toggle. The real-time neural viewport can be enabled or disabled using a Thunderbolt button in the viewport components bar. Quality settings for the real-time denoiser live under the imager node, with the goal of balancing performance and quality depending on the hardware. If you have ever watched a veiwport go from soup to something readable right as a director walks over, you already know why this matters. The promise here is faster clarity, not just faster pixels.

Upscaling joins the party: DLSS and FSR modes

This alpha adds support for new up-sampling modes based on NVIDIA DLSS and AMD FSR. The build also references AMD FSR 3. The implementation sits in the Upsampler section of the imager node, alongside other up-sampling methods. On the DLSS side, the referenced technology page describes DLSS Ray Reconstruction as an AI method that replaces hand-tuned denoisers with an AI network that generates higher quality pixels between sampled rays in intensive ray-traced scenes. Those statements describe DLSS generally, not a specific Octane integration result. This renderer is CUDA based, and the Windows alpha focuses on NVIDIA GPUs (Big surprise!).

AI Light 2.0: sampling that tries harder

AI Light 2.0 lands as a new light sampling method intended to resolve noise faster. AI Light is described as a hierarchical algorithm for sampling scenes with many light sources, and the update is positioned as a major revision compared to the original introduction back in OctaneRender 4.0.

For lighting heavy setups, this is the kind of change that can alter how fast you converge on creative decisions. If your daily routine includes juggling dozens of practicals, emissive set dressing, and a few too many hero gobos, any sampling improvement tends to show up right where it hurts, in the first minutes of iteration.

USD export and a more hands on USD workflow

OpenUSD workflows get a concrete upgrade. Geometry export to USD is included, and the build adds the ability to export a scene in USD format. The cgchannel overview also notes that geometry export in USD can include limited support for USD Preview Surface materials.

On the editing side, the standalone edition includes a USD Stage editor that allows selecting variants and layers without saving and reopening the USD file. The alpha also adds built in support for authoring variants and muting USD layers directly within the USD geometry archive.

If your pipeline already treats USD as a transport layer between layout, lookdev, lighting, and downstream tools, these changes aim straight at friction. More export options reduce the number of awkward handoffs that turn into late night chat messages that start with “hey quick question….”

UVs and geometry: more room for messy reality

The UV ceiling changes, because production UVs are never as polite as tool demos. The maximum number of UV maps allowed per primitive increases to 10, up from 3, and UV sets can be assigned arbitrary names in DCC apps that support it.

Other geometry and attribute changes include support for named UV vertex attributes, support for using vertex attributes in bump maps, support for colour vertex attributes in vertex displacement, and a Vectron tube primitive addition.

If you have ever inherited an asset with five UV sets and a note that says do not touch UV4, you now have more breathing room. The named UV support also helps keep humans oriented when the same mesh carries multiple UV purposes across shading, decals, and baking.

Changelog nuggets for TDs who read release notes for fun

Beyond new features, the alpha lists a spread of resolved issues and smaller changes. A few examples include fixes around DDS preference crashes, Alembic instancing, several MaterialX node behaviors, and multiple OpenUSD import issues such as points not loading correctly and animated point instances importing incorrectly.

The Lua API gets deprecations in geometry exporter properties, including moving from renderSizeX and renderSizeY to textureRenderWidth and textureRenderHeight, and replacing writeOcsData with embedNativeData. A small UI level tweak removes Clock Rate and Cores fields from the GPU information panel. This is where you start thinking about tool glue. If you have scripts that poke exporter properties or automate export settings, the deprecations are your early warning sign to check for breakage.

Availability, licensing, and pricing

This alpha is available alongside the stable OctaneRender 2026 releases. The software is offered as rental only via Studio+ subscriptions. The pricing listed is €23.95 per month or €239.88 per year, and the Studio+ subscription page also lists an annual price presented as 19.99 € per month billed yearly.

Free Prime editions are also available for OctaneRender and Octane X, with the Prime editions limited to rendering on a single GPU and offering a smaller set of DCC integration plugins. The alpha download links themselves require a licensed customer login for access. That is where OTOY enters the picture in the most practical way possible.

Production reality check

This build is explicitly framed as experimental, and it is not recommended for production use. That guidance aligns with the normal alpha reality: features change, files drift, and stability work continues in later builds.

New tools and innovations should always be tested before use in production, ideally on representative scenes with your actual assets, shading conventions, and deadline pressure.

What to watch while you test

The big workflow test is whether the neural viewport mode makes iteration measurably smoother on your scenes, and whether AI Light 2.0 shifts your sampling strategy. The second test is whether USD export plus USD Stage editing reduces round-trip times in YOUR pipeline. The third is whether the DLSS and FSR upsampler options behave predictably inside your lookdev and review loop, especially when you rely on consistent framing and visual stability.

https://render.otoy.com/forum/viewtopic.php?t=85551

The post OctaneRender 2027.1 alpha goes neural first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

InstaMAT Studio is out now – a layer-based painting and node-based authoring tool in the same general category as Substance 3D tools like Substance 3D Painter, Substance 3D Designer, and Substance 3D Sampler, with integrations into common DCCs and engines including 3ds Max, Blender, Maya, Unity, and Unreal Engine.

What changes in 2026 is the set of levers available for high-precision, iteration-friendly detailing. Curves Brushes move detail painting toward an editable, control-point workflow. Lazy Stroke helps freehand lines behave. Radial symmetry adds a new patterning tool. Masking and mesh filters expand geometry-aware selection and effects. The new toolbar and hotkeys aim to keep artists in flow instead of chasing settings panels.

And yes, your first experiment should probably be those curve-driven panel lines that always look great right up until the model changes. This time, the system is explicitly designed so the detail survives that upstream change.

Curves Brushes: strokes that stay alive

Curves Brushes let you create editable curve paths on the mesh, using control points rather than a one-and-done freehand stroke. Those curves remain editable after creation, including moving and refining control points, and transforming an entire curve as a unit by translating, rotating, or scaling the path.

A single curves layer can hold multiple curves, and their painting sequence can be reordered. Curves can also be set to erase instead of paint, and they can be closed to form continuous shapes from end point to end point.

Control points support different point types, including linear, symmetrical, smooth, and cusp, with a Joint Smooth setting to control how sharp or fluid the transitions are between segments. Each control point also supports per-point settings for radius, falloff, flow, and rotation, enabling effects such as tapering and gradual fading along the curve.

Curves can orient brush strokes along the path, so details follow the curve’s flow rather than fighting it. Curves also support dynamics for randomised size, flow, rotation, and position to add variation without manually wiggling your wrist into submission. The Curves workflow uses a GPU-accelerated 3D painting engine and does not rely on mesh UVs. The stated result is that curves remain intact even when topology or UV layout changes, which is framed as especially useful for repeating high-precision details such as panel lines, seams, stitches, and decorative elements.

Lazy stroke smoothing, now built in

Alongside Curves, InstaMAT 2026 adds Lazy Stroke, a brush-smoothing feature designed to dampen shaky-hand input and cursor jitter. When enabled, the brush follows the cursor with a delay set by a configurable radius, producing smoother lines for precision freehand painting. The feature is positioned for tasks such as smooth linework, organic patterns, and fine-detail passes where jitter becomes visible in the final maps. If you have ever zoomed in to paint one confident line and instead produced a seismograph reading, Lazy Stroke is aimed squarely at that moment. Try it, then decide if it belongs in production.

Symmetry upgrades: radial joins planar

Radial symmetry painting is new in InstaMAT 2026, enabling repeating brush instances around a central axis. The symmetry axis can be set to X, Y, or Z, the number of repeated instances is configurable, and the angle span can cover full 360 degree patterns or partial arcs. The plane origin is also customizable, allowing the symmetry center to be placed where it is needed on the asset.

Planar symmetry painting is also described as significantly improved. The symmetry plane can be offset to a custom position on any of the three world axes, plane visibility can be customised, and there is an option to mirror the brush on the opposite side of the plane. Symmetry accuracy is described as improved even when painting on meshes that are not exactly symmetrical, targeting the real-world scenario where characters and props have small asymmetries and deformations.

Masking: normals, submesh size, and raytraced AO

InstaMAT 2026 extends its mask set with new workflows aimed at isolating geometry features without hand-selecting everything. The new Mesh Normal Mask can isolate parts of a mesh based on polygon normals and an angle tolerance. The workflow is click-based: click a region, and the mask selects surfaces with similar normal directions. Multiple chosen areas can be defined within a single mask, and tolerance can be adjusted per point. The mask is described as UV independent and stable across topology or UV changes.

The Mesh Submesh Mask can mask submeshes by size and distance, targeting scenes with many similarly sized objects where manual isolation is tedious. There is also a Mesh Ambient Occlusion Mask described as using raytracing to generate occlusion-based selections for isolating crevices, corners, and recessed areas.

Mesh filters and nodes: mirror, bevel normals, drips, and smoothing

A batch of mesh-oriented effects and nodes are listed as part of the 2026 update. Mesh Laplacian smoothing arrives as an option in the Mesh Smooth node, described as producing a more unified surface while better preserving mesh volume compared to traditional smoothing methods that can shrink geometry. The described use cases include cleaning scan data, removing photogrammetry noise, and refining sculpted details while preserving silhouette.

Mesh Mirror can mirror decals, masks, and entire layers, and it can be applied to a layer group to mirror complex effect and mask combinations.

Mesh Bake Bevel Normals is a node for beveling low poly asset edges using a GPU-accelerated bevel normals baker, with procedural masking for selecting which objects or edges to bevel. The behavior is described as procedural, so bevel placement remains correct if the input mesh topology or UVs change.

Mesh Directional Blur is presented as a way to create leak and drip effects by blurring in a specific direction in 3D space, keeping directionality consistent across the mesh surface regardless of UV layout or texture resolution. It includes distortion and falloff controls.

Additional mesh features listed include Mesh Solidify for solidification to prevent rendering artifacts, Mesh Sharpen for definition and detail clarity, and a Mesh Stylized Filter for non-photorealistic texturing options.

InstaMAT UI and workflow: less hunting, more painting

InstaMAT 2026 introduces a dedicated painting toolbar intended to centralise common controls. The toolbar provides quick access to brush and curve settings, including radius, flow, rotation, Lazy Stroke radius, symmetry, and curve-specific controls. It is described as dynamic, updating based on the active layer type so only relevant options are displayed.

There is also a dedicated brush rotation hotkey, described as Cmd or Ctrl+Shift with a left-mouse drag, to rotate the brush, aiming to reduce interruptions during stroke work.

Viewport and gizmo changes include planar translation gizmos for moving a mesh, effect, or mask along two axes at once, plus custom viewport wireframe settings for width and color, and a viewport shortcut overlay that displays hotkeys while painting, using curves, and using the paint projector.

Mesh import settings add options to configure mesh up axis and coordinate system handedness for asset texturing projects.

Integrations: Blender, Unreal, 3ds Max, Maya

The release notes list updates for several integration plugins tied to the latest https://docs.instamat.io/en/Products/InstaMAT_Studio release.

InstaMAT_for_UnrealEngine lists support for Unreal Engine 5.7.3, plus fixes for crashes when creating invalid graph instances, and fixes for broken materials and mesh orientations for Scene outputs. Library previews are added for Mesh-type Graphs and Graph Instances.

Blender integration notes include support for the latest Studio release, improved performance when setting mesh as a graph input, improved performance when resetting graph instance inputs, and fixes for plugin stalls when creating faulty graph instances. Library grid UX is adjusted with fixed cell width, and search results quality is described as improved.

3ds Max integration notes list support for the latest Studio release and a fix for the plugin getting stuck when creating faulty graph instances, plus window icons changed to match the main menu.

Maya integration notes list support for the latest Studio release, improved mesh-as-input performance, fixes for plugin stalls on faulty graph instances, and a fix for incorrect exported textures when using the export dialog window.

InstaMAT Licensing and pricing: what the numbers say

InstaMAT licensing is split across tiers with revenue or funding caps stated for some options. The Pioneer license is free and fully featured with commercial-use rights, with availability limited to individuals or businesses with annual revenue or total funding less than 100,000 US dollars, and it requires attribution.

The Indie license is available for individuals or businesses under 250,000 US dollars in annual revenue or total funding, with an option at 8 US dollars per month billed annually, and a perpetual Indie price shown at 489 US dollars. For Pro, the pricing page lists a Pro subscription shown at 36 US dollars per month billed annually, and a perpetual Pro license shown at 989 US dollars.

If you are evaluating the tool for a pipeline, test it against real assets, real render targets, and real deadlines before it touches a production branch. New tooling should earn trust with results, not promises.

Finally, keep an eye on how the new mesh filters slot into your existing material graph habits. Directional blur for drips in 3D space, procedural bevel normals, and AO-based masking can remove steps that otherwise happen in separate tools. If it holds up, it reduces context switching. If it does not, at least you learned it on a duplicate branch instead of the hero asset.

Also, do not skip the boring step: validate exports, naming conventions, and texture packing against your engine ingest rules before you fall in love with a shiny new brush. The most dangerous bug is the one that looks like a style choice until delivery day.

InstaMAT Test: Painting, Procedurals and Pasta

The post Abstract ships InstaMAT 2026 Curves Brushes first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

For those who do not know the tool: Modeler is a direct modeling add-on for Houdini that focuses on interactive, viewport-based polygon editing rather than node-heavy procedural setups. It is designed to cover everyday modeling tasks such as blocking, refinement, and adjustment directly on geometry, while remaining fully compatible with Houdini’s SOP context. Modeler does not replace Houdini’s procedural toolset, but complements it by providing fast, hands-on controls for artists who need to shape, edit, or iterate on meshes without building complex node networks for each small change.

Alexey, (SideFX Profile) the one-man-band behind the extremely practical direct modelling toolkit with the catchy name “Modeler”, has released exciting new features with the annual update 2026.

Polypen 26

The central addition in Modeler 26 goes to the PolyPen, a context-sensitive viewport tool that consolidates point, edge, and polygon editing into a single workflow. Geometry elements are detected automatically and can be manipulated directly in the viewport, reducing tool switching and node detours. The intent is a single, general-purpose modelling instrument rather than a collection of specialised operators.

Edges can now be extruded directly with a click, allowing new geometry to be pulled out interactively without invoking separate nodes. Polygon insets are also handled directly inside the PolyPen, removing the need to route operations through the Extrude SOP for common adjustments.

Subdivision has been expanded with screen-space cutting. Polygons and edges can be cut freely based on the current viewport orientation, enabling fast, less constrained topology edits that prioritise visual feedback over strict axis alignment.

The PolyPen operates exclusively in true real-time symmetry rather than relying on a downstream Mirror node. This simplifies symmetrical edits, particularly for character modelling and proportion adjustments, while keeping the result explicit at the geometry level.

Additional tools include Connect Rings, which creates orthogonal subdivisions from selected edges, and Delete Island, which removes entire UV islands in a single action. Together, these changes focus on reducing friction in common modelling tasks rather than introducing new abstraction layers.

Open Curves Boolean

Fast and complex division of geometry is now possible with the help of open curves of all kinds.

Bezier Deform

Geometry can now be deformed using a Bezier curve as input, which is useful not only for character modellers, but also for advanced blend shapes or effects.

Cards

With the new Draw Cards SOP, cards and tubes can be drawn directly in the viewport, which gives it a bit of a ZBrush CurveTube feel.

Object Layers

The new layer palette with the usual hide/ghosting/select options provides more order and clarity.

More features in the sneak peek

Pricing and availability

Existing users can upgrade now for £50. Gumroad will automatically send an email with the upgrade link (with a slight delay). If you want to make your polygon life in Houdini much easier, you can do so for £100 on Gumroad. And if you want to know more, join the modeler Discord.

And as always, verify the new features in a non-critical scene before integrating it into a production.

The post Modeler 26 for Houdini released first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

InstaMAT has set out to become nothing less than the holy grail of the material and texture pipeline. To that end, it combines a layer-based painting system with a scalable node-based material and asset editor, adds a mix of innovative features, and builds on InstaLOD’s mesh-processing DNA. We are taking a closer look at this ambitious package to see whether it can earn a place in a real production pipeline, or whether the free version will remain its main selling point.

In the spirit of Substance Painter, we start by texturing an asset. The Element Graph, comparable to Substance Designer, will be examined in detail in a second part. We will not ignore it entirely here, as the tight integration between these areas offers too many interesting possibilities to leave aside.

For our demo workflow, we need a suitable asset. Which object combines all materials in one place? Exactly, the pasta strainer portafilter. Wood, plastic, metal, and something organic. Quickly modelled in Houdini and exported as USD.

PROJECT vs PACKAGE

A bit of differentiation is needed here. The welcome screen first offers the option to create a project, which then leads to a second level of choices. For the sake of simplicity, we loosely map familiar tools to the respective options, but this is only a rough orientation. InstaMAT is not restricted to these boundaries and lives from the interplay between its different areas.

Asset Texturing works much like Substance Painter, allowing you to paint directly onto a mesh or apply materials.

Material Layer Project is closest to Substance Sampler or Quixel Mixer, enabling the creation of a new material by layering pre-made materials.

Materialize Image uses AI-based methods to generate a PBR material from a photograph.

Element Graph operates in the vein of Houdini’s Copernicus or Substance Designer, providing a node-based environment for material creation. InstaMAT goes significantly further here, offering everything from automated mesh processing to terrain generation.

That said, this initial choice is not particularly critical. Afterward, you end up in the Package overview, where you can freely create additional projects and import assets. It is best to think of a Package as a folder structure that contains your projects, such as layer painting setups and node graphs, along with all imported meshes and assets.

UV Unwrapping

For our purposes, “Asset Texturing” is the obvious next step. Unfortunately, the modeller clearly had nothing but pasta on their mind and forgot about the UVs. According to InstaMAT, this is not a problem at all. This is where the mesh functionality inherited from InstaLOD comes into play.

We start with our first small Element Graph, created via File > New Project > Element Graph. The unwrapping itself happens inside this controlled node-based environment. Since we do not want to keep things too simple, we split our mesh into three UDIM tiles for the handle, the strainer, and the noodles. The USD mesh is added to the Package via drag and drop and from there into the still empty node graph.

During import, InstaMAT triangulates the mesh in the background. If issues occur at this stage, for example with non-importable NURBS geometry such as the noodles, it helps to pre-triangulate the mesh in the DCC application. The basic unwrap pipeline consists of adding a Mesh UV Unwrap node via the space bar, and that is essentially it. Different methods are available, including Organic, Hard Surface Axial, and Angle. In our case, we use Hard Surface Axial.

Noodles with UVs

Since the noodles already have UVs and we want to unwrap the handle and metal parts separately, we split the asset using the Mesh Extract by Submesh node. Submesh masks detect connected polygon flows within a mesh. This very useful node is also available in the Layer Painting context.

To generate UDIMs, we offset two of the node branches by one and two units respectively using Mesh UV Transform, then merge the three branches with Mesh Append. Finally, we export the mesh, now equipped with proper UV tiles, as FBX. Details on the export dialog and the rather central export button will be covered later in this article.

Orientation

We drag the FBX we just exported into our Package and can now create an Asset Texturing project. For new projects within a Package, there is a very prominent “+” button. In the project dialog, the key setting to watch is Type set to UDIM, and selecting the mesh from the Package. Templates can safely be ignored for now.

In terms of logic, the interface follows the conventions of established painting applications. You find your way around quickly and, more importantly, actually enjoy working in it. There are a few quirks, but after some quality time in InstaMAT, they stop standing out.

Interface

So we begin with the classic material brawl. We pick suitable materials from the library and happily mix them using all kinds of masks. A first plastic material is selected from the library on the left (A) and dragged directly onto the handle. Even though this is a single mesh, InstaMAT automatically and correctly masks the handle’s polygon flow using the same submesh technique, via Mesh Mask by Submesh. That is genuinely practical.

The library also contains grunge maps, decals, alphas, and similar assets. Navigation is quick, helped by various filters and view options. The additional tabs on the left, above the library, lead to the project settings. These include the UDIM setup, bit depth and colour space per channel, and the underlying mesh. There are also viewport settings, such as tone mapping, AgX in our case, lighting controls like HDR blur and saturation, and render settings. Thanks to optional ray tracing and global illumination, the viewport looks quite presentable.

As expected for this genre, the HDR can be rotated interactively using Shift plus right mouse button. The icon with the open package finally takes us back to the Package overview, listing all projects and assets. The bar above the viewport (B) acts as a quick access toolbar. It contains the baking and export dialogs, as well as a few, partly duplicated, commands for the layer view and the handy option for creating new projects.

The layer stack (C) itself is built in a very traditional way and holds no real surprises in terms of logic. Individual channels such as base colour, normal, and roughness can be selected, their opacity adjusted, masked, and enhanced with effects and generators. Things become more interesting with the “Reference” function, which we will come back to shortly, along with the two different layer types.

Below the layers palette are the layer settings (D). These include options such as projection type, for example decal, triplanar, and UV. More options will likely appear here in the future. This area also holds the material or brush settings, as well as channel mapping, provided the layer is based on an Element Graph. At the bottom, we find the Image Viewer (E) for checking textures, baked maps, and masks.

The Great Noodle Bake Off

Before we really dive into the materials, we need to handle baking. This is where the geometric details of our mesh are “baked” into 2D textures. This is essential because without maps like Curvature, Ambient Occlusion (AO), World Space Normals, or Position, the generators and masks would be groping in the dark later on. For instance, the rust effect used later relies on the Curvature map to locate edges.

The Baking Dialog (accessible via the toast icon in the toolbar) is easy to understand: check the desired maps, select the resolution, and fire up the oven. The finished textures land neatly organized in our Package and are automatically linked by InstaMAT, so we can get started right away.

Material Brawl and Layering

InstaMAT ships with around 1,000 procedural materials covering a wide range of use cases, and they look genuinely good. Additional materials can be created either in the Element Graph using nodes or via Photo2PBR. A few hundred more can be found on the in-house Polyverse platform, even though that ecosystem does not (yet) come close to the breadth of Adobe’s Substance Assets.

For the metal parts, we drag a nicely scratched, used-look material straight onto the mesh. Since all bundled materials are created in the Element Graph, they can also be opened there and adjusted down to the smallest detail. The black plastic is replaced with an oiled wood material from the library.

The materials already come with pleasing imperfections, but they are still a bit too well-behaved. Time to dive into generators, filters, effects, and masks. For the obligatory hint of rust found in any respectable kitchen, we first drop a Rust Iron material onto the strainer and select Edge Wear Mask directly under Mask. To avoid overly regular edges, we multiply in a grunge map using Mesh Project Mask. This workflow will feel familiar.

The Brush Engine

First contact with the brush engine happens through Mesh Mask Painting. Here, we can use a brush and repurposed decals as brush masks to add targeted stains. Once again, the interplay with the node graph becomes apparent. Under the hood, the stain decal is not a simple alpha image but a highly adjustable Element Graph. Parameters such as the number of splatters and the dryness at the core can be tweaked, and endless variations can be generated via the seed.

Need your own micro-scratch alpha? Then you build it in the Element Graph. Using the plus icon in the top bar, we create a new graph and, in fast-forward, turn a thin oval shape generator into a pattern with random rotation, scale, and opacity using the Guided Scatter node, controlled chaos, in other words. Warp and Slope Blur nodes handle distortion and edge bleeding for the individual scratches, driven by procedural noises and grunge maps. A final grunge map multiplies in extra detail, and the result is written out via an Output node to our Package under Paintbrushes and Masks, immediately ready for use in painting.

Proper Scratches

To properly scratch up the nice wooden handle, we create a new multichannel layer, also known as a fill layer, above the wood layer. We enable only the Height channel and set it to Subtract. On the wood layer, we paint a mesh painting mask using the brush we just created, accessed via the Asset Browser, and reference this mask on the new height layer using Mask Reference. Below the wood layer, we drop an Aged Wood material, so that lighter core wood shows through in the scratched areas. The principle is a familiar one.

 A Matter of View

Using the shortcut C, we cycle through the channels. With S, we activate solo mode for the currently active layer, including masks. By right-clicking on a layer and choosing Output for Current Channel, the channel opens in the 2D viewer. A few dropdowns would be welcome here. Viewing a more complex mask is also still a bit cumbersome. If we want to see the combined effect of an entire mask stack, we have to right-click the topmost mask layer and select View Composite Output. The well-established Alt-click on a mask would be preferable here.

That said, InstaMAT is still very young and developing rapidly. These quality-of-life features will likely be implemented sooner rather than later, especially since the team actively listens to user feedback and feature requests.

Multichannel-Element-Layer

In the layer palette, we find four fundamental layer types: Multichannel Layer, Element Layer, Multichannel Brush, and Element Brush. A Multichannel Layer acts as an almost omnipotent stem cell and can essentially become anything. Right after creation, it looks rather unassuming, showing only a colour in the base colour channel. This is where the range of possibilities starts to unfold. Instead of a flat colour (which applies to all channels), we can assign textures, procedural graphics, layer references, or full Element Graphs.

If we want to use texture maps from an external material inside InstaMAT, this is the layer to use. Once the maps are imported into our Package, we assign them to the corresponding channels on the layer and end up with zucchini noodles. Do not forget the mesh mask, we accidentally create the world’s first vegan portafilter. It is best applied to a folder rather than directly to the layer.

An Element Layer is simply an Element Graph applied as a layer on the mesh. Typical examples include materials and noises, but also more exotic options such as BezierCurve, which lets us draw a curve in a separate window and project it onto the mesh as a decal. Following this logic, the Element Brush allows us to paint directly onto the mesh using a material or any other Element Graph-based asset, while the Multichannel Brush represents the classic empty painting layer across all channels.

InstaMAT Unmasked

When it comes to masks, InstaMAT offers a wide range of options. The previously mentioned Mesh Projected Mask can be filled with more than just grunge maps or textures. Any graph, effect, or generator can be used, even those originally intended for something else. For exploration, it is worth typing “mask” into the search field and browsing through options such as Aged Paint or more unusual entries like Circular Scatter.

The Polygon Mask operates using a freely movable 3D cube or sphere in space. These masks can be modified with an arbitrary number of filters. Do not rely solely on the Add Filter menu. Browsing under Pick from Library reveals even more options.

The Volume Mask is a bounding box mask. It treats the entire object as a cube, can be moved freely, and allows for softened edges. A clear highlight is the Mesh Mask, which identifies connected polygon flows. For Houdini users, this corresponds to name attributes or USD paths.

King of Masks

The undisputed king of masks, however, is the Mesh Mask Builder. It allows the creation of highly complex masks within a single layer. It not only accesses baked mesh maps but also, as if internal references were set, picks up on effects previously painted onto other layers. The Layer Ambient Occlusion function, for example, incorporates existing scratches. Directional behaves like a freely positionable spotlight, or aligns itself to normals, and Curvature forms the basis for all edge wear effects. Grunge and scratch layers are then used to break things up again. This starts to look suspiciously like an Element Graph, and indeed, building custom masks of this complexity is entirely possible.

Additional masks can be found in the asset library. Examples include the Mesh Leaks Mask, which simulates dripping fluids, the Light Mask, which allows actual lights, such as area lights, to be positioned and used as masking tools, and the Layer Height Curvature Mask, which takes height information from all layers as curvature input.

And just because we can, we quickly build our own mask in the Element Graph. It generates a Voronoi pattern as a base and distorts it with a few nodes, exposing their sliders as parameters. Saved under Mesh/Mask, it appears immediately in the layer palette and can eventually be used for some painterly look, one day. The important part is that it works, and it opens up a large range of possibilities. This mask look can be extended further into a complex generator or even a full material as an Element Layer.

Generators and Effects and Filters

At their core, generators are practical Element Graphs designed to take the pain out of detail work. A good example is the highly configurable Scratches Generator, which can wreak havoc across low and high frequency damage, complete with per-parameter variation. Numerous additional controls, such as distort and warp, help achieve a more organic look. This should feel familiar from the Element Graph when we built our own scratches brush tip. Helpfully, each generator or graph displays a short description directly underneath it.

Effects and filters have close relatives in any image editing application. At first glance, you encounter the usual suspects like Swirl, Radial Blur, and Warp, along with Levels, Curves, and Saturation. Things get more interesting once we switch to Pick from Library. Here, a more adventurous set reveals itself. Channels can be mixed, HSL values randomised, film grain added, the previously mentioned Edge Detect used for mask refinement, or photoreal textures pushed into a stylised direction via Stylized filters.

Filters and effects are spread across the library a bit. It is worth browsing through different categories such as Image, Mesh, or Material and simply throwing what you find onto the asset to see what happens.

Decals

Logos, icons, bullet holes, and similar details are commonly projected onto a mesh as so-called decals. In InstaMAT, an image is simply dragged directly onto the mesh and positioned in Decal mode. Under the hood, this creates a multichannel layer, allowing us to add a separate roughness or height map, as well as additional masks.

It is also possible to project an entire folder structure containing materials and custom masks onto the mesh by using a Mesh Projected Mask set to Decal mode, effectively turning the whole setup into a decal.

Hand Painted … Look

When it comes to hand painting, InstaMAT distinguishes between actual hand painting and a hand-painted look, however that is achieved. The latter is easy to produce thanks to its procedural approach, with powerful masks and generators. In the most brute-force way, we could build an oil paint effect in the Element Graph and apply it directly on top of a PBR texture, or simply use the Stylize material effect. Conveniently, this need not even happen in the painting context. Everything can be done in the node graph, as effects and filters are accessible everywhere, making it easy to create variations.

So what exactly can the brush engine do right now, and what can it not do yet? At the moment, we have three tools: Paint Brush, Eraser, and Paint Projector. Artists who like to actually swing a brush can set brush size, rotation, position, and flow to be constant, random, or driven by pen pressure, which works very precise and smooth on my Wacom. There are also options for axis-symmetrical and path-oriented painting, along with fundamentals such as falloff and spacing.

For now, that is unfortunately all. Tools that are essential for serious hand painting, such as Smudge, Stamp, and Lazy Mouse, are already on the roadmap but not yet available. (Buuuuut: We were able to catch a glimpse of a preview build. It already features many improvements, like Lazy Mouse, mighty Curves for your seam needs, and Radial Symmetry.

The Paint Projector works in a familiar way, allowing us to paint a texture onto the mesh from a camera perspective using a brush, or alternatively apply it directly as a mask. At the moment, only 3D painting in the viewport is supported. 2D painting in the texture viewer is currently in development. The real strength of the current system lies in the ability to design custom brushes, masks, alphas, and effects in fine detail via the Element Graph.

Material Generation from Photos

What if the handle is made from kitchen tiles? Time to test material creation from photos. To turn a simple smartphone photo into a usable material, we once again start a new project via the “+” button, this time choosing Materialize Image and selecting our image. In the next step, we already get a preview of the resulting material. The input image can be cropped or upscaled using neural assistance. The Color Equalizer normalises the image, while Base Color Shadow Cancellation removes lighting influences from the photograph. Individual channels can be adjusted separately. For example, roughness can be broken up using a grunge map. Optional dust and dirt effects can be added directly.

Once the prominent Save button in the top bar is pressed, the material becomes available in both the painting context and the node graph. From this point on, we can freely switch back and forth between the Materialize and Texturing tabs to refine the result.

For more complex materials, the node graph comes into play. Materialize Image appears here as a node. Why does this matter? It allows us to process individual channels using the full power of the image processing engine, combine them with other materials, or push the look in a more stylised direction.

Mesh Changes

Just before finishing these lines, our modeller made a few changes to the mesh. Fortunately, we can simply drag our existing unwrapping graph into a new graph, which gives us a node with exactly one input and one output, and then add the updated mesh. Since the naming and number of submeshes have not changed, the unwrapping is effectively done at that point. We duplicate the project via File > Save Project Copy and replace the mesh in the Project Editor. Re-bake the maps once, and we are done.

But what happened to our hand-painted masks? Did they carry over in the same way as the generators? Thankfully, yes. This apparent magic is explained by the fact that every single brush stroke is stored in 3D space rather than painted onto the 2D UVs. As long as the mesh does not change too drastically, as in this case, the strokes are always projected onto the correct location. Only one decal needed a slight adjustment, which was to be expected given the slightly different mesh orientation. We will take a look at how to implement this in an automated and scalable way within the node environment at a later point.

Performance and Flow

InstaMAT runs pleasantly smoothly and feels modern, admittedly a subjective impression. In some places, you can sense the procedural foundation. Especially when opening a project, it can take a moment for everything to be recalculated, depending on complexity. Helpfully, the UI displays VRAM usage in the bottom right. In this project, four UDIMs at 4096 resolution with 16 bits per channel filled 24 GB of VRAM once, resulting in a crash. Paying attention to the red warning icon and restarting the application promptly would likely have prevented that. For performance optimisation, the project resolution can be changed at any time, for example, working at 2048 and exporting at 4096, or by disabling viewport ray tracing. Or even better: Limit VRAM usage in the settings. This leaves some memory for the system.

Export & Rendering

The Export button, centrally located in the top bar of the UI, opens a clear, well-structured menu. Here, in fairly standard fashion, we can set file formats, resolution, and bit depth, with the latter two configurable per UDIM. Desired channels can be added via simple toggles, and the entire setup can be saved as a template.

When creating a template, we can go a step further and fine-tune the mapping of individual channels and enable output converters. These can, for example, convert roughness into glossiness maps or allow us to choose between DirectX and OpenGL normal formats.

The export itself is quite fast, and the maps are easily picked up by Octane and Karma (and likely by every other engine, too). Here are some rendered examples, it was a lot of fun to noodle around with the maps, putting them through their paces in extreme close-ups and under various lighting conditions

Community and Tutorials

Help, information, and like-minded pioneers can be found on Abstract’s Discord. On YouTube, there is a growing number of tutorials and presentations created by the steadily expanding community and by Abstract and its founder.

Particularly helpful: the application ships with several well-documented example scenes that can be dissected, studied at leisure, or used as a starting point. These well-documented sample projects make it easier to get started and illustrate solution paths for more complex problems.

Good ideas and user feedback are always welcome; feature requests can be posted right here in the forum: https://community.abstract3d.com/c/instamat/features/67

Polyverse

Think of Polyverse as InstaMAT’s extended arm into the web and collaborative workflows. It doesn’t just execute InstaMAT on the server side. It simultaneously serves as a management, versioning, and review tool for assets and materials. This even includes direct download plugins for Unreal and Blender. Beyond that, assets and materials can be processed right in the browser. Tasks like file conversions or turntable generation can be handled directly online

Pricing and Availability

The good news first: InstaMAT is available as a fully featured Pioneer License for free, as long as your revenue stays below USD 100,000 and you mention the tool. Above that threshold, there is an Indie version for revenues under USD 250,000. This is available either as a perpetual licence for USD 489 or as a subscription for EUR 8 per month.
Wait, a subscription? Software development costs a lot of money and needs to be funded somehow. You have to keep in mind that Abstract is not a global corporation. It is a small German developer with fewer than 30 employees. Considering they poured a lot of private capital into InstaMAT, the price is actually more than fair.

Beyond that, there is also a Pro version that offers the same integration with game engines as the Indie license. The Pro license removes the 250k USD revenue cap and includes server-based services, such as a virtual machine for running InstaMAT.

One important detail: the Pioneer License is an always-on licence. When my Wi-Fi dropped out once, InstaMAT immediately followed suit because the licence could no longer be validated. Offline licensing is only available at the Enterprise level or higher. A compromise is the Indie and Pro license that only requires occasional connection with the internet.

Sneak Peak

Just before wrapping up these lines (again), I managed to catch a glimpse of an early preview build. I cannot go into too much detail, but plenty of great things are coming our way. The brush updates include Lazy Mouse, Radial Symmetry, and Curve Tools, alongside a new Mesh Mask from normal and new Materials. The release is already planned for Q1! (Since all brush operations run procedurally in the background, adjustable post-drawing deformers like jitter are also on the roadmap. However, they might not be ready for the very next version.)

Instalove? The Verdict

The seamless and immediate integration of Painting and Nodegraph makes InstaMAT a remarkably fast and flexible tool. The Element Graph is an incredibly powerful instrument with capabilities that extend far beyond pure image processing found in other tools (our journey of discovery promises, among other things, RBD sims, complex mesh processing, automation, and even terrain creation). It can be compared to Houdini: if we are missing a specific effect, tool, or setting, we can very likely build or adapt it ourselves directly in the Element Graph.

The decision to compute brush strokes in 3D space rather than 2D is a clever design choice that directly addresses the reality of changing base meshes and scalability. However, a few brush tools are still missing to fully satisfy dedicated hand-painting artists. Though those who primarily paint masks won’t find this particularly bothersome. Speaking of which, the masks are another major strength: clever generators and the interplay between masks (maps) make complex effects achievable very quickly.

Anyone familiar with the Substance ecosystem won’t take long to feel right at home in InstaMAT. I highly recommend trying out the free Pioneer License to see how you can integrate the tool into your workflow. It is well worth it and will lead to quite a few “Aha!” moments.

What I liked most:

• The integration of painting and node graph, with the ability to intervene and combine procedurally at any point
• The highly customizable masks
• Performance & Flow
• Brush strokes and basically everything else are calculated in 3D space, so its easy to change the modell oder make automatic texture processes.

Room for improvement:

• Channel/Mask viewing is still a bit cumbersome
• Direct brush & painting features such as Clone, Path, and Smear

With the new update on the horizon, many wishes are being addressed. Once released, we will take another close look at InstaMAT. We will also dive deeper into the terrain and scaling workflows then.

The post InstaMAT Test: Painting, Procedurals and Pasta first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

Theory Accelerated is the independent R&D studio of former ILM and Naughty Dog technical director Matt Puchala. Known for Axiom, a GPU-based volumetric solver for Houdini, the studio builds specialised simulation tools aimed at faster, artist-friendly workflows for VFX and cinematics. Paradigm extends this approach from smoke and fire into liquid dynamics.

Theory Accelerated has released Paradigm, a new GPU-accelerated sparse liquid solver for Houdini. The software, currently in open beta, aims to provide a faster alternative to Houdini’s native CPU-bound FLIP solver. According to Theory Accelerated, Paradigm can simulate millions of particles “in a fraction of the time a CPU would take”.

Like its sibling tool Axiom, Paradigm is designed to handle simulations across scales—from small splash tanks to large-scale water scenes. The solver runs entirely on the GPU through OpenCL, making it hardware-agnostic and compatible with GPUs from AMD, Intel, and NVIDIA, as well as Apple Silicon.

Built on the same tech as Axiom

Paradigm shares its underlying sparse-simulation architecture with Axiom, Theory Accelerated’s established GPU-based volumetric solver. Development of the two products is intertwined; improvements made during Paradigm’s creation reportedly led to better collision detection in Axiom 4.0. Despite the shared lineage, Paradigm and Axiom are separate tools, and there is currently no two-way coupling between liquid and volume simulations.

Simple setup, Houdini-native workflow

Paradigm integrates directly into Houdini and is structured around a compact node set—just four nodes are required to set up a basic splash tank. Its interface closely resembles Axiom’s, offering familiar workflows for existing users. Artists can use source shapes as emitters, colliders, or custom forces.

According to the developer, the goal is to make iteration as fast as possible. Paradigm’s GPU core enables quick previewing of surface tension, viscositiy, and adhesion effects, helping artists evaluate sims without long cache times.

Still missing whitewater, but it’s coming

As of the current beta, Paradigm supports small- and medium-scale liquid simulations but lacks several production-level features. Whitewater simulation and full support for Houdini’s ocean spectra are not yet implemented. Upcoming updates are expected to add colour sourcing, temperature-driven behaviour, viscosity attributes, and support for narrow-band simulation. Matt Puchala describes the current build as “highly unoptimised”, but plans to bring Paradigm to “the same level of polish that Axiom has”.

Free to test until February 2026

The open beta is free to download for all users until the end of February 2026c (See the FAQ for details). After that, Paradigm will move to a commercial model “similar to Axiom”, offering both perpetual node-locked and floating licences. The software runs on Houdini 20.0+ across Windows, Linux, and macOS, and requires an OpenCL 3.0-compatible GPU. The documentation includes setup examples and sample projects. Installation requires creating a free Theory Accelerated account.

Early verdict: promising, but still maturing

While Paradigm’s GPU acceleration promises a major speed boost for Houdini-based liquid simulations, it is still in beta. Key production features, such as whitewater and advanced ocean interaction, are not yet ready, and the solver is described as unoptimised. For now, Paradigm is best used for testing and experimentation rather than critical production work. As always, new solvers should be tested on controlled scenes before deplorment in a production. And we’ll check out the next builds to keep you in the loop when it is worth your precious GPU-cycles!

The post Liquid Thinking: Paradigm Brings GPU Speed to Houdini first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

A tasting of the dynamics and geometrys side (of) effects

This release is not about the number of features, but about finishing what was started, achieving true production readiness, robustness, performance, and ease of use. It’s a version focused on quality of life. Feature sets like MPM simulations and Karma have matured like a good wine. The machine learning tools respect the artist’s skill set and have left their state of play are actual usefull in production.

Even though SideFX remains modest in its official statements, Houdini 21 is a massive release. For the feature-hungry among us, the highlights include a fully matured APEX; a refined and clever animation and rigging framework; a simulating Copernicus (think Substance on Dope), and in the VFX realm, the production-ready MPM Solver. On top of that, we’re seeing machine learning tools popping up in all the right places (AI for people who don’t expect a Pixar film from a single click), faster and expanded rendering with Karma, and a healthy dose of quality-of-life improvements.

Since our editorial cat can only count to 300, we can’t tell you the exact number of new or improved features, but we’re impressed nonetheless. And soon, you will be too. To avoid overwhelming both writer and reader, we’re breaking this article into a mini-series. We’ll start with VFX & Geometry, followed by Solaris & Karma, Copernicus & Terrain, and the massive Animation & Rigging tools.

MPM

One of the most exciting additions in H20.5 was without question the MPM Solver. The MaterialPointMethod truly allows you to simulate a wide range of different materials. From water, snow, and sand to honey, metal, and concrete, all within a single Solver setup. The geometry is simply substituted by points or particles, which are then simulated. The different materials interact physically accurate and constraint-free, purely based on their assigned parameters.

The initial release was already impressive, but it left users standing somewhat in the simulated rain when asking: “How do I get a proper mesh with UVs?” That exact issue has now been beautifully solved in H21. Any MPM simulation, whether rigid body or fluid, can now be meshed (as polygons or SDF volumes), including UVs, color, and other attributes, using no more than two nodes.

A nice and usefull addition to this workflow is the MPM Debris node, which generates new points along fracture lines as sources for smoke, dirt, or secondary debris effects. So let’s take a look at meshing hard and fluid or granular surfaces across a few setups and scenarios and wrap things up with a creamed cookies drink while watching the official and very excellent MPM demo.

Surfacing MPM Simulations

Testing time! For this test setup, we’ll have a clay ball smash into a vase model, paying close attention to UV transfer and the generation of smaller fragments through the Debris Source. The easiest way to start an MPM simulation is by typing “MPM Configure” into the node search. This gives you a complete set of starter nodes right away. (Under MPM Configure, you’ll also find plenty of additional example setups for study or creative repurposing.) By the way, the MPM container on the far right controls the overall resolution of the entire simulation.

We replace the default sphere with our own model and can now assign materials directly inside the mpmSource node and tweak them to our liking. It’s genuinely fun. Feels a bit like a mini-game. Since a concrete material would be more realistic but also quite boring as a vase material, we went with Chunky Snow instead. The environment comes in via an Object Merge directly into the mpmCollider Sop, ready to go. Our clay ball, the antagonist of this little simulation, isn’t a collider per definition but another mpmSource ready to be smashed, merged with the vase and given its own material behavior, Chunk Soil.

To make sure the particles can actually see and “love” each other, we need to enable Particle-Level Collision in the solver. The new Auto Sleep feature helps keep the vase passive until the collision happens, preventing it from collapsing at frame one and saving quite a bit of compute time.

Since the clay ball will be meshed as a fluid and granular surface and the vase as a rigid object, we first separate the MPM particles using a Blast node, filtering them by their respective source names.

For surfacing the vase, we use the mpmPostFracture node, which takes the rest-geometry and the MPM particles as input. This node essentially breaks the geometry apart “end to start,” so it needs to be fed the final frame of the simulation. After that, we choose either Voronoi or Boolean Cut as the fracture method. The latter can generate interior details, subtle irregularities on the inner faces of the fracture, that weren’t visible before, and it’s also faster to compute. We can further control the number of pieces as well as define the minimum fragment size at which new pieces should be generated.

The final node in the chain is mpmDeformPieces, which transfers the newly generated fracture geometry onto the MPM particles and just like that, the vase shards, physically convinced they’re made of snow, go flying through the scene, complete with perfectly intact UVs. For more of a muddy mess, we could have generated a liquid or granular surface instead, but we’ll save that for the clay ball. The result from the Debris Source, which lets you precisely define when and where particles based on fracture are emitted, is then passed into a POP network, including collisions from the vase and background).

Time to get serious:

Continuos Emissions & Surface Tension

With this new option, you can quickly fill containers, simulate expanding materials, or layer different materials on top of each other. The option is located in the mpmource node and spreads new particles apart using positive pressure.

Let’s take our vase and let a thick, viscous something ooze out of it. A good chance to show how simple MPM can be: if we want things to float inside the fluid, they just need a lower density. A few cubes are generated and assigned a jelly material. Two geometries, two MPM Sources, merged and fed into the solver. That’s all it takes. Just as easily, you can mix different fluids within the same setup. And for a bit more drama, we can dive into the solver and add a POP Wind node with some turbulence.

Surface tension allows for realistic effects such as droplets, tendrils, and flowing water. H21 introduces two new ways to control surface tension for both liquid and viscous materials inside the MPM Solver. The Point Based method offers higher accuracy and stability, making it ideal for small and detailed simulations. The Grid Based method, on the other hand, is optimized for performance and handles millions of particles more efficiently, which makes it better suited for large-scale scenes. External forces and friction can be increased if objects keep moving when they shouldn’t. Otherwise, you might end up with a scene straight out of Terminator 2.

To achieve high levels of detail without an unnecessarily large number of simulation points, the new, more precise collision detection allows you to use the fracture edges of a simulation as the source for a targeted secondary simulation. The attribute Jp (Plastic Compression/Stretching) is key here. It can be used to isolate the fractured areas and feed them into a Surfacing node set to VDB mode. This resulting volume can then serve as the source for the second simulation. And don’t forget to use the main simulation result as a collider.

And finally to top it off, the official demo. A detailed breakdown of that beautiful cookie shot.

Machine Learning in Dynamics

You won’t find any generative AI native in Houdini, but rather a growing collection of smart, locally running models, often trained by yourself, designed to simplify or speed up time-consuming tasks.

Surfacing Flip, Vellum & Particle Simulations

Alongside Neural Point Surfacing for MPM, the new Neural Point Surface and proven Particle Fluid Surface nodes now bring neural meshing to FLIP, Vellum, and POP simulations as well. Until now a bunch of points are trying to reconstruct the surface of a material. With neural meshing, you can now achieve much sharper, more detailed surfaces across a both high and low frequencies. The result: surfaces that are no longer uniformly fuzzy, but crisp, structured, and temporally stable. As before, you can train your own models, but even the included presets already produce finer details. And thankfully, the whole thing is GPU-accelerated.

Volume Upres

The core problem behind volume up-resing: for efficiency, artists often create and approve low-resolution simulations. But once the voxeldensity is increased, the overall shape of the sim tends to change. With the new tools, a low-res simulation can now be upscaled while preserving its exact shape. This not only keeps previously approved versions intact, but also allows for far more iterations. A model that’s been trained on a specific motion or behavior can now upscale multiple variations of it.

The Billowy Smoke recipe (or shelf tool) comes with a pretrained up-res model already integrated. Let’s start by looking at a comparison between the low-res input simulation and the 3× up-res result.

Details are nicely added, while the overall shape is preserved impressively well. Caching took a bit of time, but it’s still far faster than running a full high-res simulation. The real idea, however, is that we can now reuse this up-res model for all our future Billowy Smoke setups and honestly, we probably should. So, let’s quickly modify the setup and see if we can break the upscaler.

This time, the solver runs at a voxel size of 0.05, using the 2× upscaler. The 3× model didn’t really add more detail, just extra waiting time. For a bit more fun, a Gas Wind with random direction and a collision shape were added. That collision shape, as it turns out, gives the upscaler a bit of trouble as seen below.

But when comparing the up-res result to a true high-res sim, it’s clear that the system is really good at preserving the base form. Doubling the voxel size in the high-res sim, on the other hand, changes the overall shape and eats up a ton of time but stays artifact-free. Or, if you really want perfection, you could just train a model specifically for this type of collision.

If you want to train your own model, this Equinox Hive talk walks you through every detail:

Zibra AI VDB compression

With this plugin you can save up to 99 percent of storage space when caching VDB simulations, which makes it perfectly suited for use in real-time engines such as Unreal Engine 5. The Zibra toolset, distributed via SideFX Labs, provides three dedicated nodes.

The first, zibravdb_compress, writes and exports .zibravdb files for use in Unreal and similar environments. The second, zibravdb_decompress, brings those files back into Houdini. And finally, zibravdb_filecache acts as a modified File Cache node that automatically handles compression, loading, and decompression for further use inside Houdini. Before diving in, you’ll need to download the model and obtain a license, potentially a free personal one if your revenue is below 100 K USD. The license management can be accessed directly from any of the three nodes.

For a quick benchmark, I used the Fireball Recipe and cached one regular VDB sequence alongside two Zibra versions with different quality settings. The original VDB sequence weighed 294 MB. The Zibra compression at a quality setting of 0.2 came in at only 5 MB, roughly 98 percent smaller. At a quality setting of 0.9, the result visually matched the original VDB almost perfectly while staying at just 36 MB, around 88 percent less.
That insane low file size at 0.2 naturally comes at the cost of lost detail, as visible in the comparison graph below. Still, the results are impressive and they open up the possibility for bringing volumetric simulations into real-time pipelines far more efficiently than before.

Pyro Shelve Tool Presets

Another way to get artists up to speed faster are production-ready presets, not just educational examples, but tools meant to be customized for your very real projects. Each of them comes with a ready-to-use Solaris network, fully set up for rendering straight out of the box. Even better, the Help section now includes a short guide and exploanation of important Nodes for every preset.

SideFX strikes a noticeably new tone here, aiming to flatten the learning curve rather than overwhelming newcomers with endless options (which, to be fair, they still do from time to time). These guides can be found under Documentation → What’s New → Pyro. In this section, we’ll take a closer look at three fundamentally different presets, each showcasing its own approach and creative use case.

Stylized Flame

With the refined Copernicus toolset, entirely new worlds open up: stylized fire based on a classic Pyro simulation, right inside Houdini. And if needed, even live-rendered in Solaris.

To put the claim of “easy adaptability” to the test, we took the Pyro Fireball preset and gave it a Toon-style makeover. Adding the VDB field “Flame” inside the solver’s output was all it took to make it work. The output from the Cop node, by the way, can be merged directly into the scene for further Houdini style editing.

Ground Explosion B

This shelf tool sets up a sparse pyro simulation featuring a large-scale explosion, smoke trails, and a shockwave. For more control and efficiency, it’s actually made up of two separate simulations, layered on top of each other and interacting through their velocity fields.

Candle Flame

A candle flame might not be the most exciting thing visually, but it’s one of those Pyro results you end up needing again and again. What makes this preset interesting, though, is the procedurally modeled candle that comes with it. Exploring that setup is almost more fun than the Pyro sim itself.

Thruster FX

In true H21 fashion and in the spirit of overall efficiency boosts, the new Thruster FX tool makes its debut: a setup designed to create engine and propulsion emissions with ease. It’s not just a new node, but rather a complete Recipe, a preconfigured network of nodes that some might, in hushed tones, simply call “presets.”

With a cheerful click on Thruster Exhaust in the Pyro Shelf Tools (or via Configure Thruster in the Tab menu), you’ll get a fully adaptable node tree, including a ready-to-render Solaris network. The effect itself isn’t a simulation but a cleverly layered, art-directable procedural system built around VOP Nodes. Multiple pyrothrusterexhaust nodes are stacked in layers, each responsible for different components like sparks, fire, and plasma. All working together to form a surprisingly easy to use thruster system.

So, what does it actually look like? And can it really be used straight out of the box, as promised? The short answer: pretty much, yes. The rendering comes surprisingly close to the viewport preview. To get it running, only a few connections inside the included Solaris network needed to be adjusted. For our small test scene, we did a bit of kitbashing inside Solaris, then added some glow and polish in Fusion.

Let’s take a closer look at the node, both from the outside and under the hood. The node expects a primitive as input, and a simple circle usually does the trick. It outputs both particles and a volume containing density and temperature fields. In the General tab, you can control speed, length, and the overall shape via a spline ramp. The Exhaust section handles the color ramp and lets you tweak the underlying noise pattern, which has a strong impact on the overall form. Under the hood, the node generates a VDB from Polygon, then modifies the result with a Volume VOP and a Volume Adjust Fog node.

As part of the ongoing effort to simplify things and lower the learning curve, SideFX has also released a good and detailed tutorial mini series: sidefx.com/tutorials/how-to-create-thruster-fx

Car Destruction FX

So that we can also crash the rigs built with the Car Rig SOP introduced in H20.5, Houdini 21 brings us the new Car Destruction Tools, led by the mighty RBD Car Fracture SOP, supported by the RBD Car Transform SOP. The first one takes care of fracturing and constraint creation, automatically handling the typical materials you’d expect in a vehicle: glass, metal, wood, and rubber. The RBD Car Transform SOP, similar to Transform Pieces, ensures that all pre-fractured parts are efficiently transformed based on the simulation points. You’re not limited to cars, by the way. Anything that follows the same basic logic can be blown apart. From motorcycles to helicopters, it all breaks just fine.

Destruction-hungry artists will find a detailed yet easy-to-follow example scene in the SideFX Content Library, the same visuals you might recognize from the keynote: sidefx.com/carbd-dual-car-collision/. A fitting go-through video can be found here:

Geometry, Viewport and other tasty QoL

Coming from its deep VFX roots, Houdini has taken quite a journey to establish its own distinct style of procedural modeling. With H21, that journey continues, extending existing nodes and adding a few genuinely useful new ones along the way. This time, even the viewport got some well-deserved love, now powered by Vulkan and capable of loading Gaussian Splats directly.

Sculpting in Time

The Sculpt SOP, introduced in H20.5 and (surprisingly) quite useful, now gets a genuinely groundbreaking new feature called Shot Sculpting allowing time-based, keyframe-free sculpting. Originally intended as a correction tool for character animation, the node turns out to be just as handy for VFX and motion design work.

Temporal control is handled through the Shot Sculpt panel, which at first glance looks a lot like an NLE timeline and, in principle, works much the same way. Sculpting can be organized into layers that can be offset in time, faded in and out (complete with easing), muted, or adjusted in opacity. Alternatively, you can use mask_track to paint time-based attributes, which can then be passed downstream and used in other nodes, for an obvious example, as masks.

Otherwise, the same rules apply as for the regular Sculpt SOP, whose updates we’ll take a look at next. In line with the new Shot Sculpting feature, the mask system has been reworked. Masks can still be painted manually, but can now also be loaded from an upstream float attribute, saved permanently, and blurred or sharpened as needed.

There are also new brushes. My personal highlight, the Elastic Grab brush:

Of course, the complexity and depth of ZBrush remain unmatched, but for many tasks, artists can now comfortably stay right inside Houdini.

Geometry Masks

There are also updates when it comes to masking. Several well-known nodes now include a Mask parameter, allowing the effect to be restricted to a painted or procedurally generated mask. Among them: Peak SOP, Soft Peak SOP, Inflate SOP, Flatten SOP, and Point Jitter SOP.

UV Flatten from Points

The latest addition to Houdini’s already powerful UV toolset could just as well be called “UV from Voronoi” since that’s exactly what it’s based on. The node distributes random or precisely placed points across the surface and uses them to calculate clean, non-overlapping UVs. It’s primarily designed for complex, high-resolution meshes, where traditional unwrapping tends to get messy fast.

Vulkan Viewport

Now enabled by default, the new Vulkan 3D viewport offers noticeably improved lighting, Ambient Occlusion, shading and ray tracing with built-in denoising, and a more accurate texture display though performance can take a hit if you push it too far. New worklights including a fully adjustable Dome Light, Physical Sky, and Three-Point Light setup now serve as the default viewport lighting.

Looking toward the future, the viewport can now display Gaussian Splats directly. Since splats are essentially just point clouds, and Houdini is fundamentally point-based, this opens up a rather promising combination. The .ply file can simply be loaded via a File SOP and passed into a Bake Splat SOP for further processing. From there, you can treat and manipulate the splats just like any other geometry using the usual SOP tools. More on rendering those Splats in the upcoming section on Solaris & Karma.

Curve Tools

The new Extract Contours SOP can generate object outlines from a camera’s perspective either directly as edges or as an edge group. Quite handy for toon-style effects.

The well-known Curve SOP now allows you to interactively split points into branches (with unique vertex numbers) or fuse them back together.

Unsubdivide

If things ever get a bit too much, this node can reconstruct a low-res input geometry based on Catmull-Clark.

Conclusion after some bottles of VFX

Even though the stated (and achieved) goal of H21 was mainly polishing existing systems and adding plenty of quality-of-life improvements, it still manages to sneak in a massive load of new features along the way. And we’ve only scratched the surface here. Deep dives on Copernicus, Solaris, Karma, Rigging, and Animation are already in the works.

What’s also refreshing is the ongoing effort to flatten the learning curve through better documentation, tons of in-house tutorials, and solid example files in the Content Library. Many things have become easier or let’s say, more accessible, without losing depth, at least for those who want to go there. As always, most nodes can still be cracked open and modified at their core. Nice one, SideFX.

The post Houdini 21: Like good wine (Part1, VFX & Geo) first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

We had the pleasure of talking to Simon Hall from Blackmagic Design about Fusion, AI and the community. Simon Hall knows post-production from both sides of the suite. Before stepping into his current role in business development at Blackmagic Design—where he focuses on post-production and supports the Resolve ecosystem across EMEA—he spent over a decade getting his hands dirty in the edit bay.

Starting as an offline editor and later working as a Smoke operator in a northern UK studio, Simon eventually moved to London to take up a training role—merging his technical know-how with a knack for sharing knowledge. His past as a freelance editor kept him close to the tools, even as his focus shifted to product strategy. Over the past ten years, he’s been a key figure in shaping DaVinci Resolve’s growth from a specialist grading tool to a full-fledged post-production platform with a massive user base.

DP: Fusion 20 marks a huge step forward, and the community has been very enthusiastic. What was the motivation behind this release, and what can users look forward to in future updates?

Simon Hall: We are a company that really does value user feedback. What the devs always want to do is to take user ideas and integrate into the software. As you can imagine, those lists tend to be very long. SO we have to pick and choose what we do. Our motivation as a company is to give people the features and workflows they want. We will continue to try to get the best out of our software. Because we like making people happy at the end of the day.

DP: The Integration in Resolve was a great idea – as it was to keep the Standalone Edition alive which is favoured by many professionals for performance reasons. Can we expect full feature parity (i.e. all Resolve OFX plugins available in the standalone Fusion)?

Simon Hall: Some of the open effects are obviously designed for colour. So that’s why you may not find them in fusion studio. But the devs try and get parity as much as they can. Over time, what will happen is hopefully we’ll start to get parity between the two applications. The open effects that are available in resolve are then also available in fusion.

DP: When you’re developing both editions, is there an ideal use case in your mind for when users should use each version?

Simon Hall: If you’re doing things like shot clean-ups, you’re doing some matte painting, you’re doing some tracking, my recommended workflow is to use fusion in resolve.
I always tend to steer people towards fusion studio when you’re doing sort of heavy VFX work – You’ve got a couple of hundred nodes, you’ve got 3d models, you’ve got particle generators. As soon as you start to do something that becomes quite complex, you’re going to get performance enhancements in fusion studio. The one thing that fusion studio can do that resolve can’t, is to use network rendering.

DP: Both Resolve and Fusion include very useful ML tools like the Magic Mask. What’s next on your roadmap for neural-network features? Any change to see an integration with tools like ComfyUI? What is Blackmagic Design’s long-term vision for applying machine learning across the industry?

I could talk about what we’re thinking, but the truth is-we don’t really know. There’s no set roadmap. That’s just kind of how things work at Blackmagic. We don’t always know what’s coming. Our approach to AI is focused on speeding up workflows-not replacing the person in the chair. That’s the goal behind all the AI we’ve built so far. Also at the moment all of our AI processing happens locally-on your system.

We don’t send your files anywhere to train the AI.

There is one exception, and that’s the scene extension feature. It’s not in the public beta yet, partly because it uses Blackmagic Cloud. Since the system needs to understand the image, it does have to send it up to the cloud for processing. We’re still figuring out how that will work, especially in terms of using it with a cloud account, which may involve some cost. Our AI is meant to help-not take over. So when it comes to the kind of AI that generates full scenes or content, like the comfy UI stuff, I could be wrong, but I don’t see us going in that direction.

DP: The community loves that Blackmagic hasn’t adopted a subscription model—but new features still cost money to develop. Are there any plans to introduce an upgrade-pricing scheme in future releases?

Simon Hall: Potentially in the future, we might charge for upgrades. A lot of this software development takes time, money, and people-we’ve got a growing team of developers. But I don’t think this is going to turn into a subscription. Grant himself really doesn’t like the idea of locking people out of their own work; he thinks it’s unfair. Long-term, yeah, we want to make things sustainable, but nothing’s been decided yet.

It kind of became a hot topic at NAB because Grant mentioned it in his video. What surprised us was how many people actually supported it-people who really want Resolve and Fusion to keep developing and improving. And if that means maybe paying, say, a $50 update once a year, or per version, a lot of folks were like, “Yeah, you know what? I’d be fine with that.” Especially considering we’ve never really charged for updates before.

DP: You surely know the Fusion Forum WSL/Steak underwater. Do you incorporate feedback from the user community into your ongoing development?
Simon Hall: Yes, absolutely. And yeah, great name-“We Suck Less.” The Fusion community there is full of really smart people writing macros, scripts, all sorts of things. A lot of our product specialists are on that forum. I don’t know if you know Steve Roberts-he was one of the original guys behind Eyeon. When we acquired Fusion from Eyeon, Steve came over with it, since it was basically his baby. He’s still a member of the forum and still checks in. We all do, really. I’ve even picked up scripts from there.

There’s one I use all the time-it animates to the beat of music by analysing the audio. I use it constantly, though I’ve forgotten what it’s called. So yeah, we’re definitely across that forum. And when people post feedback or feature requests there, the developers do take a look-just like we do across other forums-to see what the community is talking about and what they’re asking for.

DP: Is there one feature you’d most like to add or change for yourself?
Simon Hall: Yeah, one thing I’d really like to see in Fusion 20 is a bit more “smart assistance” when building node trees-especially in 3D scenes. Sometimes I’ll go to connect something, like a camera, and it just doesn’t work. Then I realize I’ve missed a node-maybe I forgot to add a 3D plane or something in between.

What I’d love is if Fusion could recognize that kind of situation. Like, if I try to connect two nodes, and it doesn’t work, the system could say, “You’re probably trying to do this,” and automatically drop in the missing node-like a 3D merge or a plane-so the connection makes sense.

Basically, a bit of smart logic that fills in the gaps when I miss something. That would really help, especially when working quickly. So yeah, that would be my feature request-something like a smart assistant that helps you build the flow correctly when it sees what you’re trying to do.

DP: Do you have a favourite movie (or specific shot) that was created using Fusion?

Simon Hall: Oh, there are quite a few-especially if we’re talking old-school Fusion. One of my favourite shots was in the film Swordfish. It’s about hacking, with a young Hugh Jackman and John Travolta. The opening shot, where someone’s left a claymore mine and the camera moves through the explosion in what looks like a frozen moment-that whole sequence was done in Fusion. That was back in the Eyeon Fusion days, and I always thought it was a fascinating use of the tool.

In more recent films, there are a few standouts. The Martian used Fusion heavily, and Top Gun: Maverick-which has been one of my favourite films in the last few years-used it for a lot of shot cleanups. The grading on that was done in Resolve. There’s also a TV show called Bosch on Amazon Prime. It’s been one of my favourite series for a while. Fusion was used extensively on that as well-for scene extensions, keying, and shot clean-up. So yeah, those are some of the highlights for me.

DP: Thanks for your time, Simon :)

The post The (further) development of Fusion. first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

We first take a close look at the new functions and then test various workflows in general. As a special treat we have an interview with Simon Hall from Blackmagic Design about the development of Fusion – which you can read very soon. Stay tuned! But now, let’s start up Fusion and see what’s what.

Native support for Cryptomatte

Or the “compositor’s lifesaver” – with a cryptomatte, complex masks can be created quickly and easily from all objects or materials present in a 3D scene. The only prerequisite for this is that Cryptomattes are included when the 3D scene is rendered. Manual object selection or ID assignment is not necessary.

The Cryptonode itself presents these masks as extremely colourful surfaces that can be selected with a simple click and converted into an alpha channel. The mattes can be combined as required and removed again from a simple list view. Complex adjustments such as the colour grading of objects in the blur can be implemented quickly with cryptomattes, although they can also reach their limits here (we will look at a workaround for this special case later in the chapter on multilayers).

USD & 3D compositing

Let’s stick with this example. Suppose we want to make the light a little more dramatic or add particle FX or text in the room or or or or … Here, in addition to the possibility of masking things to infinity, the fantastic (real) 3D space of Fusion comes into play, which can be fed with all kinds of data from FBX to USD. Let’s take a look at the updated USD workflow.

The USD file generated by Houdini Solaris is simply dragged and dropped into Fusion and is then loaded and ready for use. Incidentally, the 3D space opens automatically as soon as a 3D object is to be displayed on one of the viewers (shortcut “1” or “2”).

To make the rear lion’s head a little brighter, we can now add a USD light and illuminate the head as desired. As we are working with real 3D data, the light is modulated correctly, which is a huge advantage over working with conventional masks. To avoid potentially disturbing influences on other objects, these are faded out using uVisibility. A newly added 3D layer acts as a light blocker to allow the light to flow gently downwards. Finally, this black and white image generated by a uRender Node is added directly over our original rendering – or better, used as a mask for a colour corrector.

3D text can be added in a similarly simple way, and parts of Fusion’s proprietary 3D system can be integrated into the USD Scene – as is the case with a Text3D Node. Particularly nice: If a Z-channel is also output via uRender, Fusion can perform a so-called depth merge, in which the merge node automatically “masks” the objects in the correct order using the Z-channel.

To round off the trip, we export the whole fun as USD and load the file back into Houdini as a sublayer and can access the new light and the Lightblocker here.

What we would like to see in a future update: A USD stage manager and more Hydra delegates aka render engines that support Fusion.

An alternative to relighting via 3D is the relatively new relight node, which uses a rendered or calculated normal map. This is practical if you don’t have a 3D scene to hand and can do without precision.

(Real)Deep Compositing

Deep compositing is a brand-new feature in Fusion for intervening deeply in the image – and completely without 3D. Here, the pixels are also given depth values during rendering so that Fusion now knows where these pixels are located in 3D space.
The decisive advantages are mask- and Z-channel-free merging of objects and the creation of real depth position-based masks (the above-mentioned depth merge accesses a Z-channel, a 2D representation of the depth in space), which, in contrast to the volume mask (which accesses the world position), are very precise and virtually free of edge problems. Volumes such as smoke and explosions can also be handled wonderfully, as objects can interact correctly with volumes. The new freedom comes at the price of larger data volumes and necessarily a render engine that supports deep data (e.g. Karma, Vray, Arnold, Octane, Renderman and Redshift).

But right from the start – how do we even know that we are dealing with deep rendering? Fusion writes “deep” + colour depth after the resolution in the viewer and shows a cheerful “Z” in the channel selection (not multilayer selection).

The new node “DeeptoPoints” then shows the whole truth – as a point cloud. We do not see “haptic” 3D objects, but the distribution of individual image pixels in space.

Let’s assume we now want to mount a fireball behind the lion heads. In “normal” compositing, volumes (explosions, smoke …) are a guarantee for alpha channel problems – not so in deep compositing.

Above: The delivered explosive DeepEXR rendering (via Karma) and the Deep2Points view – the explosion has an actual volume of points, which will be very useful to us in a moment. The two deep renderings are merged using dMerge Node – and automatically know which elements should be in the foreground thanks to the 3D depth information they contain.

The fireball can even be moved in depth using dTransform and is automatically covered by the corresponding objects – or even partially covers other elements.

To bring new 2D elements into the deep space, there is the Image2Deep node, which is attached behind all possible 2D nodes such as graphics, footage and renderings. The result is then available in the deepcomp, but of course remains flat itself.
For example, texts can be perfectly integrated into the fireball. Partially concealed, without a mask and the resulting alpha problems.

The final DeepNode is called Deep2Image and brings the deepcomp into the classic 2D space for further processing or output. We have the fireball, but the right reflections are still missing. Let’s take a look at the brand new EXR multilayer workflow.

EXR Multilayer Workflow

For the greatest possible flexibility in compositing CGI renderings, other helpful render layers such as masks, reflections, depth, separate lights and world position are added alongside the actual beauty pass (“the image”), which then allow a number of far-reaching adjustments to be made in compositing.
For reasons of clarity and working speed, these passes, which can be imagined as Photoshop layers, are not rendered separately as individual file sequences, but in a multilayer ERX sequence. This is then split up in compositing – which was also possible in principle in the past, but was very cumbersome.

For Fusion 20, Blackmagic has revised the entire AOV / multilayer system and created a very fast workflow. The first major innovation is the layer dropdown in the viewer, which can be used to view all the layers contained in the EXR or PSD (shortcut: pageUp/Down) – to simplify things, we are using a rendering here that already has the fireball integrated.

At first glance, there does not appear to be an equivalent to Nuke’s shuffle node for extracting the AOVs. However, to get to the individual layers, we can simply use … any node. For the sake of clarity, we use the ChannelBool node, which can generally be used to swap image channels.
(Update with Beta 4: Blackmagic added a Node called Swizzler which acts more like the shuffle node.)

Below on the left viewer we have only extracted the effects of the AOV rimlight on the reflections (LPE rendered from Karma) using Setting > Backgroundlayer and then made them brighter using a ColourCorrector.

In order to return these to the actual image, we must first remove the rimlight present in the beauty pass, otherwise it will be calculated twice. To do this, we can use the newer Multimerge Node, which allows us to process different layers with different mathematical operations. The layer called “Difference” removes the original rimlight, while the “Add Rim” Layer adds the new processed light using Alphagain = 0 (which is the same as the Nuke plus operation).

Caution: The title “Layerlist” only refers to the sequence in the merge node, not to the EXR layers/AOVs themselves.

As the nodes can access the AOVs directly, nothing needs to be extracted for simpler operations such as a Hueshift. The colour corrector can access the layer directly, in this case the emission pass. The rest happens as usual, a merge removes the previous emission pass, a second merge adds the new, blue-coloured pass.

Further application examples: The books on the left are too shiny? Simply subtract the reflection layer (limited to the books by crypto)!

To give only the explosion a glow, the “DirectEmission” pass can be selected directly in the X-Glow Node as an area mask. Last but not least, we add a camera blur using fresh air Depth of Field. Conveniently, the depth map can also be read directly from the stream here.

By the way, if you want to add new layers to the flow, you can do this with the LayerMux node. LayerRegex allows layers to be removed or renamed. The new workflow not only supports EXR, but also Photoshop layers.

What about ML?

Blackmagic has always been well positioned when it comes to machine learning tools. First and foremost the extremely practical Magic Mask, which can significantly speed up rotoscoping tasks. Version 2.0 is already integrated in Resolve 20, while Fusion still has to make do with version 1.0 in the current beta.

In the Magic Mask Node, lines are simply drawn on a reference frame over the objects to be masked and then tracked. The mask itself can be refined or blurred using the “Matte” tab. As the whole operation is quite computationally intensive, the result is best cached (by right-clicking on the node).

To whet your appetite, let’s take a look at the new version, which has been simplified and improved in terms of precision. With our woolly friend, 2 clicks instead of strokes (the sun collector is precisely recognised as a separate object) are enough to create the mask. After tracking, a temporally stable mask is ready for use.

Intellitracker

Another well-functioning machine-learning tool is the Intellitracker, which copes well with even the most jagged movements such as that of this flower in the wind – as can be seen from the movement path aka the green wild line. The Intellitracker is the new default tracker and is automatically selected as soon as the tracking node is called up.

It is usually not necessary to do more than move the tracker to the desired area and press “Track Forward then Reverse”. The tracker automatically selects the most appropriate colour channel, in this case the red channel (see bar chart below the tracker list). In this case, the text was not attached directly to the tracker. A downstream transform node, whose coordinates are linked to the tracker position, offers the flexibility to position the text anywhere in the image. The tracking path can be adjusted directly in the viewport frame by frame like a normal spline or in the Spline(Curve) Editor.

Let’s continue tracking, even without ML tools – with the Surface Tracker. This practical node is able to track intrinsically deforming objects such as clothing, newspapers or flower petals in the wind with a kind of fine grid and transfer the movement of the individual points to any graphics or text so that they follow the complex deformation. In this example, the text was only positioned on a reference frame using classic gridwarp; all other deformations are handled by the surface tracker.

For the sake of completeness, the planar tracker should also be mentioned – neither new nor ML, but tried and tested and easy to use: draw a spline around the area to be tracked, set the operation to e.g. Cornerpin, adjust to the area and define the new insert as the tracker foreground.

Multitext

One node to … surprise them all with beautiful typography. You can think of this innovation a bit like any number of classic text layers, with all the trimmings: transparencies, transitions, extensive typographical settings such as (manual) kerning, modifiers (more on this in a few staggered lines). This was also possible in the past, but a separate node was required for each text element. However, the dynamic frame and circle text familiar from DTP has never been available.

To quickly create procedural animations, you can of course write expressions (more on this later) and link parameters, but you can also add a modifier to the respective parameters by right-clicking and thus quickly create procedural effects such as random movement (wiggle sends its regards).

The modifiers are not just limited to the text node, but can be applied to almost all parameters in almost all nodes (and also linked to each other). For example, a master random modifier can control the opacity of different merge nodes at the same time.

The modifier “Follower”, responsible for “character-by-character” animation, is exciting for moving typographers. This allows you to animate letter by letter in opacity, colour, size, etc. – not only in 2D, but also in 3D, as Fusion has an extensive 3D text node, including bevel and extrude.

Shape Tools

Primarily intended for motion graphics, the Shape Tools are characterised by a vector-like workflow. In contrast to the other 2D systems from Fusion, they are basically resolution-independent and are only cast in pixels using a shape render node.

With the shape tools, various basic shapes and paths can be drawn, combined, duplicated, created as a grid and, of course, animated. Linking individual parameters with the above-mentioned modifiers offers great possibilities. The jitter node ensures random movements. For even more control (or chaos), the shape can be instantiated directly on a particle system.

Expressions

Many motion (and VFX) tasks can be significantly accelerated or automated with simple expressions. To access the expression editor, simply right-click on the relevant parameter field > Expression. For example, as the simplest of all possibilities, values can be changed by the pure passage of time(value “Time”) or linked and nested in complex ways. Parameters can be linked interactively using the small “+” icon.

You can find more examples here:
https://www.steakunderwater.com/VFXPedia/96.0.243.189/index4aa9.html?title=Simple_Expressions

Of masks and multipoly

The aim of the various ways of creating a mask is always the same – to create an alpha channel. Fusion is quite flexible in its use of masks, which are created using rectangles, ellipses, polygon splines or paint nodes. The individual masks can be easily combined, animated and attached to trackers. Individual mask points (if created by path) can be “published” and the parameters of other nodes can be linked to them. The bitmap node converts individual colour channels or the luminance of footage or graphics into masks (more precisely: into an alpha channel). Thanks to the new layer system, AOVs can now also be selected directly as masks here. Thanks to the node system, a mask can be reused or instantiated (copy>shift-v) as often as required.

A few examples:

Above: A simple vignette with ellipse mask node and strongly blurred mask edge aka softedge. In the right viewer the alpha channel of the mask.

Complex shapes are possible by linking individual mask nodes. Alternatively, the newer Multipoly tool can also be used for this, although this is limited to polygon and BSpline masks.

Quick and easy thanks to the new layer system: the blue channel of the AOV glossy transimission as a mask for a colour corrector. Connect the footage loader to the ColorCorrectNode as an input AND as a mask (blue input), set the effect mask layer to the desired AOV under Settings and select a channel under Channel if necessary.

A simple polygon mask in “DoublePoly” mode. The outer outline defines a soft edge gradient, which can be set in addition to the global “soft edge”.

Timesaver: The Multiframe option allows you to change mask points for all keyframes simultaneously – similar to Mocha’s Überkey.

Masks can of course also be drawn beautifully and even support graphic tablet pen pressure …

… and brushes such as this useful fish (available as a preset).

To track a mask, the mask centre can be linked to a tracker modifier. The actual mask path can then still be adjusted or even animated, as only the centre position of the node is actually attached to the tracker.

Particles

Fusion comes with a very powerful and intuitive native particle system. The setup is very simple: The basis for every ParticleFX is the pEmitter Node. As a starting point, it can assume various basic shapes, use 3D shapes (see text example above) or an image input (see crypto example above) and the pRenderNode, which displays our particle system either in 3D space or as 2D pixels.

The particles created in this way can now be subjected to various forces, e.g. the extremely popular turbulence. The effect strength can be set using a 3D mask (region), probability, particle groups or particle age.

Although the particles are not really simulated in comparison to Houdini, they can mimic many effects such as gravity and bouncing of objects

One of the most powerful nodes is the “replicate3D”, which can instantiate any 3D objects on the points and vary their size, rotation and position randomly.

ACES 2.0

Fusion 20 now supports ACES 2.0 & OCIO 2.4.2. Let’s take a look at what this looks like in practice.

The loaded rendering was created in ACEScg, which can be seen in the metadata (hotkey “V”, right-click and display metadata). The display is too dark without display transform.

The small raster icon (1) leads to the Display LUT/Transform menu. Here we select ACES Transform (2) and edit (3) the input & output transform (4) depending on the pipeline, here ACEScg in, sRGB Gamma 2.2 out.

Now we see the image correctly displayed in the viewers (but only displayed, the image itself is not sRGB!) and can continue to perform all operations in ACEScg.
For the final output as e.g. ProRes 4444, however, we have to apply these values via ACES Transform Node.

If you would like to work with AGX / Filmic and co, proceed as follows: Again via the ViewLut menu (1), this time select OCIO Display (2) and edit with the following settings (4). The conversion for the final output is carried out this time via the OCIO Colourspace or Ocio Display (!) node, with the same values as in the ViewLut. The necessary config comes this time from: https://github.com/Joegenco/PixelManager

So much for the application in Fusion. If you want to read more about ACES or argue about it, you can do the former here: https: //chrisbrejon.com/cg-cinematography/chapter-1-5-academy-color-encoding-system-aces

Vector Warp

The new vector tools are based on analysing the movement of the image pixels. Fusion knows what happens to which pixel and can therefore apply complex deformations or retouching quickly and usefully. Areas of application include digital make-up or the insertion of new objects.

The basic prerequisite is motion vectors, which can be supplied externally or generated via an optical flow node (cache without any need!).

To simply place new objects on the background, the new VectorWarp node in “Generate Warp Map” mode is sufficient. The deformed result is placed over the background again using the Merge Node.

For more complex retouching, the VectorWarp node can be set to “Unwarp” and “freezes” the object in time. In this way, objects can be retouched or new ones added using the Paint Node. The result then flows into a 2nd Vector Warp Node, which brings the image back into motion using “Generate Warp Map”.

Curve Warp

The warper previously only available in Fusion Reoslve can now also be controlled using curves. Simply draw a line or an outline, set limits if necessary and bring the object into the desired shape.

Node versioning

A very small and extremely practical function is the somewhat hidden versioning of a node. Up to 6 different settings can be saved to quickly try out different looks. These are not presets, but can be created as such by right-clicking on the node name and Save Settings.

Performance optimisation

Fusion offers various optimisation options to keep performance high despite complex effects and comps:

1. The render area selection (region of interest) limits the calculation to a selectable part of the image
2. Proxy mode reduces the preview resolution (click on the PRX button on the right for further options)
3. High Quality Preview and Motionblur can be switched off for faster previews
4. Framestep skips every frame and leads to faster previews (right click on the play icon for more options)
5. Cache to disc renders and saves the flow up to the selected node (right-click on the desired node)

Reactor

Reactor, which can be downloaded free of charge from the unofficial official Fusion forum, is the counterpart to Nukepedia and lets you install all kinds of macros, scripts and fuses, also commonly known as user-created plug-ins, directly from within Fusion. From exponential glows, edge blur and complete mograph solutions (Krokodove!), everything is included – including the Nuke2Fusion project, which bases shortcuts and settings on Nuke as far as possible.

Installation and instructions: https://www.steakunderwater.com/wesuckless/viewtopic.php?t=2159

Top nodes to try:
X-Glow for wonderful exponential glow
FTL tools for modular lens flares
Krokodove adds many motion graphics nodes to Fusion
OIDN denoiser to be able to use the Intel Open Image Denoiser directly in Fusion.

Last news but not least news: Fusion inside Resolve only: The option you have been waiting for since the integration in Resolve: You can now display the grading applied in the colour page in Fusion and set the start frame count independently of the footage.

Fusion Resolve (Studio) integrated vs. Fusion Studio Standalone

A quick look at the possible versions and versions of Fusion – the standalone is only (still) available as Studio and therefore costs just €355. However, for that money you not only get Fusion, but also Resolve Studio. Or vice versa.
The free Resolve version has Fusion integrated, but has to do without a few really practical Studio OpenFX such as Lens Blur, Termporal Denoise and the new Neural Engine FX such as Magic Mask II. For this reason, the Studio version is highly recommended, especially because it is a perpetual licence. No subscription. For Resolve Fusion. As you can see, it’s worth it.

If you don’t need the other Resolve tools for your current task, it’s better to use the standalone version for performance reasons – it’s simply faster and more flexible as it doesn’t have the Resolve overhead and also offers network rendering (with unlimited render clients). By the way: Before Blackmagic times Fusion alone cost around 2500 $ …

Conclusion

Fusion offers a powerful complete package for compositing / visual effects and also a lot of core power for motion graphics, if you can get involved with the NodeSystem and do without direct integration of Adobe Illustrator files. Working with the programme is fun and quick. The price of the programme is unbeatable, and Resolve Free is even free – just give it a try.

The beta is available immediately and can be downloaded from the Blackmagic website. A Resolve or Fusion dongle or key is required for operation. This is available as a one-off purchase for 355€ – as a perpetual licence.

The post Fusion 20: a deep look at the core first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

The compositing tool, which is integrated into Davinci Resolve or available as a standalone, is positioning itself more aggressively than ever as a cost-effective alternative between Nuke and After Effects as a one-stop shop for VFX and motion graphics. Whether integrated or standalone – the feature set is basically the same. Both versions bring exciting features that have been eagerly awaited for years.

Real deep image compositing

Blackmagic has been advertising on its website for years that deep pixel compositing is possible with Fusion, but what it really meant was the (admittedly extensive) possibilities of reading a world position pass and using it for all kinds of effects. Version 20 finally introduces real deep compositing, very similar to Nuke’s well-known toolset. This allows the depth data stored in the pixels to be read out and, for example, overlapping compositing or depth-based holdouts to be created without masks.

Shuffle something – the new multilayer workflow

By far the biggest obstacle when working with Fusion and CGI renderings was the lack of a proper EXR multilayer workflow. Technically, Fusion has always been able to laboriously extract AOV layers from an EXR by hand, which in practice was extremely cumbersome and time-consuming.

This agony is now history – Blackmagic is introducing a completely new workflow that perhaps even goes a little further than Nuke’s Shuffle Node – even if there is not yet a 1:1 equivalent. However, almost any node can take over this function – you can select which layer is to be displayed, processed or used as a mask.

For simpler adjustments, nothing needs to be “shuffled out”, you can stay in the flow with just a few nodes and merge the adjustments using multimerge. Otherwise, there is the option of extracting layers, subtracting them if necessary, processing them and adding them (back) as usual from Nuke using CHannel Bool Node, for example. In the viewer, all existing layers can also be selected and displayed via a new drop-down menu
and display them. The new workflow not only supports EXR, but also Photoshop layers.

Native Cryptomattes

The “Finally” category also includes the new Cryptomatte Node, which works very similarly to Nukes and replaces a previously required external plugin. This allows complex masks to be created quickly and easily from all objects in a 3D scene.

New Optical Flow Smart Vector Toolset

By analysing pixel movements, complex retouching of changing image content can be Image content easier to realise. Vector-Warp, -Denoise & -Transform are available.

Typography like never before

The new multitext tool offers the possibility to combine different text layers in just one node and for the first time offers the same functionality as in DTP programmes such as InDesign. Further updates include support for ACES 2.0. & OCIO 2.4.2 as well as the Filmlook Creator Node, which has made the leap from Resolve and offers various film emulators and lens effects. The Node search has been revised and can now be searched on a category basis. Fusion inside Resolve only: The option you have been waiting for since the integration in Resolve: You can now display the grading applied in the colour page in Fusion and set the start frame count independently of the footage.

In addition, the Warp Deformer can now also be controlled via Curves. The beta is available now and can be downloaded from the Blackmagic website. A Resolve or Fusion dongle or key is required for operation. This is available as a one-off purchase for around 300€ – as a lifetime licence with access to all future updates.

And the best comment from the Fusion forum WeSuckLess was by mattpf: The presentation was overwhelming. So much information. It was like asking for a drink of water and expecting a glass and getting blasted with a fire hose instead.

And if you want some files to play around with, there are sample projects on the BlackMagic Site for download (Right Column, under “What’s new in Fusion”). All these things are already in our lab, and get pelted with all the pixels we can find! Stay tuned to find out what’s what in the newest Fusion release.

A word on pricing

While the Resolve-Studio-Version is still at just below 300 US-Dollars (Local taxes apply), there is a “newer” price for Fusion standalone in the US, which comes in at 689 US-Dollars. So US-Users just should get the big Resolve licence. For the rest of the world, the price seems to be the same – for example, Germany is still showing 355€.

The post Blackmagic Fusion 20 first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

Who has no hands and cares about our health? Our pets, of course. Yes, really. Our intestinal health is the biggest concern of our loved ones (furry flatmates). Following this idea from Serviceplan Health and Life, the TVC was created for the Burda Foundation’s current bowel cancer prevention campaign. The task “in a nutshell”: How can a dog and a cat engage in a loving dialogue, form words without the appropriate biological prerequisites, express human emotions and still remain animals?

After initially examining possible implementation routes and styles and collecting references (from strange things from the depths of the internet to Disney remakes), the path of real-looking animals, which are likeable thanks to their respective character-driven acting, crystallised: a somewhat grumpy older man’s dog lives together with a charming cat, masterfully spoken by Jürgen Prochnow and Katja Burkard, rounded off by Sky Du Mont as the voice-over artist.

Before moving into 3D, the scripted storyboard was created as shots in Resolve. The rough mix previously created by the sound studio served as a timing reference. This was then used to create an animation layout in Solaris to define the camera angles and staging of the animals, which was gradually replaced by renderings later on in the process. But first a few steps back and to the fur.

From hedgehog to dog or: the grooming process

The grooming tools in Houdini – like everything else – offer different approaches to realising complex hair and fur structures and so the fluffy dog was created in a different way to the cat. This may be due to the fact that the rather short-haired dog was much easier to comb than the cat (take a look at a cat without fur, the ter has a completely different head shape), but it was also about maximising the learning effect and comparing different strategies. Right at the beginning, the path forks – all grooming SOPs in a separate node or the “official” path with the separation of guides, sim and hairgen with object level nodes?

The hair pipeline is basically the same: Manually drawn or procedurally generated guides are placed on a base mesh, deformed on an animated mesh, simulated if necessary (whiskers in the wind…) and finally serve as a source for the detailed (procedural) hair generation. This result can be cached wonderfully as USD/Alembic in a truckload of external hard drives. Alternatively, the last step can be skipped and the guides then serve as a source for the @Rendertime Hair-generating Hairprocedural LOP in Solaris.

So the dog follows the classic route: GuideGroom-Guidedeform/Sim-Hairgen. Select the mesh, click on GuideGroom and a hedgehog is ready. So that we can all still get to the dog, it is advisable to plan in advance: What hair types does the animal have? What is the flow/growth like? What kind of over-regions can the coat be roughly divided into?

Accordingly, various masks or attributes are painted onto the base mesh (or generated by the usual means), which are first relevant for guide generation and then later for all kinds of hairstyling manoeuvres, especially the density attribute. This means that the Guidegroom and Hairgen nodes not only know where hair should grow – the attribute can also be used in multiple ways, for example as the basis for the thickness of the hair. This means that the hair at the edges of the density map becomes gently thinner. The Guideadvect Node is a very quick way of defining the basic flow of the hair with the help of curves drawn on the mesh.

In the next step, the powerful but no longer procedural Guidegroom SOP node takes care of the fine adjustment. Hair lengths, special swirls and growth direction exceptions are sculpted interactively in the viewport. A more intuitive alternative to this is the fee-based Groombear plug-in, which allows much more fluid and complex work – be it faster creation and editing of hair masks or sculpting of HairClumps.

The “animation view” is also a dream to be able to paint guides in different poses/states of the base mesh. Once the guides have been moulded, they are fed into the Hairgen object. The main task of this node system is to give the individual zones their final look using various nodes such as Clump, Bend and various operations such as Length and Fuzz. Layering the effects is important here – the body fur, for example, is first divided into large but discreet clumps, which are then given several sub-clumps depending on the region. Later on in the nodetree, lively details such as flyaways are added – hair that goes against the general direction of growth and sticks out a little chaotically.

A great design aid here is the Guidemask Node, which generates a random selection of hairs or creates a gradient mask on the guides, for example, allowing clumping effects to be realised only in the direction of the hair tips. The masks can be created directly, painted or adapted and combined on the basis of existing masks. The process roughly follows the pattern of creating masks for specific body regions one after the other and then using these to control the operational nodes such as Clump, Fuzz or Bend.

The guide deform node comes into play to transfer the grooming created on the static mesh to the animation later on. At the right time, it is switched between the Guidegroom and Hairgen objects and sets the dog’s 1.2 million hairs and the cat’s 850,000 fur balls in motion. An accompanying node is the GuideSim, which performs a vellum (soft body) simulation at its core – gravity and wind effects send their regards.

The finished fur splendour, in the case of the dog, divided into three separate grooms for the body, head and whiskers, was imported directly into Solaris via SOP import for test purposes before caching. “Why Solaris”, some people will ask themselves – sometimes including me. Because Solaris can be an incredible toolset – until you run into bugs or strange processes.

The Solaris workflow

In Solaris you work with LOP nodes. By decoding this abbreviation in Lighting Operators, the true benefit of the system quickly becomes clear – built around USD, however, the true strength lies in iterative work with light, material and camera.designed as a separate context or workspace, the first step is to import the assets. Either from the OBJ context conveniently via scene or SOP import or – assuming asset planning and pipeline – via sublayer or asset reference as USD files. The latter requires more work initially, but rewards you with much better performing scenes. Conveniently, you can export geometry as USD from almost anywhere in Houdini or create more complex USD files with material and, if necessary, variants in a separate Solaris Nodetree using a Component Builder preset.

In-depth knowledge of USD is not necessary if you “only” want to put your scene in a nice light – it is sufficient to understand the hierarchical structure and the assignment of attributes and shaders to primitives (USD slang for all kinds of object types, not to be confused with faces in regular SOP. Can be defined in the OBJ context via group nodes, among other things).

USD and layers

You can do this – it’s really practical to load a central, finished asset of a dog with materials, but sitting statically in the rest pose, into each shot and only import the respective animation from the obj context and layer over it… But you don’t necessarily have to – if you don’t want to deal with USD, simply import everything from the OBJ context, add lights and shaders and use Solaris only as an advanced render area. For more complex set-ups, however, the question arises – if you have to cache in the OBJ area (hair!), why not do it in USD instead of Alembic?

After loading in the assets, the real fun begins – the continuous branching off of the nodetree in order to experiment non-destructively, incredibly quickly and flexibly with new light set-ups, camera settings or shaders. The approach is always camera-centric, i.e. the focal plane can be precisely set from the active camera view by clicking on the geometry.

Lights no longer have to be moved back and forth in the traditional way using Gizmo, but can be placed interactively using three modes: A click in “Diffuse” mode sets the light so that the desired area is illuminated by the diffuse reflection, “Specular” sets the specular highlight at the desired location and with “Shadow” the pivot is selected first and then the location where the shadow should fall. In addition, the light size, intensity and distance can be adjusted using shortcuts. The system is quick, intuitive and fun to use. Moving over an object while holding down the mouse button and studying the changing lighting effect live is an experience you won’t want to miss. At this point, the system is still independent of Render-Delegate, and many of the extended lighting functions (Spotlight, Focus) are also largely supported by most renderers or, like V-ray, these bring their own parameters with them.

Another highlight is the light mixer node. From intensity and colour temperature to solo mode, all set lights can be edited conveniently and centrally. Here, too, the Nodetree system invites you to experiment effortlessly with the use of parallel light mixers – simply switch off one node, restore the origin or duplicate and change it. With the Light Linker LOP, the effect of lights can be limited to individual objects, useful for an extra eye light, for example. So before we set the scene for the dog and cat with Solaris and V-ray, we quickly bring them to life with KineFX. And then cache the animated hair.

Rigging and animation with KineFX

First of all: although the new APEX system was already available at the start of the project and offers promising concepts, it is still in a noticeable beta phase and was therefore not used. The rigging and animation system KineFX, which was introduced in Houdini 18.5, was used, and its procedural workflow did not even scare away my old rigging enemy. The special thing about KineFX is that the system handles the geometry, the skeleton and the animation separately. The ingenious thing about it is that it sees the rig as (connected) points that can be manipulated with the entire arsenal of tools available in Houdini, from simple soft transforms to noises to all kinds of fun with VEX.

The workflow “in a nutshell”: A skeleton node is used to draw half a skeleton over the beagle in its remaining pose with the help of anatomical drawings or to set the joints. In addition to the bones and joints, the joints for the facial muscles and the eyetarget are already taken into account here. Orient Joints are used to rotate the joints to the correct angles. Skeleton Mirror mirrors the skeleton and renames the joints accordingly. BonecaptureLines and Tetembed provide a finely subdivided mesh with the necessary attributes to transfer the joint weightings to the original mesh using BoneCapturebiharmonic. This works very well right from the start, creative or technical weighting adjustments can then be made interactively using Capture Layer Paint.

This part of the geometry is now ready for animation. On the other side, the skeleton in the nodetree is split in two and provided with the rig pose node in which the actual animation takes place. To do this, the three streams, geometry, skeleton and rig pose animation are merged into a bone deform node, which analyses the movements and deforms the mesh accordingly. This very simple rig serves as the starting point for advanced functionalities such as Inverse Kinematics (IK), i.e. the backward-orientated movement of the joints. Put simply, instead of moving the paw from the shoulder joint by joint (FK), the paw is positioned directly and the remaining joints follow automatically. The tail can be switched back and forth between IK and FK and is kept in gentle motion procedurally with a simple sine function at the various joints (which are really just points with certain attributes!). This effect can in turn be varied in strength or completely deactivated using skeletonblend.

A wonderful and very time-saving function are the secondary motion nodes, which record a basic movement and apply bounce or overshoot to this joint. If the head moves, the ear automatically wobbles with a slight time delay. The secondary motion nodes can be chained, so that the tip of the ear wiggles a little later and more strongly than the rest of the ear.

Blendshapes are added on the geometry side. These can be created in all kinds of ways, the simplest of which is the EDIT node in conjunction with the sculpting tool of the Modeller plug-in. Instead of the classic blendshape nodes or the newer character blendshapes, an attribute wrangle with two VEX mini lines (see image) is recommended for performance reasons, but is not necessary – as is typical for Houdini, there are many roads to Rome. Animation then takes place one network level higher with previously set control shapes and sliders for the blend shapes. After caching the animation and loading the hair into USD files, these are loaded into Solaris in the last step and set up as described at the beginning and placed in the scene with simple transform nodes.

As there is nothing complicated about this setup apart from the hair and the rig itself, the shot setup also follows the credo “keep it simple”: after the geometry, only the lights, a camera and the render settings follow without more in-depth USD configurations. And since all assets are already available as USD, nothing needs to be cached (Solaris caches non-USD assets with every RenderToDisk process, which can be very detrimental to your nerves at some point). The actual file output then takes place via the USD Render Rop. The most important setting here is Render All Frames With a Single Process!

This eliminates the need to restart the render process after each frame, which is one of the biggest pitfalls when rendering from Solaris. Set the render delegate to V-ray and optionally, but highly recommended, activate the Mplay monitor. Otherwise there is only a progress bar and no visual control of the current frame.

Having finally arrived in Lo-Lo-LOPS land, you are spoilt for choice of renderer. Almost all engines now provide a Hydra delegate that can be used to render in Solaris. The following criteria have been defined for the casting of this project (what works well in the previous OBJ rendering does not necessarily have to work just as well in Solaris. The delegates are sometimes drastically modified for this).

Hairshader

How well can the hair shader be adjusted, what is the look of the hair? General visual quality: How much user tweaking does the engine need to produce a good image? Feature set & efficiency: Does the engine provide everything for the required production? Do you need to build your own tools or use hacks? Are relevant nodes missing? How complete is the existing feature set in Solaris? Are relevant AOVs easily output from Solaris? Is the engine in Solaris easy to set up? How well are the Lightning features (e.g. Lightfilter) supported? Does OCIO work without problems? How quickly can the support team help?

Speed and stability: When it comes to hair, rendering speed is of course a major issue, but not the most important one. Does the engine render the project within the set timeframe of 5-6 days? How easy is it to integrate the existing small render farm? How often does the renderer crash (when will we finally ask ourselves whether it crashes at all…)? A fast first-time-to-pixel would also be nice… The question of GPU rendering, which is a favourite for small teams or, in this case, CGI lone warriors, was clearly subordinate to the above parameters for me. After a few days of intensive study, the choice fell on VRay version 6.1 (a few of the new 6.2 features were already being made available via nightlies prior to release).

V-ray, Houdini and Solaris

The results briefly summarised, starting with what is probably the most important topic for cats and dogs – hair. And here Vray can come up with an excellent hair shader that not only provides a beautiful look OutOfTheBox, but can also be easily customised in a variety of ways.

Basically, the shader is based on the behaviour of real hair – the more melanin pigments are set using the slider, the darker the hair. Pheomelanin makes the hair reddish/orange, the tiger thanks. The dye colour serves as a port for texture maps, which together with the two melanin sliders define the basic coat colours. As a hair does not have a uniform colour, the practical hair sampler node can be used to define gradient masks along the individual hair curves, which can be used to combine texture maps, colour values or even to blend the opacity.

Custom attributes can of course also be used, although the view of attribute values is somewhat hidden in Solaris. Diffuse is best used for fabrics, as hair does not normally have a diffuse component. The remaining sliders deal with the shine and reflection behaviour of the hair, whereby softness has a major influence on the look in terms of the contrast of the hair. Finally, the random settings should be emphasised as extremely practical, as they do exactly that: create credibility through random imperfection – and in our case, enable the advanced age of the protagonists with Gray Hair Density (which can also be controlled by attribute or hair sampler).

The general visual quality is of course subjective, as all engines (well, most of them) ultimately achieve a decent look. What is relevant for me here is how believable an image looks out of the box, what cinematographic and colour design possibilities the engine offers and how easy or quick it is to achieve all this. Of course, a lot can be added in Nuke, but for reasons of efficiency I try to take the image as far as possible in the rendering and use the compositing more for the final touches or for elements of maximum control (DoF). V-ray comes with a physical camera that extends the standard Houdini camera with parameters familiar from the world of photography and filmmaking. This means that shutter speeds, ISO and aperture can be adjusted with real values to rotated elements or generally more plausibly than just with a generic slider. Motionblur in particular can be levelled out more easily. The Sun&Sky system, which works with global light intensities, also benefits from real exposure. In addition, the camera offers other settings borrowed from the real world, such as lens distortion (freely adjustable via slider or distortion map, e.g. from Nuke), OSL support for all kinds of individual effects and a highly customisable depth of field with optional anamorphic bokeh, which can also be controlled via the Aperture Texture Map. Another nice feature for all fans of photographic image composition is that the bokeh shape can be automatically moved towards the cat’s eye with increasing distance from the centre of the image using optical vignetting.

Fortunately, the physical camera works 1:1 in Solaris’ viewport and of course in Vray’s own render viewer VFB (Vray Frame Buffer), which – great cinema – is the only 3rd party render viewer to date that works in Solaris at all. This is accompanied by access to (almost) all the functions that the VFB brings with it. It starts with its own snapshot history including a before/after view, followed by the possibility of displaying image composition overlays such as the golden ratio (otherwise in vanilla Solaris only loadable as an existing image via camera foreground image). Extensive colour management options including simple OCIO setup are just as integrated as complex lens (post) FX.

Although Vray comes with all the necessary OCIO configurations to work out-of-the-box, for convenience and consistency I recommend setting the parameters permanently via system environment variables, also to be on-pair with Houdini/Solaris’ own OCIO settings. Detailed instructions can be found here: is.gd/aces_setup. The only difference: Do not download your own OCIO-Config, but use the one from Houdini in the installation directory/packages.

The Lens FX go beyond the usual bloom/glare and not only allow dedicated adjustment of star flares, but also all kinds of real-world phenomena such as lens scratches and dust, which can have a major influence on the look of the image. CAs are also possible as a post-effect since 6.2. Many of the options here can save time in the comp or at least serve as a quick preview for the customer. Thankfully, the PostFXs are not baked into the image, but can be output as an AOV – Husk takes the settings of the VFB into account when rendering. AOVs can be set in Solaris with Vray’s own node VrayStandartRenderVars and then added to the render product.

This is stored as the last step in the render settings node. A little awkward, as Solaris sometimes is, but can be done independently of the 3rd party render engine. The denoisers (Optix, Intel Open Image Denoise, Vray-Eigen) are also created in this way and automatically activate all the required AOVs. The result can either be rendered directly or used for later denoising with the standalone denoiser (temporal blending!). Cryptomattes can be found in the VrayStandartRenderVar and can even be used directly in the VFB for masking colour corrections.

The best (virtual) camera is useless without the right light (or as the photographers say: the beginner takes care of the technology, the professional takes care of the light). V-ray makes full use of the great lighting tools in Solaris and adds the option of creating your own light filters. To do this, V-ray’s softbox node, for example, is combined with everything your heart desires in a light filter library and fed into a V-ray TextureLightFilter LOP. This is assigned to the respective lights. In this way, gobos, light blockers or soft softboxes can be quickly realised.

In addition to all kinds of compositing and utility nodes such as texture layers, noises, round edges and easy-to-control ramps, the complete toolset also includes a dedicated SSS shader node that delivers beautiful results, especially for the cat’s ears and nose. MaterialX has been supported since 6.2. Even though the Sky/Sun and the newer procedural clouds from V-ray were not used in this project, the artist is pleased that these tools work in Solaris and can be controlled via Distant or Domelight.

A rejected idea at the beginning of the project envisaged more haptic spatiality instead of the undefined endless cave. Thanks to the integration of Chaos Cosmos into Houdini, various seating options for the animals were quickly tested. Chaos Cosmos is Vray’s own extensive asset and material library. Objects including V-ray shaders can be imported directly from a browser into Houdini with a single click. Only the translation to Solaris does not yet work smoothly here, but can still be managed with a little customisation. Solaris imports the .vrmesh as an instance, which breaks the material assignment. A current solution is to convert – to real geometry via the Sopmodify LOP and activated Unpack USD to Polygons.

Over the course of the year, Cosmos will also receive a machine learning-based prompt-to-material function that is directly integrated into the DCCs. The decent rendering times of an average of 20 minutes per frame could be well cushioned with the easy-to-set-up network rendering via distributed rendering.

With DR, all computers on the farm think about one image at the same time (it’s always a pleasure to see over 100 colourful buckets…) – simply activate this in the render settings and add the IP of the workers (these require their own Vray Render Node licence). Of course, the occasional crash cannot be avoided, although the cause was more often Solaris than V-ray itself. V-ray support reacts quickly to bug reports and publishes bug fixes almost every night in the nightlies (activation by e-mail required) and occasionally new functions or UI adjustments.

All in all, Vray not only offers a lot of features and a nice look, but also a really good integration into Solaris. The few functions not yet supported include decals, Aerial Perspective and Enmesh (instantiation of geometry patterns on a mesh for fine details, a bit like Zbrush Micropoly, only @Rendertime). This is very straightforward, even exotics such as the V-ray Clipper (Cut Geo@Rendertime) are supported. My personal highlight: Chaos has managed to get an external render view running in Solaris.

Minimal compositing in Nuke & finishing in Davinci Resolve

The philosophy of achieving as much as possible of the final look in Engine is achieved in Nuke by adjusting the Depth of Fields, fine-tuning and painting out distracting elements that would have been more time-consuming to correct in 3D. Thanks to the OCIO set-up using system environment variables, colours are handled consistently.

Although Vray renders outstanding camera blur, this task was handled (for maximum control) by the wonderful Bokeh Node in Nuke. Fed with DeepPixels, this tool creates the best and cleanest post FX bokeh, which is especially important for fur structures. In addition to real values, unphysical multipliers for the respective blur strength in front of and behind the focal plane can be freely set here. For maximum consistency, a 3D camera exported from Houdini, preferably via USD of course, can serve as the source of all values. Fine details are primarily provided by the Virtual Lens Node (Nukepedia), which can be used to realise wonderful optical phenomena. A favourite is the subtle halation effect, a red-orange halo around high-contrast, bright image elements. Chromatic aberrations such as haze and glare can also be simulated. Last but not least, the layout renderings are replaced by the comps from Nuke in the Resolve edit, refined with film grain and finally played out with beautiful sounds from the sound studio.

Conclusion

Houdini with V-ray & Solaris: A beastly good choice. This article was written with the help and presence of a cat. Many thanks to the team!

The post A beastly good choice first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

With so much stuff – where to start? The fine new “little things” that would justify an entire release for some other software manufacturers or the big chunk? Suggestion – in order to be able to devote ourselves undisturbed to these chunks aka the new animation system, Feathers and Solaris/Karma updates, let’s take a look at the “sideshows” first and free up a lot of mental working memory.

Texture Mask Paint SOP aka Houdini 3D Painter

Houdini has long allowed masks and attributes to be painted directly onto the mesh, but until now only on the basis of topology. If you want to paint detailed masks, you need a correspondingly high-resolution mesh. The new Texture Mask Paint SOP, on the other hand, works on a UV basis and is therefore completely independent of the topology.

The interactive tool not only offers the expected paint function, but also brush features that are more familiar from specialists such as Photoshop or Substance Painter. The applied brushstrokes can be softened with Smooth or smudged with Smudge. Texture and Stamp allow you to paint with textures, while Dirt and Cloud loosen up the brushstroke with noises. The whole thing also works symmetrically.

The painting can be output as a volume mask based on the UVs, which can be used for any other purpose with the usual volume tools or simply used as a mask for the new Feather tools, for example. Alternatively, the volume mask can be exported via Heightfield-Ouptut as .exr and co. and used as a texture mask for hairgen/grooming or shading, for example. The appropriate node for scattering points into the freshly painted mask is called Scatter in Texture Mask and is able to understand the opacity or luminance of the paint node as a density multiplier. If you want to go deeper with the brush, you can use the free HPaint HDA(is.gd/hpaint) by Aaron Smith, a Houdiniesque version of the Grease Pencil.

Quad Remesh

Long wished for and finally here – a native Quadremesher. Although it is still in beta, it already delivers very good and, above all, very fast results. As soon as the node has the first remesh after a few seconds, the number of polygons can be changed almost in real time. Guides can currently only be created indirectly, but this will certainly change in the final version. Until then, you can draw a curve on the mesh, calculate the tangent using polyframe or orientalongCurves and then transfer it back as a guide attribute.

Clouds

If the current weather isn’t cloudy enough for you, you can use the completely new cloud tools to create hyper-detailed hero clouds or even an entire skybox full of clouds. A Cloud Shape Noise serves as the basis for the former, which can either be fed with any geometry or create a structure close to the shape of a cloud itself. This basic shape is ripped apart, processed and transformed into a realistic cloud using new cloud noises (Cloud Billowy & Cloud Wispy Noise), which were created from the detailed analysis of real cloud structures. As these are classic volumes, any Houdini tool can be used to further customise the shape.

The clouds generated in this way can be rendered physically accurately using the new cloud shader with multiscattering. If you want to go a little faster and don’t want to be completely precise, you can use the Cloud Ambient Occlusion Shader, which delivers very useful results for background clouds with a much faster rendering time.

The skybox is similarly direct, with a choice between 2D skyfields and 3D clouds. The former are configured with the new Skyfield plus Skyfieldpattern node, which comes with various cloud type presets, and then designed using the Skybox node. The Skybox alone is sufficient for 3D clouds. The cloud nodes mentioned above offer the option of applying further deformations.

Bubble Solver

A by-product of the new cloud tools is the bubble solver, which takes care of the correct interaction of bubbles. Overlaps are avoided and the individual bubbles are pressed against each other and deformed accordingly. As input, the node requires nothing more than a point cloud (particle, cloud generator or simply a grid) with the Pscale attribute set.

Ripple Solver

Another very simple tool (almost too simple for Houdini) for simulating wave movements on geometry, for example the effect of raindrops on water, but also the impact of shock waves on character. The waves can be output as a float attribute for further use in shading or can be used for other purposes, for example as a density attribute for scattering.

Solaris/Karma

The most important innovation here is the gold status of Karma XPU. The beta status has been cancelled and a whole host of new abilities have been added. These include the complete Light Filter Shader Set, Round Edges, Thin Wall (see Bubble Solver section), production boosters such as Cryptomatte and Deep Images, Absorption and Nested Dielectrics, faster First-Time-To-Pixel and generally increased speed, especially for Fur and Volumes. To be able to marvel at the latter, the render gallery now comes with an extensive statistics panel.

To go with the new Cloud Set, there is finally a Physical Sky (Hosek et al), which in principle combines the new Sky Dome Light Lop with a Distant Light under the bonnet and thus offers the usual Houdini flexibility – if desired. A lot has also happened in the area of shaders and material management. The new material library integrated in the material linker is a good way of creating a material collection more easily and assigning it via drag’n’drop. Some presets and access to the AMD Mtx library (online access) are included out of the box, but could be a little more user-friendly. If you are looking for an intuitive alternative, you can take a look at ODTools with its extensive asset library – is.gd/shelf_tools.

The Karma Material Builder has been tidied up and is now equipped with the Geometry Properties Node to save time. A new fur shader offers settings for medulla manipulation, the inner core of the hair, so to speak, which in turn promises realistic lightscattering.

As MaterialX is subject to constant growth and change and some essential (Uber) nodes are missing or have to be put together yourself, SideFX has thankfully supplied a whole host of new custom nodes, e.g. a ramp node. Fog Box (Uniform Volume for fog and other atmospheric effects), Background Plate, Ocean Procedural and Tone Mapping (Reinhardt and co.) also make it possible to work faster with XPU.

The new cloning offers the option of rendering and comparing the scene in parallel at different times or settings, for example to adjust the effect of a light at the beginning and end of a shot – temporally at the same time, so to speak. The Solaris toolset has also been optimised in many areas and offers, for example, the latest ACES support (applies to all areas of Houdini, not just Solaris), new lighting views and the RBD Desctruction LOP, a procedural that transforms RBD pieces at render time. Mplay can now export video formats natively without an FFmpeg installation, and not just from Solaris.

With its seamless integration, Karma can therefore be used very well as a production renderer and not only saves 3D party engines, but also a lot of setup time. Karma can also be used as a standalone Hydra Delegate from next year. Further in-depth information that would go beyond the scope of this article, as well as wonderful examples, can be found in Olaf’s article – already in progress!

Feather

In addition to the Clouds, the new Feather system is another highlight of Houdini 20. To provide an efficient solution to the complex production challenges of feathers, Houdini offers over 20 new Feathers nodes, many of which are GPU-accelerated and interactive as well as perfectly integrated into the existing grooming tools. Individual feathers can be created with just a few nodes or curves, a shaft and outline, and can be brought into the desired (dis)order with the existing grooming nodes such as Frizz and Clump (of which there is also a special Feather version).

In addition to the classic Guidemask Node, the new Texture Paint Mask Node can also be used to mask certain areas. To create as many different feathers as efficiently as possible, shapes can be interpolated to form new shapes. Once the individual feather (sets) have been defined, they can be quickly drawn or scatterned using the familiar grooming tools such as Guide-Groom.

New options ensure clean interpolation between different feather type areas. Otherwise, the Feather Pipeline follows the work steps of the Hair Tools exactly with a few special new nodes, such as the GPU-supported Feather-Deintersect. This node interactively prevents unwanted overlaps and also ensures a fluffier look, for example. The finished feathers can then be easily converted into polygons and resampled for simulation and animation. The feather fun is best rendered with the new Hydradelegate-independent Feather Procedural, i.e. memory-saving high-resolution only at rendertime.

Animation

The big star of H20 is undoubtedly the new APEX animation ecosystem, a direct challenge to the workflows of long-dead empires. Star text: Beta status with many good ideas, most of which are running well in initial tests and then still have to prove themselves in practice. Before we delve deeper into the topic of APEX, let’s take a brief tour of “general” improvements in terms of animation. In the animation editor, the areas of the curves can now be changed directly without having to use handles. A bit like the newer path tools in Illustrator and incredibly practical. Keyframes can now be moved via MMB without the mouse pointer having to remain directly over them.

The timeline has been given a useful companion in the form of the Animation Toolbar. Here, for example, breakdowns, tweens, easing, time offsets, noises or blending to certain frames or neighbouring keys can be set to speed up the animation processes with sliders. Finally, bookmarks can also be created and controlled with new shortcuts.

What is Apex and what has happened to KineFX?

In short, and this would have taken up most of the time writing this article, so I’ll quote SideFX at this point: “APEX, a brand new context designed to deliver an animator-friendly environment that is built using a robust procedural rigging toolset.” For animators, this really does mean a completely new, viewport-centric and interactive experience. The entire animation now happens in the new Apex Scene-Animate Node, which has no parameters other than Reset, only interactive viewport tools. And what tools!

The selection sets make it easier to select and save relevant controls, but it gets really exciting with new ideas such as locators and dynamic motion. The former allow us to set and save pivots on the go, so that we can move our mesh or character over these pivots away from the controls defined in the rig. The movement is not limited to just one mesh, but can also move everything that has been selected via the selection sets without any constraints.

And if you do need constraints, the new constraint tool allows you to create them directly in the viewport with just a few clicks (2: Driven, Driver, Done) – and remove them again or key the constraint state (On/Off). In addition, reference videos can finally be displayed in the viewport. Everything is controlled via the Animate Node tool menu. The ingenious Dynamic Motion Toolset can also be started here. Considering the original strengths of Houdini, it is only a logical consequence to integrate physical simulations directly into the animation tools.

Thankfully for all pure animators without DOP-Network and Co. the workflow is as follows: The animator sets raw keyframes and contact points for his motion paths, such as the trajectory of a ball or a jumping character, and then lets Houdini adjust the animation physically correctly, fine-tune it and bake it back as keys. Everything simulated can be adjusted at any time. The animator also has direct access to the ragdoll system, allowing him to fling his character around without keyframes.

Kine Fx and rigging

APEX does not replace KineFX, but is part of it. Skeletons, skinning and the like are implemented as before and then transferred to an APEX rig (if you want, you can also animate using a rig pose as before and combine the whole thing with APEX). The idea of APEX is basically a further development of the basic idea of KineFX to treat joints and co. as geometry. However, if rigs are too complex, this leads to performance losses, so that the APEX Graph System, which treats geometry as pure data, allows considerably better performance. For more in-depth information on procedural rigging, be sure to watch the Houdini Hive videos, especially the one by Esther Trilsch here: is.gd/h20_rigging.

Conclusion

Lots of new features and tools and still no end in sight – except for this article. If you are interested in the updates in the areas of RBD (sticky collisions!), Vellum, Flip, Muscles, Pyro, ethically correct machine learning, PDG and actually every aspect of the program (including “hidden”, i.e. undocumented changes such as the new “Create Digital Asset” dialogue), we recommend the extensive, albeit often very technical, docs at this point.

In the Content Library(www.sidefx.com/contentlibrary/) you can download sample scenes for many new features. And they are quite something – they show more advanced setups than just the new tool and take a second or two to calculate the node network due to caches that are not included when opening them. Once you have rummaged through the nodes, the examples are a real source of knowledge. As always, H20 is also available as a free non-commercial version.
Take a look and happy rendering!

The post Houdini 20 first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

Many tasks in Houdini are carried out in the network editor and not in the viewport; every single step, whether bevel or extrude, for example, creates a new node. So it’s all purely procedural, isn’t it? The overview goes to zero in parallel with the working speed and the user goes to other DCCs that can be modelled directly.

Modelling directly in Houdini has some clear advantages. In addition to the obvious saving of export/import loops, Houdini offers wonderful opportunities for automation, experimentation and endless iteration (or quick non-destructive customer feedback rounds) with its basic, but not exclusively, procedural approach.

Add to this a bit of VEX coding at the right time and the conversion of complex modelling setups into simple shareable or sellable HDAs, in which the artist simply has to adjust given parameters to create countless variants of the model, and you have a gigantic arsenal of creative possibilities. Unfortunately, Houdini is not always particularly intuitive or user-friendly and some tools are a little awkward to use.

SideFX has recently been trying to address this with exciting new features. There are more interactive tools, many nodes have been given a tidier UI, more Quality of Life nodes from the Labs or the Tech Art Challenges, where users can submit their own HDAs of all kinds (some of which are permanently integrated into Houdini), plus Quicktips and, of course, more tutorials. Basically, modelling in Houdini is better and more interactive than expected. Nevertheless, there are some areas where we would like to see a better flow and easier ways to achieve the goal.

Direct Modelling!

And this is exactly where Alexey Vanzhula’s solution for direct modelling with the plausible name “Modeler for Houdini” (version 2023) comes in. The talented developer’s inexpensive tool aims to model quickly, intuitively and above all interactively, primarily in the viewport, to compensate for missing tools and generally to simplify and streamline the workflow. Alexey defines his work with the following words: “Modeler is designed to quickly create and edit polygonal\subd meshes. This plugin allows to concentrate only on editing polygons without unnecessary manipulation of Houdini nodes. It has a full set of mesh editing tools, like in other classic 3D programs.”

The centrepiece of the current version 2023 is the launcher, a global menu that opens at the mouse position and from which the artist can quickly and clearly select the desired tool, even faster of course via hotkey.

A bit like Maya, but with its own new ideas and – this is important – seamlessly linked to all the powerful on-board tools of Houdini itself. Modeler is not a black box, but is wonderfully integrated and can be controlled in many places – if required – with attributes or outputs useful groups such as the extrudeFront known from the vanilla Extrude and thus builds the urgently needed bridge between direct and procedural modelling.

It is important to understand that Modeler still creates nodes in the background for many tools, but you can safely ignore them in the interactive flow (tip: hide Network Editor) or send them to nirvana. With the latter, however, the procedurality also disappears. A typical example of remixing the Houdini and Modeler workflows is shown in the following project, in which the various plants were created as individual assets with Modeler and its companion Z (more on this later), partially refined in ZBrush per Z or with Houdini tools such as the Voxelmesh and then scattered onto the basemesh with various procedural tools. Or the complex elements of a bicycle, which can easily be created using Modeler and then welded together using Houdini’s on-board tools. Or the furnishing of a graphically stylised room, created with Modeler and then brought to life with Houdini’s RBD plus classic CHOPS animation (with the exception of characters).

The tools, workflow and launcher

Modeler is activated via the shelf tool of the same name. A yellow line in the viewport shows that Houdini is now running in Modeler mode (and some vanilla shortcuts will now be used by Modeler elsewhere). Let’s take a closer look at the launcher and the most important tools. Viewport with Alt-B in fullscreen mode and off you go!

The heart and control centre of the entire tool is opened in the viewport via a tab (hotkeys are of course customisable). Categorised according to logical use cases, all available commands can be quickly selected here or the associated shortcuts can be learned. A tooltip for the current tool can be found at the bottom.

PolyPen

With this probably most innovative and versatile tool from Modeler, you can interactively move, slide, cut, remove and add any components (points and edges) with a single node (!). You can add any number of loops (including interactive subdivision), adjust the loop flow, slide the entire loop and, of course, delete it again. An inset face and bridge function rounds off the package. All these commands are – and this will blow the mind of any Houdini user – easy to implement interactively in a single node (a subnet is generated in the background, but you won’t notice this).

Brush Tool

Fancy a bit of basic sculpting? Interactively move geometry/points and then smooth them? You can do this without ZBrush and without any edit node cramping using the tool of the same name. Points can be moved freely or along their normal with a freely adjustable radius. The counterpart to ZBrush’s Move Brush and therefore a much-needed tool with which you can even work with axis symmetry..

Symmetry

Oja, Modeler allows interactive axisymmetric work for everything based on the edit node, i.e. moving, scaling, rotating and the brush tool including helpful tools such as beaconing, instantiating or clipping the symmetry. In addition, there is also the Simple and Vanilla Tool-like Mirror Node.

From Extrude to BevelPro

Extrude and Inset actually work in exactly the same way as in Vanilla Houdini, only more interactively and faster via shortcut or “Repeat last” command. The addition of the Extrude-Pro tool, which works a bit like ZBrush’s qMesh and allows you to “punch through” geometry, is exciting.
Another “Pro” tool is the addition to the classic bevel (also interactive and wonderfully fluid), which allows interactive “magnet-based” changes to the respective bevel radius at point level – without the use of attributes. Bevelling with interactive falloff, which can also be fine-tuned with a ramp.

Knife Tool

Unfortunately, Houdini’s own Knife Tool is not exactly flexible, which is why the Modeler version, which allows any number of cuts through the selected faces in a node, is incredibly helpful. The cutoff function, which immediately removes cut polys, is particularly time-saving.

Other useful tools

• Falloff transforms selected elements, but with a falloff defined by ramp or freely settable.
• The array tool works very similarly to ZBrush and is a quick alternative to copy2Points or offers a little more than Copy&Transform.
• Lattice is a simplified version of the Houdini tool of the same name.
• To Circle transforms selected elements into a circle. Straighten aligns selected elements in a line.
• Flatten aligns selected elements on a plane or free axis defined by a construction plane.
• The Crease tool is characterised by its own subdiv preview.
• Quickpivot is a quick and interactive way to position the transform handles of each tool faster than before.
• The CurveTools thank you for FixCurves, which prepares the input for further processing (aka conversion to clean polygonal curves) and avoids a few problem areas of the native workflow, as well as the HoseTool, which lets you quickly create all kinds of cables and hoses.

Parm Slider

This is not a tool as such, but rather the ability to adjust various parameters such as loop subdivisions or extrude divisions at the touch of a button and mouse or pen drag. Information on this can be found in the tooltips of each supported tool.

Align View

Also not a tool in itself, but very time-saving and welcome: Modeler simplifies viewport navigation by aligning the camera rotation to the next global view plane when the Shift key is pressed. Pressing Space-1 to -4 thus becomes obsolete.

Display Options & Material Workflow

For even faster work, Modeler comes with a few desirable functions on the subject of “What do I actually see and what don’t I see?”. For example, selected faces can be easily hidden or all non-selected faces can be hidden. Assigning and editing or copying and pasting materials on a polygonal level is also accelerated or made possible with a few useful tools.

Further utilities from the launcher

If the nodetree does become too large, a bold click on “DelHistory” packs the entire geometry without attributes into a single node and deletes the now superfluous nodetree.
The DelAttr and DelGroups commands help you to get rid of unnecessary data clutter. Of course, you can also remove groups and attributes as before, but this makes things a bit faster again – and that is the basic idea behind the entire tool. Speed up what already exists, add what is missing.

Companion Z

Alexey’s dedication to simplifying modelling in Houdini can also be seen in the two smaller siblings of Modeler, which add even more functionality as separately available tools.

“Z for Houdini” connects ZBrush with our beloved Houdini and allows the artist to quickly and easily exchange and process geometry between the two programmes. Simply send the basemesh from H to ZBrush via Shelftool (unbelievably good: even groups from Houdini are transferred as polygroups), sculpt and otherwise modify it as required and retrieve it again with a click of the Shelftool. Incidentally, fibre meshes are also interpreted as curves and blend shapes and layers are supported. What’s more – and particularly tasty – the powerful zRemesher can be started and adjusted with a node from Houdini.

Soft Boolean

“Softboolean” does exactly this task with flying colours and saves a lot of work steps required in vanilla Houdini. A few useful tools are included to make the workflow as interactive as possible, such as quickly extracting the seamcurve or subdividing the meshes.

Community, resources and development

Modeler benefits from an active community centred around the Discord channel. In addition to official how-tos and highly helpful users who can answer almost any question, there is also the opportunity to report bugs or directly express new feature requests and discuss the best ways to implement new tools with the developer. Modeler is also regularly updated with new functions and bug fixes. Sneak peaks of new functions and helpful, detailed tutorials can be found on the official YouTube channel.

Setup and purchase

Modeler is sold for 99 US dollars via the Gumroad Store and is very easy to install: “Copy the modeler and packages folders to the Houdini user preferences folder.” A preconfigured *.json file is used.

Conclusion

Of course, almost a hundred euros is not a small sum, but measured against the gain in speed, fun and convenience, the tool is inexpensive and a really good investment. Modeler belongs in every well-stocked Houdini collection and makes the assembled DCC competition look even older..

Links

Gumroad Store alexeyvanzhula.gumroad.com
Discord Channel https://is.gd/discord_hm
Youtube is.gd/houdini_modelers

The post Direct Modeling (R)evolution für Houdini first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.