The sheer mass of innovation so far has been roughly the same kind of brain trip as Neo’s journey down the rabbit hole. So put the popcorn on the table, question your own reality, celebrate Houdini’s 30th anniversary to the day while you are at it, and off we go into the land of new nodes. And yes, you can imagine this being read to you in Keanu Reeves voice.

“We have a clear, confident and calm direction to get you through these big changes that are happening in this industry.” – Cristin Barghiel, Head of R&D from SideFX

Oh well, let’s see…

KineFX & APEX Rigging

The “umbrella ” for character and creature workflows reaches a certain level of maturity in Houdini 22, where all subareas interlock: rigging, animation, retargeting and motion mixing. With this version, CFX (muscle simulation), hair and fur systems, is integrated into the KineFX environment to form a continuous workflow.

In production, rigging traditionally sits between static modeling input and the animation pipeline. Houdini 22 now makes this transition smoother by treating even new, extreme assets such as Gaussian Splats like normal polygon meshes. You can capture G-Splats, rig them procedurally and animate them without changing the workflow.

Using a wasp as an example, the new Rig Builder shows how the system works. Thanks to new Shape LODs, you can switch in the viewport between proxy, low-res and high-res splats to get real-time feedback while posing interactively. The finished setup is saved as a Rig Template and adapts to completely different insects such as rhinoceros beetles or absurd larvae, because KineFX procedurally detects different joint lengths and can skip joints based on names and tags.

Controller widgets also get a upgrade. The old image controls are back, scale natively with the viewport, can be docked to the edge of the screen or act as screen-space gadgets fixed to the display. This opens the door for clever control interfaces inside the viewport.

BiPeds

For daily work with bipeds, Houdini 22 provides ready-made recipes and templates. You simply throw your geometry and skeleton in, and the system builds a biped, including a completely revised viewport interface. Joints can be aligned through translations instead of rotations thanks to auto-aiming, while procedural Selection Sets sort the controllers clearly by body part and place them collapsibly in the animator’s field of view.

Here’s Cedric

The chimpanzee Cedric demonstrates how character setup, animation and Creature FX, or CFX, work together. Here, Rig Builder, Fuse Graph, blendshapes and the Wrinkle Deformer for muscle and armor setups flow together, without having to touch a messy graph in the network.

For facial setups, the combination of classic blendshapes and the Wrinkle Deformer saves a huge amount of manual sculpting, since the system calculates fine wrinkles and nonlinear deformations procedurally. The face controllers are shapeshifters and can switch on the fly in the viewport between direct on-face manipulators and classic 2D sliders.

The Mechs are coming

For mechanical rigs or robot arms, Houdini uses Set Driven Keys and Multi-IK with constraints. The central component is the new APEX Rig Pose Node, which manages posing, rest pose and animation in the Animate State. Its secret weapon is the Set Driven Key component, which acts as an automated translator: you define an animation range and connect it to a driver control, allowing the rig to fire off logical dependencies without manual graph tinkering. If something gets stuck, the APEX Graph Debugger displays the numerical values of the graphs live as hover text directly in the viewport.

Together with studio Tumblehead, SideFX uses toad Hank to show how much creative madness is packed into APEX. CUDA-accelerated custom deformers via HDK enable an extreme squash-and-stretch rig to run completely in real time. The system stubbornly follows the Character-In-Character-Out principle, allowing you to procedurally attach new eyes or extra arms to the rig in the middle of a shot without breaking the rig. Because apparently even amphibians deserve modular body horror now.

AI, here we go….

To speed up the coding of complex rigs, Houdini 22 introduces the APEX Script Comfort Package. It provides a VS-Code extension for autocomplete, a Python panel directly inside Houdini and, functionally, an MCP server, meaning Model Context Protocol, that controls a carefully curated library of syntax rules and snippets.

Since the thing is claimed to be highly “token-efficient” (We used to call that “Working”, but the LinkedInification of language. Sorry.), you can connect a local LLM, and generate rigs using natural language. An integrated validator checks the code, and since the final output consists of pure scripts, you keep ownership of the data without AI dependency.

Mo-capybara

Mocap retargeting is fully automated through a new biped recipe, which maps joint names, proportions and rest poses from Mixamoall the way to custom characters. Even incomplete skeletons, are accepted. The subsequent rig inversion translates the skeleton data back onto the rig , measures bone lengths for automatic stretch and counters the IK flipping on overbent mocap knees using the new Rest Twist option. If needed, IKs can even be intentionally broken as an artistic decision.

In a live demo, SideFX shows that the entire process, from bare geometry to the finished Motion Mixer, can be completed in under five minutes. The character is rigged via template, connected to retargeting data, art-directed at the shoulders, converted through rig inversion and then pushed directly into the Motion Mixer.

Animation

When it comes to animation, viewport performance is the big metric. Houdini 22 delivers with the “Evaluate Rig in Parallel” option. The system distributes characters across separate CPU threads, so 20 fully rigged Electra characters can play back smoothly at a full 24 frames per second. More than 3,600 controls and over 13,000 channels in native real time, without disabling anything in the background. Since these are full rigs and not simple crowd agents, you can make live adjustments and pose characters during playback. We don’t know how big the Workstation was, though.

In the revised Motion Mixer, you can drag animation clips onto the timeline, trim them and use functions such as Match Position to align joints. Clips can be blended into each other by overlapping them, looped or cleaned up with filters such as Smooth FX. The real workflow rescue device here is the new Nested Clips.

Nested what?

These nested clips combine a whole battery of timelines and tracks into a single clean block, which keeps the thing vastly more usable. A double-click takes you back into the data to edit details.

APEX Character

The new APEX Character Picker gives rigs a visual control center on a configurable canvas. You can load backgrounds directly from the viewport or use ready-made templates to link buttons to the desired controls via right-click. The tool adopts the names and colors of the controls, can be scaled, mirrored or connected to procedural Selection Sets.

For complex areas such as hands, the canvas can be split to preserve readability. A neat side effect appears in ragdoll rigging: you can control invisible collision shapes through the picker while keeping the unscaled mesh visible in the viewport. The tool ships directly with standard characters such as Electra.

Cameras are now full citizens inside APEX, which improves working with the integrated audio panel, including scrubbing. A face camera, constrained to the character’s head, eliminates the full body movement. In the viewport, you get a stable focus on the face, which is essential for precise lip-syncing and fine facial animation. For posing, you can access your animation library directly. You select the pose from the catalog and blend it onto the entire rig or, through Selection Sets, onto isolated areas such as the mouth region.

Through the new Geometry Channels, you get direct access to all animation layers of your character at once. If, for example, the director shifts the audio by a few frames after the fact, you no longer have to touch every layer individually. Instead, you use the Retime tool. A double-click places markers in the timeline. If you grab the thick handle, you can shift the entire animation. If you use the thin handle, you correct the marker position without touching the keyframes. This lets you compress or stretch animations between markers quickly, while all keys outside the markers remain untouched.

With the Full Body IK system, animations can be reshaped without coing through a thicket of keys, curves and individual controls. Bookmarks define the relevant time range in the timeline, a keystroke places a target on the hand or head, and the in and out points are pinned. From that moment on, a single controller is enough to make the entire character behave procedurally.

Did someone say ragdoll?

The ragdoll system receives four physical forces that can be activated directly in the viewport. In addition to wind, magnets and damping, which makes the character float as if underwater, turbulence adds a major boost in realism. Since these forces work through collision shapes, you can reduce turbulence on the head or legs to avoid unattractive wobbling. With the magnet, you can pull and tug on the rig procedurally to sculpt poses physically. The thing even works without prior keyframe animation.

For brutal destruction scenarios, where a character is slammed through a table, Houdini 22 introduces the new Impact Threshold. This threshold is based on impact velocity and removes the manual keying of the exact ragdoll activation moment. The object shatters automatically in the exact frame in which the critical velocity is reached. Since the system works nondestructively on copied animation layers, the throw timing can still be moved afterward. The Impact Threshold recalculates the ideal physical break moment automatically every time.

Animated Splats?

The fact that Gaussian Splats are, under the hood, nothing more than points with attributes makes them ideal food for the animation pipeline. Since they are lightweight and calculated on the GPU, you can load G-Splats as full sets, remove individual points or bring them back into the rig with controllers through the Scene Add Prop Node. You can animate and pose G-Splat stools and kick them around correctly with ragdolls.

For organic creatures, the system provides procedural secondary motion directly on controller level. A keyframe animation on the main control generates automatic swinging on antennae or legs. Multipliers prevent all limbs from twitching in sync, while modes such as Lag Overshoot, Jiggle or Spring add a touch of inertia. Using a blend slider, you can blend this physical secondary motion back into your keyframe animation at the end, or send the chunky G-Splat wasp crashing into the wall with a ragdoll impact.

CFX

In CFX, Houdini 22 expands the interaction between crowd simulations and anatomical correctness. The new feature for crowds is the porting of the ML Deformer to Agent Primitives. The machine-learning model runs on the GPU, calculates inference blending of blendshape weights in batches across multiple characters and gives mass agents.

An Agent LOD slider in the viewport lets you balance performance quickly by downgrading more distant agents while only characters close to the camera receive the full deformation stack.

Look at those muscles!

The revised Muscle Transfer recipe benefits from the new biped retargeting tools, allowing mocap animations to be pushed onto muscle setups.

For muscles, SideFX fixes the solver so that stiff tissue no longer lags behind during fast movements. Thanks to new constraint formulations and velocity blending from Vellum, you get organic jiggle without additional calculation overhead. The Otus subnets are now fully editable for POP forces, provide stress attributes for wrinkle masks and offer real sliding constraints for tissue sliding over other tissue.

For hair and fur, Houdini 22 delivers the long-awaited end-to-end workflow requested by the community. You load any high-resolution static groom into the system without any prior attributes and let an extremely thin set of guides deform the final fur only at render time.

Responsible for this is the Guide Reduce SOP, written completely in OpenCL. Its adaptive algorithm selects the most distinctive outlier hairs for Vellum simulation, with 100 to 200 guides often already enough for a clean result.

The new Guide Deform 2.0 maps these weights accurately onto all stray hairs. To prevent dense fur clusters from falling apart during extreme action, the options Preserve Shape and Preserve Clumps run under the hood. Using a quasi-static physics simulation, they smooth out high-frequency artifacts and preserve the spatial relationship between hair tips.

The new Capybara Fur recipe bundles this workflow and pushes Guide Deform 2.0, thanks to OpenCL optimization, to 50 times the speed of its predecessor in native real time in the viewport. The integrated Guide Utility Node handles the annoying work of root pinning, Vellum orientation and 0-to-1 curve normalization in a single node, cleaning up the network.

A highlight for polishing at shot level is the fact that the Shot Sculpt tool now fully supports curves and guides. You can mix mesh fixes and guide adjustments in constant back-and-forth, mask areas or use animated attribute painting to morph haircuts and fur colors fluidly in the middle of a shot.

When expanding hair, the Hair Generate Node enables sparse guide grooms on highly detailed geometry through the Blend in Skin Space option, so guides only need to be placed where they are required for the final look.

The Configure Guide Deform LOP saves a huge amount of disk space because it does not bake hair deformation to disk. Instead, it calculates the deformation on the fly at render time using a Hydra procedural.

Through deep LOPs integration, the system automatically inherits motion-blur subsamples from the skin and guide input, preventing hair from ever tearing away from the skin. Since the in-house Husk procedural has also been upgraded to real geometry motion blur, millions of hairs render cleanly even with nine samples and without the typical artifacts of the old velocity blur. This saves enormous amounts of disk space and network I/O because the heavy high-resolution groom only needs to be stored once instead of firing hair salad frame by frame onto the servers.

Modeling and terrain

The Quad Remesher receives an Edge Flow upgrade in Houdini 22. The new rectangular method was developed for hard-surface models, since it procedurally detects hard edges and aligns the mesh exactly to them without distorting the internal topology. At the same time, the symmetry function provides a cleaner flow for organic objects.

The new SideFX Labs tool Split by Expression allows flexible splitting of geometry using different methods. Its special feature is that the interface displays the underlying VEX expression directly next to the parameters, making the node a useful learning tool.

For complex organic patterns or laying cables, the Walk on Surface Node provides a solution for growing or sliding curves and points along closed meshes. Control is handled through attributes or through noise vector fields via streamline tracing.

The Curve Tool receives a evolution with Curve Animate. In addition to pure point positions, tangents can now also be animated. Even if the topology breaks into pieces during motion, the interpolation of curve arcs and tangents remains consistent across the animation.

Heightfields in Copernicus

The migration of heightfields into Copernicus accelerates terrain generation by a factor of five (supposedly) and integrates it directly into the texture synthesis workflow. Instead of working awkwardly with volumes or layers, the Copernicus nodes provide direct access to all inputs and outputs.

These can be seamlessly combined with all the heightfield tools. As a result, complex operations such as erosion can be controlled through compositing inputs and directional maps can be generated in the node network.

The new tools include Height Field Strata, which emulates layered rock and quickly generates high levels of detail through an included recipe. The new Fractal Sample Node builds a bridge between real terrain and pure texture.

It samples a simple input pattern fractally across different resolution levels and scales, repeatedly over itself, producing complex, seamlessly tileable structures very quickly. In addition to directly available recipes for these nodes, larger scenes for more complex environments and texturing are planned for the Content Library in the future.

With Neural Layer to Height, machine learning also enters the terrain pipeline. The node automatically downloads an external ML model, MOG 2, in the background and estimates depth directly from a single photograph, while the tool remains controllable like any other Houdini node. Since purely image-based ML results are often somewhat soft, the generated heightfield can then be refined with procedural tools to add fine details and structures.

Solaris

The focus in Solaris lies on the long-awaited expansion of layout, worldbuilding and set dressing. The USD Component workflow becomes a first-class citizen directly inside SOPs. Here, you can build geometry hierarchies, create proxies and finally place and manipulate pivots without switching context to LOPs. For point-based placement, paint-based instancing has been made more robust and expanded with geometric shapes such as circles or rectangles, which serve as brush fill masks.

Procedural mass placement is handled by a new scattering procedural that runs Houdini Engine inside the Hydra pipeline. Since the data is only generated at render time, the USD scene remains lightweight even with half a million instances. The tool provides powerful masking options: camera frustum culling saves RAM, ambient occlusion places instances specifically in crevices or avoids them, and external hero meshes can mask roads out of vegetation, for example. Comprehensive transform randomization also provides some realism.

The Edit LOP now uses the RBD and ragdoll developments for improved physics-based object placement. You can move clusters interactively, build organic piles and benefit from a iterative workflow. Karma also now supports instanced mesh lights with individual control over intensity and color per instance.

For lighting and volumes, the introduction of equiangular multi-importance sampling provides less noisy point lights in volumes. For lighting design, there are also new, highly controllable Light Blockers with adjustable shapes and soft fall-offs.

In look development, the new Texture Material Library LOP allows a tight loop for COP-based texturing directly in combination with Karma. Through the update to the latest USD and MaterialX versions, SideFX gives Karma a native flake shader as well as dedicated shading nodes for curvature and ambient occlusion.

Finally, slap comping moves directly into LOPs through the new Image Filters as a post-processing stack. Since these filters are authored as USD data, they are available to all Hydra renderers and remain live in the viewport during interactive layout.

VFX

After the enormous number of new solvers in recent releases, SideFX uses version 22 to slow the pace slightly and close functional gaps.

One important gap is closed in Bullet: the rigid-body solver now receives a simple method for bending and metal fracturing, making the resource-intensive MPM solver unnecessary in many classic pipelines. In parallel, the reliable Voronoi Fracture Node has been optimized and now runs faster than in previous versions, saving time before the actual simulation, even with hundreds of thousands of fragments.

For entry-level use, SideFX also includes new ready-made recipes for magic effects, covering the full path from simulation to rendering and compositing in a single learning setup.

The main focus in the VFX area, however, is the Copernicus-based Sparse GPU Fluid Solver, which has been upgraded from a simplified background experiment into a full production solver on SOP and DOP level. To avoid slowing down brute-force GPU performance by uploading heavy polygon meshes, Houdini introduces so-called implicit surfaces. These mathematical shape descriptions are generated directly on the graphics card and immediately used there as efficient collision objects or source geometry for fluid simulation. This merges the advantages of procedural physics simulations with the flexible pre- and post-processing possibilities inside the new Copernicus environment.

Copernicus

In just two years, Copernicus has evolved from a beta version into a full toolset for texture synthesis. Houdini 22 marks an important milestone here, since the 2D and 3D painting functions are now fully integrated.

A significant architectural shift takes place in terrains, since all heightfield workflows have been migrated from SOPs into COPs. In addition to expanded physics solvers, Copernicus also serves as a central platform for orchestrating AI models, allowing ML-based processes to be represented inside the node environment.

Newly integrated are parametrized UV Shapes, which output complex layouts that would be difficult to build manually, such as horseshoe or spiral UVs, allowing arbitrary input textures to be distorted across surfaces.

For photorealistic PBR materials, the system also provides new procedural grunge maps for drips, rust or stains, as well as tools for web, knit and bark patterns.

For the games pipeline, Copernicus uses Session Sync to drive interactive Unreal materials in live exchange between the engines. During subsequent texture baking, the new Bake Pre-Process Node helps in the COP and Karma baker. It automatically identifies interpenetrations between high-res and low-res meshes via attributes and corrects the cage geometry before the actual baking process.

With Neural Cellular Automata, or NCA, another ML node enters the system. It scales and distorts learned texture patterns and, thanks to adjacency maps, lets them grow seamlessly across UV seams directly on 3D geometry to create complex organic growth effects.

With the new Paint 3D COP, a full paint package moves directly into Copernicus. The user interface provides everything expected from texturing, including a classic layer stack with blending modes, alphas and many brush shapes. The toolset is complemented by features such as tiling for seamless textures, ready-made recipes for catalogs and countless options for customizing brush strokes.

This tool is not limited to 2D space, but also allows direct painting on 3D meshes. Handpainting therefore happens exactly where it is needed, making it possible to place textures on the geometry.

Since the Paint node lives natively inside the COP network, its use goes far beyond classic drawing and can be repurposed for entirely different tasks. One example from the presentation showed how hand-painted masks on a backpack image sequence were used directly in the network to train a machine-learning model for image segmentation.

With the integration of SAM 2, a powerful neural model for image segmentation becomes available. It fits into the familiar user interface as a native node and can be integrated directly into existing texturing pipelines or compositing processes.

Oceans in Copernicus output height information directly as texture maps. Based on that, two-dimensional simulations such as custom foam can be calculated and seamlessly combined with ocean surfaces.

New tools for Refraction from Height and Caustics from Height generate physically plausible light effects directly from height data, without three-dimensional rendering. This enables techniques such as rendering a depth map from the camera perspective, calculating caustics from it efficiently and projecting them back into the scene through lights. These additions push Copernicus toward becoming a full compositing tool.

The arsenal is expanded by a new two-dimensional Ripple Solver directly inside Copernicus. It processes animated inputs as well as collision objects and is suited for deforming surfaces for stylized effects or motion graphics.

Adjacency Maps solve the problem of visible seams at the edges of individual UV tiles. When a texture-based effect reaches such an edge, the motion is transformed seamlessly across the boundary and continued. Houdini now provides several tools that natively support this, such as Cellular Automata, where organic growth patterns flow across complex geometries without interruption.

But what else ? If that isn’ enough for you, SideFX is carrying out a major technical rebuild in Houdini 22 on two fronts.

3D viewport

The viewport throws out the old OpenGL ballast and now consistently uses Vulkan, or Molten on Mac. This not only cleans up the code, but finally clears the path for the “cinematic near-realtime Vulkan-based renderer” that has been promised to us for years as a future vision “just around the corner”. Next up, Nuclear Fusion at Room temperature.

User interface

For years, users have demanded a UI update, but SideFX stayed with the proven interface. With Houdini 22, SideFX now breaks with that tradition. Cristin Barghiel makes clear that this is not merely a design update: “We drew some new icons. There it is. Oo laa.”

It is explicitly not just a re-theming, but a “serious, long-term, arduous exercise in functionality,” made possible by the transition to Qt and QML, which finally removes the technological roadblocks that have prevented SideFX from significantly advancing the UI and UX for years.

The new start screen collects all essential entry points, such as recent projects, tutorials and production templates, in one place. This simplifies the workflow when launching the application and saves time in daily work.

With the integrated Theme Editor, there is no more painful manual editing of text files, which previously required regular restarts of the application. Adjustments now happen directly inside the interface, allowing global color schemes, highlights and contrasts to be modified without interrupting the workflow.

The revised Preferences organize all settings in a much clearer structure. The integrated search function enables direct access to all options, finally ending the time-consuming hunt through nested menu paths.

Tooltips now function as a visual knowledge base directly inside the viewport. In addition to explanations, they also display example images, allowing users to understand functions more quickly without leaving the software to look at the documentation.

The color picker improves color selection through precise control and management of custom color palettes. The eyedropper can now sample colors from any element outside the software, making it easier to integrate reference values from other applications.

The ramp catalog replaces previous text presets with a visual library of available gradients. Thanks to adaptive sampling from the screen, ramps can be generated directly from existing references, making the creation of complex gradients much more efficient.

Gaussian Splats

Gaussian Splats are now first-class citizens in Houdini. The toolset has been expanded from a visualization and rendering solution into a full component of the pipeline. Splats are now editable across every node: they can not only be loaded, but also procedurally created and modified.

The performance of Gaussian Splats has been improved in Houdini 22. Under the hood, these splats are simply point clouds with attributes, which makes them ideal for procedural manipulation.

The capybara test model can be animated without difficulty. Standard nodes such as Bone Deform and Surface Deform are used for this. Physical simulations can also be applied, for example to make a palm tree sway believably in the wind by controlling the points.

One inherent problem of splats is their baked-in lighting, which can look unnatural when deformation becomes too strong. New relighting tools based on spherical harmonics allow dynamic relighting of the points.

Gaussian Splats are created directly inside Houdini from photographic input and parallel training via PDG. Only the generation of the COLMAP data for camera estimation currently still has to happen externally. Messy edges after training can be cleaned up easily using simple networks.

Splats can also be generated directly from rendered three-dimensional scenes by placing a camera array around the object. The result is high-resolution models that can be navigated in real time. This technique is not limited to geometry, but also converts volumetric data such as clouds or animated fireballs into storage-efficient splats.

Anyone who made it to the credits knows: that was not all. In addition to these major highlights, there are dozens and dozens of other new features.

Get it … now?

Exact release date? SideFX is sticking to its usual rhythm here: the keynotes and sneak peeks, which took place in mid to late June 2026, serve as previews. Traditionally, it takes about another four to six weeks from that point until the actual launch.

Thanks, and out.

The post Here comes Houdini 22 first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

TL;DR / For those who don’t know the tool: Sneeze sits between spatial services and AR and VR clients. It consumes glTF output from Blender, Maya, Houdini, Revit and Cinema 4D, and forms the engine layer of OMBI at the Metaverse Standards Forum.

A browser engine for rooms

The Metaverse Standards Forum introduces Sneeze on June 15, 2026 as an open metaverse browser engine. RP1 acts as lead architect and maintainer. The engine targets spatial services that appear through location and proximity rather than through a conventional page, tab or app-store download.

The project names Sneeze as the world’s first open metaverse browser engine. That is a marketing claim. Its practical definition is more useful: Sneeze keeps the scene graph, manages network connections, executes service logic and renders a shared spatial scene. A browser or native application supplies the shell around it. The planned release uses the Apache License 2.0 and places the code on GitHub. The final repository URL has not been published, but should be online soon.

The distinction between engine and browser matters. A web browser wraps navigation, settings, updates and user trust around an engine. Sneeze takes the engine role for spatial content. Developers can embed it beside an existing web renderer or use it inside a standalone native spatial browser.

Tabs would get crowded

A normal web browser loads one origin into one page context. Sneeze works with spatial fabrics. A spatial fabric combines mapped content, a coordinate system and related services into an environment such as a city street, university campus, factory floor, airport terminal or game arena.

Every fabric requires a map service. That service supplies geometry, terrain, objects, coordinates and streaming updates. Other services can add presence, communication, commerce, safety alerts, equipment data or location-bound content.

That model gives augmented reality a browser-style discovery mechanism. The engine opens and closes streaming connections as fabrics become relevant. It does not load each environment as a fixed document. Proximity supplies the navigation event.

Rendering gets an adapter

Sneeze routes scene rendering through ANARI, the Khronos rendering abstraction. ANARI describes meshes, materials, lights, cameras and volumes through a common API, then delegates drawing to a renderer underneath. The current architecture uses Filament through an ANARI-compatible wrapper for rastersiation. ANARI keeps that renderer replaceable. The application code above the abstraction does not need a rewrite when the engine swaps the renderer below it.

Tracking and device input pass through OpenXR. Head pose, hand pose and controller state come from the active XR runtime. Sneeze combines that tracking with the user’s position to place the virtual camera in the SOM coordinate space. The render loop reads the SOM as it exists for the current frame. It does not wait for every service writer. Network updates and WASM modules can keep changing the scene while rendering continues, and the next frame picks up the new state. That separation matters across phones, desktops, AR glasses and virtual reality headsets. Hardware changes below the abstraction layers. The scene model and service boundary stay in the engine.

For 3D, VFX and visualisation teams, this vocabulary will reach client meetings long before it settles into production pipelines. We will create the models, materials, animation and environments that spatial browsers present, so names such as SOM, glTF, WebAssembly, ANARI and OpenXR are worth learning before the next briefing becomes another group exercise in confident nodding. Again.

DCCs stop at delivery

Sneeze does not replace content creation tools. It consumes their output. glTF carries 3D models, animation and scenes from the DCC side into the browser engine.

The format can carry mesh geometry, physically based materials, textures, skeletal animation, morph targets and a hierarchy of transforms. Its binary container can package the same delivery data. Sneeze treats that payload as rendered content rather than as an editable authoring scene.

glTF does not carry the live multi-user state, service streaming or change notifications described by the browser architecture. The map service and SOM handle those jobs. The format transports assets; the spatial system handles what changes around them.

KTX supplies GPU-oriented textures. SPIR-V supplies portable shader bytecode. Compiled WASM modules carry service logic. Together they create a delivery boundary between authoring and runtime.

Materials and textures can come from Substance 3D or Quixel Mixer. Models and animation can come from the usual DCCs. The engine sees the files, not the artist’s preferred interface, node graph or collection of mysteriously named final-final files.

That boundary gives existing Blender workflows a direct route into the proposed runtime through glTF export. It does not promise that every shader, modifier, simulation or custom rig behaviour survives the trip.

Game engines need translation

Unity and Unreal Engine projects have a migration path. Assets that convert cleanly to glTF can move across. Engine-specific rendering, physics, UI and networking do not transfer directly. Those systems depend on the original runtime. Custom effects need new shaders or materials for the Sneeze rendering model, while service logic needs the host-function API instead of engine-specific calls.

That makes migration a conversion job rather than an import button. The architecture preserves the distinction between content that crosses the runtime boundary and systems that remain coupled to a game engine.

Server-side adapters provide another route. An existing application can run as a backend service and expose model data through the browser protocol, while Sneeze renders the result on the client. That route trades direct client execution for compatibility with existing server infrastructure.

Open standards, mixed maturity

The engine stack draws from the Khronos Group, the W3C and existing internet standards. ANARI handles rendering abstraction. OpenXR handles XR device interaction. glTF, KTX and SPIR-V cover 3D assets, textures and shader bytecode. WebAssembly runs service logic.

The Metaverse Standards Forum hosts OMBI as an open project for standards organisations, technology companies, developers and researchers. RP1 contributed a working prototype and leads the engine architecture and maintenance.

The project’s open-source plan puts implementation beside standardisation. Code, documentation, test cases, reference services and developer tooling all fit the contribution model. The final code URL remains the missing practical detail at press time.

Academia joins the build

The University of Rochester has launched the Open Metaverse Academic Alliance through its Center for Extended Reality. The alliance brings universities, researchers, educators and professionals into spatial standards work.

Its current focus includes OMBI. Participants can contribute use cases, conduct research, evaluate proposals and work on the open-source engine. The alliance also connects academic work with enterprise partners and student training.

Two AWE sessions, one booth hunt

The Metaverse Standards Forum and RP1 present Sneeze at AWE USA 2026 in Long Beach. The conference runs from June 15 (Yesterday) to June 18. Sean Mann and Neil Trevett will discuss the browser initiative on June 16 at 4:30 PM in Room 101A. A working roundtable follows on June 17 at 1:40 PM in Room 103B. The Forum and Khronos occupy Booth 104. RP1 occupies Booth 928. The first native browser built with Sneeze is due for discussion and demonstration during the event.

The useful boundary

For artists and pipeline teams, the immediate technical point is the runtime boundary. DCCs create assets. glTF, KTX and SPIR-V carry compiled output. WASM carries service logic. The SOM combines live scene state from separate operators.

Sneeze packages those pieces into an embeddable engine rather than a single proprietary application. Its design defines the architecture in substantial detail, while the missing repository blocks code-level inspection before launch.

Open standards case and initiative scope.
https://omb.wiki/standards

Architecture, SOM, WASM, rendering and content pipeline.
https://omb.wiki/sneeze

Original OMBI project page.
metaverse-standards.org/open-metaverse-browser-initative

OMBI launch announcement.
https://metaverse-standards.org/news/blog/introducing-open-metaverse-browser-initiative/

Forum homepage and project context.
metaverse-standards.org

Open Metaverse Academic Alliance.
https://www.rochester.edu/university-research/initiatives/extended-reality-research-and-application-extrra/open-metaverse-academic-alliance-omaa/

Open Metaverse Browser Architecture PDF.
https://cdn.rp1.com/product/Open-Metaverse-Browser-Architecture.pdf

AWE 2026 sessions.
https://www.khronos.org/events/awe-2026

The post Sneeze Brings a Browser Engine to Spatial 3D first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

MoonshotCGI has made a free Komodo asset available through its Try our assets page. The free package is a multi LOD model, muscle ecorche, an advanced rig, 2K multiUDIM textures and a walk cycle animation. Also, there is a facial rig (Insofar as Dragons have face instead of giant maws of putrid creepyness), multiple resolution levels and files for Maya, FBX, Alembic and OBJ workflows.

For creature artists, this is the useful kind of freebie: not just a still-friendly mesh, but a rigged animal with animation data. It gives modelers, animators, TDs and lookdev artists something to poke before procurement wakes up. Test teh rig, deformation, texture coverage and caches before trusting it in a real pipeline.

Paid tiers for real jobs

The commercial product page has paid versions of Komodo Dragon starting at €292,62. License options include Non-Commercial, Indie and Studio, with Silver, Gold, Platinum and Diamond asset tiers. Non-Commercial Silver costs €292,62 and includes model, textures and lookdev. Non-Commercial Gold costs €438,93 and adds rigs. Indie Silver costs €780,33, Indie Gold costs €1.170,50 and Indie Platinum costs €1.365,57. Studio Silver costs €2.926,23, Studio Gold costs €4.096,72 and Studio Diamond costs €4.681,97.

Indie is listed for individual freelancers only. Studio tiers use 4K textures, while Non-Commercial and Indie tiers list 2K textures. Indie Platinum and Studio Diamond list walk, run and idle cycles. Studio Diamond also adds animations and simulations. So, igf the joke from the dailies session gets to big, you don’t have to rebuild it, but can buy the odel and put it in there. We assume, a lot of background gags in cinematic historey start this way.

Formats and pipeline reality

The paid product has .abc, .obj and .fbx. Textures are listed as EXR, TIFF or PNG. Rigs, lookdev and animations use .ma or .mb. Simulations use .hip, which points that part of the asset toward Houdini users. External plugins are not required at the moment. MoonshotCGI is moving its rigging workflow to mGear, and future rigs will require it when the asset description says so.

https://shop.moonshotcgi.it/en-eu/pages/try-our-assets
https://shop.moonshotcgi.it/en-eu/products/komodo-dragon

The post Free Komodo Rig for Fun first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Houdini is SideFX software for procedural modelling, animation, VFX, look development and rendering. Houdini Engine connects its assets with Maya, 3ds Max, Unity and Unreal Engine.

Before anyone updates the farm

Houdini 22 has appeared in a maddeningly short sneak peek video. That sentence contains nearly everything we can state with confidence. The footage moves quickly through Gaussian Splats, character work, Copernicus, Terrain, USD, Unreal, rendering and simulation. It supplies very little explanation and what follows is therefore guesswork.

Think of it as fanboys pausing a teaser frame by frame and attempting to identify the nodes before the compression artefacts win. A longer presentation is scheduled for June 22, 2026. Until that arrives, every interpretation deserves a large bucket of salt.

The Splats look suspiciously useful

The loudest section of the teaser concerns Gaussian Splats. The video appears to show Splats created inside Houdini, processed through procedural networks, rendered in Karma and manipulated as scene data. It also appears to show a Splat-based creature being rigged and animated. Thank you, SideFX, for picking the absolutely worst animal to trigger all my personal creepy-crawly shrieks. Why not do that with a cat, or a dino, or something …l nice?

But back to the topic: That sounds substantial. It may be substantial. The animated creature suggests that Houdini 22 may support deformation or motion workflows for Gaussian Splat data. The footage also appears to show training or generation through TOPs. So, the Gaussian Splat Machine Learning for Radiance fields directly within Houdini.

Copernicus keeps spreading

Copernicus appears throughout the teaser. The footage shows procedural pattern generation, a UV Shape node, Neural Cellular Automata and image-driven effects moving across geometry. One shot appears to use adjacency data and time shifting to move ripples across a statue. That could indicate tighter links between image processing and surface topology.

Could is doing heavy work in that sentence. Copernicus also appears beside terrain tools and Unreal Engine integration. A Houdini Digital Asset seems to expose COP controls inside the engine. That could become a practical authoring workflow for procedural textures and effects. It could also depend on prepared assets, restricted nodes or specific outputs.

The teaser does not say.

Character tools get a few seconds

The KineFX section appears to include IK Limits and Set Driven Keys. Both concepts are familiar in character rigging. IK Limits restrict joint movement. Set Driven Keys connect one animated value with another. Their apparent arrival in Houdini could simplify common rigging tasks.

Motion Mixer also appears to gain nested clips. The current reading is that animation clips can be nested within larger clip structures. That seems useful for assembling longer motion sequences.

None of these sections lasts long enough to answer the questions a character department will actually ask.

USD wanders into SOPs

The teaser appears to show USD data authored through SOPs. That could give geometry artists another route into scene description without moving immediately into Solaris. The idea makes sense. SOPs already provide a familiar procedural environment for asset construction. Adding USD authoring there could reduce context switching during asset preparation.

The footage does not explain supported schemas, composition arcs, variants, references, payloads or layer management. It does not establish whether SOP-based USD authoring handles complete production assets or a narrower set of preparation tasks.

Quad Remesh may get more rectangular

Quad Remesh appears to gain a Rectangular method. The visual result suggests a more regular grid-like topology. That may help with surfaces that benefit from cleaner directional flow. Automatic retopology demos usually begin with cooperative geometry. Production begins when the mesh has teeth, holes, overlapping parts and a history of questionable decisions. The new mode looks promising.

Terrain enters the Copernicus fog

Terrain tools appear to move closer to Copernicus. The teaser seems to show a unified heightfield workflow inside the image-processing framework. Since heightfields already behave like grid-based image data, the combination is technically plausible.

Effects get recipes and speed claims

The video appears to show prepared recipes for fireworks and magic effects. Recipes can package node arrangements for repeated tasks. That could help artists reach a usable starting point faster.

Voronoi fracturing also appears faster. Faster than what, on which hardware, with what geometry and under which settings remains unknown.

Disclaimer: This is a teaser, not documentation

Hints are not specifications. Several interpretations may turn out to be accurate. Others may describe internal experiments, partial workflows or features that behave differently from the way the teaser suggests. The video is simply too short to support definitive conclusions.

For now, SideFX Houdini 22 looks interesting. That conclusion is safe. Everything more detailed remains guesswork until the manuals arrive.

YouTube Houdini 22 Sneak Peek

The post Houdini 22 Teaser Fuels Guesswork first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the studio: Lux Aeterna delivers documentary and natural history VFX including CG environments, FX, and compositing, and it mixes scanned data with CG for shows made with broadcasters and streamers.

History likes receipts

Historical reconstruction only works when the images carry the same authority as the research. The studio leans on archaeological reference, field documentation, and specialist feedback to keep reconstructions grounded, especially when the brief asks for ancient humans that look plausible in stills and in sequence work.

Two recent projects show how far that approach goes. Secrets of the Neanderthals needed a cave interior rebuild and physical remains that read like real bones. Human pushed further, asking for early human avatars built from actor scans and refined against scientific consultation, plus maps and timelines driven by datasets.

Bones first, drama second

For the Neanderthal work, the team recreated the interior of Shanidar Cave in northern Iraq, the site of one of the largest ever discoveries of Neanderthal remains. It used a mix of reference drawings, photographs, and expert advice from professors at the University of Cambridge and Liverpool John Moores University to guide accuracy, including cases where remains had been damaged or moved from their original positions.

Skeleton placement used inverse kinematics so the bones could interact with the ground in a natural way. The pipeline also dealt with scan data arriving as a 3D point cloud, then converting it into polygons that could support a usable cave reconstruction. That conversion problem tends to separate demo reels from production, because bad meshing reads instantly, even when the camera does not linger.

Point clouds, polygons, and the cave that ate your schedule

natural landscape. The figures are engaged in a purposeful journey, reminiscent of ancient human life.” class=”wp-image-279577″/>

The cave build started with LiDAR scans that came in as a 3D point cloud. The team developed algorithms to convert the points into polygons for the reconstruction, then used Houdini to isolate areas of scan data so the mesh could be assembled and recombined like a 3D jigsaw. That kind of procedure-heavy work sits squarely in the Houdini mindset: build repeatable ops, then iterate until the scan stops looking like scan data and starts looking like a place.

The result aims for a CG environment that matches the real location closely enough that it can carry the weight of the story, while also supporting the additional CG work needed for the remains and the shot context. In a documentary pipeline, that matters because the images often sit right next to photography, maps, and archive material, with no cinematic lighting trickery to hide behind.

Lux Aeterna delivered 60 shots for a single series, and that number matters because it hints at the production scale when planning resources. WE might e talking about geological and evolutionary tiespans in the story, but delivery is far more rapid.

Full bodies: photogrammetry, casting, and millimetre arguments

The later project asked for historically accurate avatars built from scans of real performers, refined with skeletal research and scientific input. It was a five-part series produced by BBC Studios Science Unit for the BBC and PBS NOVA, hosted by paleoanthropologist Ella Al-Shamahi, and it frames visual effects as a way to tell a story spanning hundreds of thousands of years without a written record.

The workflow combined ultra-high-resolution body scans with iterative model refinements guided by BBC Studios and scientific advisors. It worked with London-based scanning studio Sample & Hold, which describes custom head and body photogrammetry systems and a photogrammetry robot for objects. In practice, that puts photogrammetry into the same category as any other acquisition step: controlled capture, predictable output, and a pipeline that can survive the boring parts like data cleanup and repeat scans.

The stated goal was four historically accurate avatars representing Jebel Irhoud, Neanderthals, Homo floresiensis, and Homo erectus, based on scientific data and real-world actors. Alongside the character work, the project also required prehistoric environments and landscapes to show migration and later disappearance of early human life across the globe. The work targets ancient humans, but it does not tolerate ancient guesswork.

Maps, timelines, and the part nobody notices until it breaks

A second strand of the work focused on animated maps and timelines that visualised migration, development, and disappearance across millennia. The graphics are being built using datasets provided by BBC Studios Science Unit researchers and scientific consultants, and not as speculative graphics.

One specific challenge involved changing coastlines and submerged landmasses, where the team created transitions and overlays to keep the visuals clear while staying scientifically accurate. That is the kind of “small” work that carries a lot of editorial risk: the map has to be readable, the timing has to serve the cut, and the choices have to stay consistent across episodes.

On the delivery scale, the project description states sixty crafted shots across five hour-long episodes, and it frames the approach as avoiding prosthetics and overly stylised effects while using a hybrid of photogrammetry, consultation, and minimalist Compositing.

What to take away if you do this for a living

If your job involves building reconstructions that sit next to real-world evidence, the takeaway is simple: acquisition quality and reference discipline decide how much time you spend “fixing” later. Scan data arrives noisy, research notes arrive detailed, and schedules arrive optimistic. The pipeline has to translate all three into images that read as plausible without distracting from the content. And as always, test any new workflow, plugin, or automation step on a throwaway shot before you bet a delivery on it. Just like with rare fossils, you don’t want to play loose with the materials.

https://www.lavfx.com/
https://www.lavfx.com/secrets-of-the-neanderthals
https://www.lavfx.com/blog/human

P.S. You have NO idea how big the challenge was not to replace “Ancient Humans” and “Prehistoric” with the users of one ore more DCC-packages….

The post Lux Aeterna rebuilds ancient humans first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: The Pixel Farm makes PFTrack, a node based matchmove and reconstruction tool that exports to DCCs like Autodesk Maya, Foundry Nuke, SideFX Houdini, Blender and Unreal Engine, with improved dense point clouds via OpenUSD.

Hero Cloud is a new reconstruction node

PFTrack Build 26.05.19 adds Hero Cloud, a node that generates a measured dense 3D point cloud from a single tracked plate. It sits in the Geometry category and runs downstream of a solved camera, turning an ordinary camera solve into spatial data you can actually measure against. Hero Cloud claims to be through-the-lens reconstruction, meaning it extracts depth from the camera movement in the shot rather than relying on a separate photogrammetry set or a LiDAR scan.

The node targets a familiar production reality: you get a brief that needs measured 3D, but the the on-set… people…. said “Fix it in Post, heheeheeh” and did not capture the extra data for cases like set extension, CG integration, lighting reference, forensic analysis, architectural measurement, and archival footage where you cannot go back and reshoot reference. If the plate is all you have, Hero Cloud aims to make that plate pull double duty.

Hero Cloud works on plates PFTrack can track and solve, and works footage sources that include cinema cameras, drones, body cams, dash cams, action cameras, mirrorless and DSLR cameras, CCTV, and archival film. Basically, every type of video. Camera metadata can help but it is not required, and the Camera Sensor Database can cover common cameras automatically, with the Camera Solver able to estimate parameters when metadata is missing.

There is a catch, and it is the same catch as every method that tries to infer depth from motion: the shot needs parallax. Locked off shots or shots with very little movement can produce sparse or unreliable results. Most production footage, including handheld stationary shots, can still have enough movement to produce usable reconstruction, while deliberate camera motion tends to produce richer results.

A cleaner route into splat training

PFTrack 26.05.19 adds a Postshot export option that writes Hero Cloud point clouds and associated tracked cameras in COLMAP format. In other words, matchmove and reconstruction can stay in the same app up to the point where you hand off to splat training.

If you already live in the Gaussian Splatting world, COLMAP is a common interchange format and COLMAP itself has both GUI and command line workflows. The practical value here is that you do not have to glue together separate tracking, reconstruction, and export steps before you ever open Jawset Postshot. You track the plate, generate the cloud, export in COLMAP format, then train the splat.

This is an artist friendly route into a workflow that has historically leaned on command line tooling. That is a reasonable and recommendable goal, but it still deserves the usual pipeline skepticism: try it on a real shot and verify your coordinate frames, scaling, and camera consistency before you let it anywhere near a deliverable.

USD point clouds now carry more than positions

The same build extends USD export to support dense point clouds with per point normal and colour data, because a point cloud that only carries XYZ positions often becomes a dumb scaffold the moment it leaves its origin app. Normals and colour help downstream tools treat the cloud as more than a vague spatial fog, and can make it easier to use for measurement, placement, modelling reference, and lookdev decisions.

Improved integration with USD aware tools including Unreal Engine, Maya, and Houdini. It also claims (!) improved FBX export reliability for very large dense point clouds, aimed at users who previously hit issues exporting big clouds via FBX.

If your pipeline already standardises on USD, this is the kind of unglamorous export detail that can decide whether a new feature becomes a daily tool or a demo-only party trick. Still, test it on your actual asset scale and on your actual DCC import settings. Export support is never a substitute for shot-based validation, and you only find the sharp edges when production hits them, much like furniture at night can only be found with toes and shins.

Photo Mesh gets a single shot input path

Studio and Enterprise editions receive an update to Photo Mesh that enables it to consume Hero Cloud point clouds as input. That creates an internal single-shot path from tracked plate to dense cloud to surfaced textured mesh, without leaving PFTrack. The Pixel Farm describes Photo Mesh as the highest fidelity route when you have a planned photo set, while Hero Cloud covers the case where you only have the hero plate.

In practical terms, this puts a reconstruction option closer to matchmove, and it reduces the number of handoffs in the middle of a cmaera tracking job. Whether it replaces any external reconstruction tooling depends on what you already trust for meshing, texturing, and scale fidelity, but the internal integration is at least a coherent story: generate the cloud, feed it into Photo Mesh, then export into the rest of your pipeline.

The viewport tweak you will actually use

26.05.19 also adds an Active Camera viewport option in viewer windows, with a snap to active clip toggle. It sounds minor, and it is, which is why it will get used: quick visual verification against the source plate tends to catch mistakes faster than hunting through node outputs. The release notes pitch it as useful for checking Hero Cloud reconstruction, but the feature applies anywhere you want a fast way to see what the tracked camera saw.

Trial and licensing notes

Solo trial mode now enables full export functionality for seven days. The release notes describe this as enough time to take a plate from track through Hero Cloud and out to Postshot or USD, rather than being limited to evaluating the toolset without export.

For Studio, the release notes state it is available on rent to buy for 5 or 30 days, or as a perpetual purchase. The PFTrack Creator Program page states PFTrack Solo licenses sell for £699. Treat that as a price reference for Solo licensing, not a promise of regional pricing or bundles.

What this changes in real work

Hero Cloud aims to shift PFTrack from a pure matchmove and survey friendly reconstruction hub toward a single shot scene reconstruction step that can be used even when the onset data plan fell apart. The strongest parts of the release are not flashy, they are connective tissue: COLMAP export for Postshot, denser USD point cloud payloads, and a meshing path that stays inside the same graph.

It is also a reminder that the industry has started to treat point clouds as a first class asset, not only a temporary byproduct. When point clouds export with colour and normals and survive the trip into USD aware DCCs, they become reusable poitn based reference that can support layout, set extension decisions, and reconstruction driven previs.

https://www.pftrack.com/post/pftrack-build-26-05-19-is-now-live

https://www.pftrack.com/post/hero-cloud-tutorial

The post PFTrack gets Hero Cloud first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: MoonRay is a production path tracer with a USD Hydra render delegate for tools using OpenUSD, positioned in rendering and lookdev next to ASWF staples like OpenColorIO.

The Academy Software Foundation has added MoonRay as a hosted project, keeping the renderer under foundation governance while opening contributions to a broader community. DreamWorks Animation developed MoonRay as an open source production path tracing renderer and has used it on every one of its feature films since 2019, including The Wild Robot and The Bad Guys 2. The project uses the Apache 2.0 license and is developed in C++.

MoonRay includes support for distributed rendering and a pixel matching XPU mode that processes bundles of rays on the GPU as well as the CPU. It also includes bundled path tracing and a USD Hydra render delegate for integration into content creation tools that support the OpenUSD standard, which should make interactive preview workflows less of a custom science project in teh average pipeline.

The ASWF angle

MoonRay now sits alongside other hosted efforts in the ASWF roster, including OpenEXR, OpenVDB, OpenTimelineIO, and Open Shading Language. If your facility already treats OpenColorIO as plumbing, this is the same neighborhood.

For contributors, the project points developers to openmoonray.org and to the ASWF Slack workspace for a MoonRay channel at slack.aswf.io. Documentation is published at docs.openmoonray.org, and the source repository lives under the OpenMoonRay organization on GitHub.

Keynote season meets SIGGRAPH season

ASWF Open Source Days runs in Los Angeles on July 19 to 20, 2026, and the schedule aligns with SIGGRAPH 2026 timing. The keynote comes from DreamWorks Animation CTO Bill Ballew, with a talk titled How to Train Your Renderer: MoonRay’s Journey from DreamWorks’ Dragons to the ASWF.

The event listing describes July 19 as the main program day in Los Angeles, followed by July 20 as a full day of open source Birds of a Feather sessions within SIGGRAPH. The Call for Proposals remains open through May 24, 2026, via the Open Source Days event site.

As always, test new tools and new governance setups before you bet a production schedule on them, even when the feautres list looks exactly like what your render wranglers asked for.

https://openmoonray.org/

https://www.aswf.io/

The post MoonRay Renderer joins ASWF as hosted project first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Simple Tree Tools 3.0 targets artists who want tree and plant generation to behave like the rest of a Houdini graph: parameter driven, non-destructive, and easy to rewire when a shot brief changes at 6pm.

The toolset runs in Houdini 20.5 or later. The supported editions depend on the license tier and include FX, Core, Indie, Apprentice, and Education. In day-to-day use, the pitch is straightforward: generate species with controls that stay editable, shape plants with growth responses, and keep the whole thing inside a network you can hand to the next person without a sacred PDF explaining which button not to touch.

Procedural generation, but with plant brains

The feature list leans hard into procedural generation. The tools aim to generate any species of tree with non-destructive, parameter-driven controls, covering everything from small plants to large trees.

Plant shaping focuses on environmental response through tropisms. The named list includes Gravitropism, Phototropism, and Thigmotropism, with several others also mentioned. For art direction, growth can be guided using guide curves or vector fields.

If you live in the Houdini tag archive, this sits comfortably in the same mental drawer as other procedural effects tools: the value comes from staying editable until the last responsible moment, not from making a single perfect hero tree once.

Scan extension nodes for the trunk people

3.0 also includes scan extension tools aimed at hybrid workflows: scanned trunks, procedural branches, and a bridge between them.

Two nodes are important: Scan Initialize and Scan Stitch. The stated goal is to seamlessly extend scanned geometry and blend procedural branches onto high-resolution trunks with physical and UV-mapped transitions. That matters for asset teams that already keep a scan library but still need variation and shot-specific dressing without resculpting every new silhouette.

If your environment’s pipeline already leans on library assets and a sprinkle of procedural dressing, this positions the tool neatly inside CGI environments work, where consistency and iteration speed beat heroic one-offs. Test your scan handoff carefully, though, because any workflow that mixes geometry sources can surprise you in UVs, scale, and downstream exporting.

Wind, growth, and the licensing reality check

Licensing and commercial use come with unusually plain language. The toolset uses one-time purchase licensing with no subscriptions or recurring fees, and purchases cover all v3.x updates delivered automatically through Gumroad. Future major versions such as v4.0 may require a separate purchase, with a discounted upgrade price mentioned.

The FAQ states you can sell models, renders, asset packs, game assets, and film work created with the tools if you only hold a Limited Commercial license. You cannot redistribute the tool’s own HDA files. The Non-Commercial tier restricts use to personal learning and non-revenue work, and it ships as .hdanc files, which forces Houdini into non-commercial mode when those nodes exist in a project.

If you buy a paid license while staying on Houdini Apprentice, the FAQ states it does not remove export restrictions. The tool does not alter your Houdini license limitations, so you need to match your tool license to your Houdini license to avoid unpleasant surprises in prodution.

Support runs through email (nirfse3d at gmail.com) – refunds generally are not offered due to the digital nature of the product, with an invitation to reach out if a serious issue appears. As always, treat new tools like new plugins: build a small test scene, push it through your actual export path, and only then let it into a network that people depend on.

Pricing and tiers

Pricing has four tiers: The Non-Commercial tier is free and a good way to test the tools. The Limited Commercial tier costs $99 and targets hobbyists and freelancers with annual revenue under $100k USD. The Full Commercial tier costs $229 and targets hobbyists and freelancers with annual revenue above $100k USD. A Studio tier costs $1,299 and is described as a site-wide studio license. So, for the big players, not as little ones.

The plugin also has file type differences by tier. Non-Commercial uses .hdanc. Limited Commercial uses .hdalc. Full Commercial uses .hda. The Studio tier also lists .hda.

Individual licenses allow installation on up to two personal machines for a single user. The Studio license covers unlimited installs within a single facility.

https://simpletreetools.com
https://nwestfelt.gumroad.com/l/SimpleTreeTools-v3

The post Simple Tree Tools 3.0 goes procedural first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: SplatTransform is a CLI and library that converts and edits Gaussian splats for pipelines that end up in SuperSplat or real-time runtimes. It ships as a package for Node.js and also runs in browser contexts.

What 2.0 actually changes

SplatTransform 2.0.0 adds a sparse voxel grid plus exterior fill for nav simplification. That pushes the tool beyond file shuffling and into spatial reasoning you can use for scene cleanup and interaction prep, especially in Gaussian Splatting workflows. Or, you know, previews.

Two new GPU-based processing actions land alongside the voxel pipeline: filterFloaters and filterCluster. They target unwanted bits that do not belong to coherent spatial clusters, and they run on the GPU path.

Floors, clusters, and tighter crops

2.0.0 adds floor fill, voxel-level cluster flood, and tighter voxel crops. The net effect is more structured scene operations, built on the voexl representation rather than only per-splat attributes. The release also refactors logging and progress reporting, and the CLI now reports peak memory usage in its final summary line. That is small, but it is the kind of small that saves time when you run batches overnight, or the whole studio is computing in timewarp.

Less native baggage, more inputs

The tool replaces meshoptimizer with a lossless coplanar-merge pass. That removes a native dependency from the meshing side of the pipeline and keeps the operation lossless by design. SplatTransform also accepts http and https URL inputs in the CLI, so you can feed remote assets directly without a manual download step. PlayCanvas also updates the dependency on supersplat-viewer as part of the 2.0.0 release work.

Formats, install, and the boring but important bits

The repo documents claim support for PLY, Compressed PLY, SOG, SPZ, SPLAT, KSPLAT and LCC, plus write support for PLY, Compressed PLY, SOG, SPZ, GLB, CSV, HTML Viewer, LOD and Voxel formats. So, everything we ever heard of as formats for splats. Install uses npm with a global command, and there is also a Docker backend guide for server-side use. Which we will be testing soon, and if you don’t hear from us again, something exploded.

The code is MIT-licensed and published as an open-source package, which usually means it’s free to use, but any production adoption still deserves a legal and pipeline check. New tools and innovations should always be tested before use in production, preferably on the worst shots and the messiest captures first.

https://github.com/playcanvas/splat-transform/releases/tag/v2.0.0

The post PlayCanvas updates SplatTransform to 2.0 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Fallout Season 2 asked for more scale and less forgiveness. Rise delivered 244 shots across seven episodes, with the heaviest work landing early, and kept two sites moving as one crew. The playbook stayed familiar, but the demands went feral: closer cameras, heavier mechanical interaction, city-wide procedural destruction, and sand-driven reveals that punished every shortcut.

Fallout!

Andreas Giesen is a Rise VFX Supervisor with a Houdini-heavy background and a track record on FX-intensive shows. He is credited by the Television Academy for a 2024 Primetime Emmy nomination for Fallout in “Outstanding Special Visual Effects in a Season or a Movie”. His Rise FX credits include serving as the studio VFX Supervisor on The Matrix Resurrections, as well as work on has worked on X-Men, The Matrix, The Last of Us and the various entries in the Marvel universe, among others.

DP: When we last spoke about Fallout Season 1, you worked on a show that combined large-scale environments, destruction, Vertibirds, Power Armour, and complex integration work. On Season 2, where did the challenge shift?

Andreas Giesen: The challenge shifted purely to massive scale and extreme scrutiny. In Season 1, we were establishing the rules. In Season 2, we took those rules and stress-tested the pipeline. We had a huge jump in scale, like procedurally destroying the entirety of Los Angeles or dealing with the multi-layered sand reveals of Area 51, but we were operating with roughly the same core team size. Brute forcing was not an option. We had to lean heavily on our procedural setups and the USD foundation we built in Season 1 just to survive the shot count.

DP: Did Season 2 feel like a continuation of an established visual language, or more like a technical reset because the demands had changed so much?

Andreas Giesen: Artistically, it was a continuation. We already had that shorthand with Jay Worth and Jonathan Nolan, so we knew what that tactile, grounded Fallout look felt like.

Technically, though, it was a massive upgrade. We did not throw everything away, but we had to rebuild or upgrade many assets because the camera was suddenly much closer or the interactions were much more complex. The Vertibird docking with the Caswennan, for instance, required a whole new level of mechanical detailing that just was not necessary in Season 1.

DP: RISE delivered work across several episodes, with particularly dense work in some of the early ones. How did that affect the structure of the production on your side?

Andreas Giesen: We delivered 244 shots spread across seven episodes, but the bulk of the heavy lifting hit right in episodes 2 and 3. To keep the chaos in check across our Berlin and Stuttgart offices, we operated as one unified team. We ran single VFX dailies so it never felt like two separate facilities. We relied heavily on our in-house production management tool, risebase 3, to keep the sites synced.

Honestly, a massive shoutout to our VFX Producer Annelie Dangel , Production Manager Scott Kunysz, and the coordination team. They were the real firewall keeping the production structured while the artists dealt with the pixel pushing.

DP: You mentioned that the work was divided into more specialised teams. How exactly did that division work in practice?

Andreas Giesen: Instead of splitting the work purely by department, where an asset just gets tossed over the wall, we built small, cross-functional strike teams dedicated to specific sequences. For example, we had a dedicated Area 51 team and a completely separate Caswennan team.

Each of these pods basically consisted of one layout artist, one lighting artist, and an FX artist if the sequence required it. This meant the artists became absolute experts on the continuity, lighting setups, and specific technical hurdles of their assigned sequence, rather than constantly context switching between different environments.

DP: The Caswennan ship has become even more important in Season 2. At what point does a hero asset like that stop being “just a vehicle”?

Andreas Giesen: When you get that close, it absolutely stops being just a vehicle and becomes a massive flying set. The layout has to treat it like a static environment just to block the shots, especially when we are tracking complex character animation and heavy mechanical interactions, like the Vertibird docking, directly onto the hull.

DP: What were the rebuild decisions under the hood?

Andreas Giesen: It was actually a really interesting round-trip process. Since the flight deck scenes were shot on a virtual stage, we received the Unreal Engine asset from production as our starting point. Funny enough, that Unreal asset was originally based on our own Season 1 dirigible model!

So, our CG team, led by Jenny Leupold , took the updated proportions from the virtual stage, brought the asset back into our pipeline, and completely re-engineered all the high-res cinematic details and shading quality.

DP: How did you approach balancing a highly detailed close-up asset with practicality for layout, lighting, and shot iteration?

Andreas Giesen: We relied heavily on our USD workflows and instancing. We had to design functional heavy hydraulics and complex mechanical joints so the lifting arm physically made sense up close, but we could strip that back or use lighter variants for wider layout tasks so the scene would not grind to a halt in the viewport.

DP: In Season 2, there seems to have been a stronger overlap between physical production, virtual production, scans, and final CG. How did that affect the pipeline in concrete terms?

Andreas Giesen: It meant we lived and breathed LIDAR. For the Area 51 reveal and the hangar sequences, production gave us incredible plates and highly accurate scan data. Having that precise spatial data was the only way to guarantee a seamless transition from the practical sets into our massive digital extensions. Once that data enters production, it locks in your scale, distance, and speed, which were crucial for making the flight dynamics feel grounded in reality.

DP: There was also mention of Unreal-based virtual production material related to the airship. How did you manage the relationship between real-time assets, scanned set data, and final cinematic assets?

Andreas Giesen: Again, USD was the bridge. We took the Unreal assets, which gave us the exact scale and spatial relationships from the LED volume, and used them as the spatial framework to build our final pixel cinematic assets over the top. It ensured that when we integrated the final CG back into the live action plates, all the contact points and lighting references matched the physical set pieces perfectly.

DP: Was the biggest benefit from USD technical elegance, or simply that it stopped artists from stepping on each other’s work?

Andreas Giesen: Ha, a little bit of both, but honestly, stopping the file overwrites is worth its weight in gold. On a more technical level, the real elegance was how flawlessly it let us bridge the gap between Maya and Houdini.

For the Shady Sands environment, our Layout Lead Karin Wolf and her team built the pristine, non-destroyed city parts in Maya. We then brought that via USD straight into Houdini to scatter all the granular details and endless cornfields. Being able to mix and match layouts without friction meant artists could just stay in the tool they were fastest in.

DP: The Vertibird work in Fallout has always been interesting because it needs to feel stylised and believable at the same time. What were the challenges for it in Season 2?

Andreas Giesen: The challenge is that it is a massive, lumbering vehicle, but it still needs personality. For Xander Harkness arriving at Area 51, he is a fantastic, slightly cocky pilot, so we had to inject this aggressive precision and specific swagger into the flight path and mechanical braking.

The integration challenge, especially during the Caswennan docking, was finding that fine balance of heavy momentum. We had to ease the mass and simulate procedural micro vibrations to show it buffeting in the air currents. The hardest part was nailing the exact frame where the mechanical arm takes over the full weight and the rotors power down.

DP: How much of selling a vehicle like that comes from animation, and how much from camera language, editorial rhythm, and integration into atmosphere and environment?

Andreas Giesen: Animation gets you the weight and the performance, but the environment integration is what sells the lie. In the hangar landing, the plate was dramatically backlit. Our lighters had to introduce specific light sources to shape the geometry nicely and match the foreground. Then the FX rotor wash tied everything together. We simulated heavy CG dust and debris blowing right past the lens, matching the practical wind from the live-action plate to physically anchor the digital ship into the real set.

DP: For sequences involving scanned practical sets, such as hangar or landing environments, what are the biggest pitfalls once the scan data actually enters production?

Andreas Giesen: The biggest pitfall is that the scan data and the live action plate lock you into absolute physical reality. If the plate has a specific wind direction or interactive lighting, absolutely every piece of CG vegetation, dust, or vehicle integration has to physically react to that exact same environmental energy, or the illusion breaks immediately.

DP: Fallout still has this very specific balance: it is heightened and absurd in places, but the world still needs physical credibility. How does that affect VFX decisions in review?

Andreas Giesen: You have to ground the absurdity in absolute, boring physical reality. For the dramatic dirigible crash, which is inherently a heightened, spectacular moment, we went straight to historical footage of the Hindenburg. We ran intense, clustered simulations starting with plastic deformation for the metal bending, triggering RBD sims for the hull ripping apart, and feeding that into multiple layers of pyro for flames, smoke, and contact sand. If the physics are incredibly strict, the audience will buy into the universe’s stylised madness.

DP: On a show like this, where does proceduralism genuinely save time, and where does it still need a heavy layer of manual art direction to become production-ready?

Andreas Giesen: Proceduralism saves you on the sheer volume, but art direction saves the shot. For the destroyed Los Angeles, we started with basic map data, literally just cubes and planes. Our brilliant TD, Kilian Baur , built a Houdini tool that procedurally converted those cubes into heavily detailed, destroyed buildings. It generated massive amounts of geometry. But you cannot just hit simulate and walk away. We had to manually paint the degree of destruction across different zones for compositional reasons. The tool does the heavy lifting, but the artist still has to compose the frame.

DP: Was there a particular sequence in Season 2 where the real constraint was neither the creative idea nor the client feedback, but simply scene complexity, cache weight, or iteration cost?

Andreas Giesen: The dirigible crash and the Area 51 reveal were absolute beasts for cache weight. For Area 51, we were blending volumetric dust, suspended sand particles, and contact sand actively swirling off the geometry. The dirigible had even more interactive layers, expertly managed by FX TD Arnaud Malherbe under Jens Martensson .

We survived by heavily clustering the sims for faster turnarounds and by relying on deep compositing workflows in Nuke. Our Compositing Supervisor Michael Lankes , Comp Lead Kader Bagli , and Comp Lead Jannik Walzer did incredible work taking those massive datasets and balancing them without bringing the farm to its knees.

DP: What became easier on Season 2?

Andreas Giesen: Things like lookdev for the energy signatures became easier. We reused the core effect for the cold fusion and diode glows from Season 1. But because we had to scale it up to so many more shots, we had to build highly efficient setups in Nuke involving heavy rotomation and complex relighting, since that blue glow affects every shiny metal surface around it. The look was established, but the volume and the necessary integration were significantly harder.

DP: Was there a shot or sequence this season that looks deceptively simple in the final cut, but was technically far more difficult than most viewers would ever suspect?

Andreas Giesen: It has to be the Power Armor enhancements. Production has this absolutely incredible practical suit that a stunt performer wears on set. However, because it is a physical, wearable suit, sometimes individual parts will naturally jiggle or bounce a bit too much during heavy action, which breaks the illusion of solid, heavy metal armor.

In the shot where the massive dirigible is coming down and exploding in the background, we actually had to completely replace the shoulders of the Power Armor while the character is running away. Everyone in the audience is obviously staring at the massive fiery airship crash taking up the sky, but there we are, meticulously tracking and doing invisible CG replacement on shoulder pads just to make sure the suit feels appropriately heavy.

DP: And conversely, was there a shot that looked terrifying at first but became manageable once the right structure or workflow was in place?

Andreas Giesen: Definitely the procedural destruction of Los Angeles. The idea of destroying a city of that scale is terrifying. But once Kilian’s tool was in place, and we utilised our USD pipeline to block the shots with simple geometry while the high-res destruction updated seamlessly in the background, it actually became a highly manageable, iterative process. We could instance the endless piles of rubble and rusted cars, which kept the massive scale from becoming unrenderable.

DP: What is a technical lesson from Fallout Season 2 that would transfer well to other large episodic shows?

Andreas Giesen: The absolute golden rule is to keep everything as procedural as humanly possible so you can actually survive rapid client changes. That, combined with establishing those small expert strike teams we talked about, is how you manage the chaos. But the real lifesaver that transfers to any heavy show is aggressive pipeline automation. For sequences with massive shot counts, we utilised our proprietary riseflow tools to completely automate the heavy lifting.

We could submit CG renders from one principal master scene across 50 different shots before leaving the studio. By the next morning, the pipeline had automatically generated 50 temporary composites, already perfectly combining the new CG with the live-action plates using deep learning. Waking up to 50 ready to review temp comps instead of a massive rendering bottleneck is the only way to deliver a show of this scale.

DP: What is the next project you are working on, insofar as you can already talk about it, and is there anything from Fallout Season 2 that you are taking with you into that next production?

Andreas Giesen: I am currently working on something very exciting, but unfortunately, it is strictly under wraps right now, so I cannot speak about it just yet. But I am absolutely taking the USD workflows and the procedural pipeline strategies we refined on Fallout straight into this next challenge!

The post RISE: Fallout Destroys LA, Politely first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Paradigm is a GPU liquid solver that runs inside Houdini, alongside Axiom, using node based workflows for VFX liquid setups.

What 1.0 actually changes

Paradigm 1.0 targets GPU accelerated liquid simulation in Houdini, and the developer describes it as a “hybrid that can be called a FLIP solver while borrowing ideas from SPH”, whatever that means. It is supposed to be faster and more accessible than Houdini native liquid tools.

Version 1.0 ships as a sequence of point releases that stack up into something production artists can actually evaluate. The current notes focus on simulation stability, faster solvers, better sourcing, more outputs, and a Tank workflow aimed at open water setups. If you live in Houdini, this is the kind of list that determines whether you can keep a shot moving or spend the week explaining why it will be ready next week.

Sourcing gets less crunchy

The 1.0.153 to 1.0.175 updates bring a major round of sourcing work. Particle emission from source shapes improves, with spacing and layout described as more random and even, and with less repetition. A separate Particle Source node arrives to control emtoion timings in a way described as similar to source shapes.

Read more: Theory Accelerated shifts Paradigm 1.0 for Houdini

Sourcing can now push more than just positions. The solver can output particle attributes like color, temperature, viscosity, and rest as optional outputs, and it also adds age and life attributes plus lifespan controls to remove particles that age past their life value. It can also output churn, described as the magnitude of the curl of the velocity field, as an optional field.

The system also supports defining extra arbitrary particle attributes by defining them in the output tab of the solver node. Source VDBs can affect particle attributes, for example by sourcing a temperature volume source to make particles hotter. Temperature and color attributes can diffuse and dissipate. A relax force is described as now working properly and as fully deterministic. All of that translates into a much clearer story for lookdev and downstream controls. You get more handles, more outputs, and fewer excuses to bake everything into a single sim and pray.

The performance pass: SDF, advection, sorting

The 1.0.176 to 1.0.219 updates lean hard into speed and numerical behavior. A much faster SDF creation algorithm lands, plus changes to advection that make it faster by considering the SDF collision value when stepping forward. Adhesion becomes more accurate by using the collision SDF gradient for directions.

Particle handling also gets a leaf-based sorting method described as greatly improving the performance of grid sampling. The solver can better predict future resource needs when reinitialising, called Acceleration in the Advanced to Solver tab. There are also new filters for the output surface SDF, specifically erode and dilate filters, plus additional filtering options for the output surface SDF as a concept in the earlier 1.0.153 to 1.0.175 set. The end result is still an SDF output, not a finished mesh.

If you want a mesh, you still need to convert the surface SDF to a mesh using the VDB Convert node in Houdini. That’s cool for shot work, because it keeps the meshing and any post-smoothing in familiar Houdini territory, with all the usual caveats about voxel size, narrow features, and meshing time. You know the drill.

PCG everywhere: viscosity and pressure style steps

Viscosity gets a major upgrade in 1.0.176 to 1.0.219. It is described as much faster, with a new PCG-based solver. On the control side, multiple control ramps arrive for viscosity and gravity, and gravity and drag can be driven with control ramps in the earlier update set. Viscosity can be driven with a viscosity or temperature particle attribute, and there is collision conductivity for temperature diffusion plus the ability to source collision temperature for melting or freezing effects when particles touch a collider when using viscosity.

In practical terms, these controls push Paradigm closer to how artists like to art-direct liquids. You can tie behaviour to attributes, and you can do it without building a separate rig of custom forces for every shot. Also, a speed limit force bug gets fixed, where values could clamp incorrectly and produce a lower speed limit than expected. That is not glamorous.

Tank workflows and open water domains

Paradigm 1.0 adds a Paradigm Tank node for creating open water. These domains can be animated to have a moving container. Later updates describe the tank node as more stable and efficient at different scales.

For artists, that sounds like fewer edge cases and less time spent re-scaling a scene just to make the container behave. It also points to a workflow that is intentionally separate from classic boxed FLIP tanks, which feel like they belong to a different decade of fluid tools. And yes, I am thinking in decades; I am old.

Outputs, fields, and other useful knobs

The 1.0 notes mention more efficient sinks. Output field precision issues that could cause garbled outputs get fixed. Source shape noise can optionally cull source particles instead of just source values. Some blend modes get fixes when sourcing with source shapes.

None of this removes the need for real pipeline testing. New tools and innovations should always be tested before use in production, especially when the toolset is still evolving across frequent builds and wet behind the ears. (Obvious joke. Watersim. Wet. I need more coffee.)

What it does and does not include

Paradigm does not include narrow-band support yet. It does not currently have reseeding, though it is something likely to be added. A white water solver is in development, and the suggested current approach is to use Paradigm with Houdini’s white water solver.

Ocean spectrum workflows are described as not officially supported. The FAQ describes a possible approach using custom sources if the spectrum is converted to velocity fields and mask, with a desire to add full support for ocean spectrum in the future. That future support is not confirmed.

Compatibility and system requirements

Production builds of Houdini 20.0 and higher are supported. Daily builds are not supported. Windows, Linux, and macOS are supported. Nvidia and Apple GPUs are recommended, and any device that supports OpenCL 3.0 should work. Due to issues with drivers, some GPU may not be supported.

Pricing, licensing, and the parts people actually ask about

Paradigm Indie is $99 as a node locked license and can only be used with Houdini Indie. Paradigm Commercial is $199 as a node locked license and can be used with Houdini Core and FX.

Each node locked license includes one year of maintenance that renews annually, plus a perpetual license for all builds released during the maintenance period. A node locked license can be used on two devices at a time, with a maximum of two licenses per studio. Floating licenses exist for Paradigm Commercial via contacting sales.

The FAQ also states that Paradigm is free to use with Houdini Educational and Apprentice licenses, matching the vendor’s approach for Axiom. During the open beta for version 1.1, it is also free to use with no license or login required, with builds lasting 30 days from the date of publishing. The 1.1 open beta is scheduled to start in early May 2026. There is no release date, and the estimate given is 2 to 3 months, described as just an estimate.

If you are planning to integrate this fluid into a pipeline, test the licensing workflow, expiry behaviour, and Houdini version constraints in your actual studio environment. Then test again on the machine nobody loves, because that is the one that will end up simming the hero splash.

Where this sits in a broader Houdini sim stack

Liquid Thinking: Paradigm Brings GPU Speed to Houdini

Paradigm is a separate solver from Axiom, and the FAQ states there is no two-way coupling between the two. That does not stop you from using them in the same Houdini project, but it does mean you should not expect an automatic handshake between liquid motion and volumetric effects. You can still do the usual tricks using exported fields and caches, but the coupling is a pipeline job, not a one-click feature.

Axiom 4 for Houdini: Faster GPU Pyro With Better Collisions

This is also where expectations need to stay grounded. Paradigm outputs a surface SDF with filtering options, and Houdini converts that to a mesh. White water comes from Houdini’s own white water solver for now. Narrow band and re-seeding are not there yet. If your shots require those features, treat 1.0 as a serious tool that still leaves some work for you.

If you adopt it, run a focused test pass: emission behaviour, collisions with temperature effects, viscosity art direction, SDF meshing quality, and driver stability under OpenCL.

https://www.theoryaccelerated.com/paradigm

https://theoryaccelerated.notion.site/paradigm-1-0-whats-new

https://theoryaccelerated.notion.site/paradigm-1-faq

https://www.theoryaccelerated.com/axiom

The post Theory Accelerated shifts Paradigm 1.0 for Houdini first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

What Project Violet is

Project Violet is a tutorial series made in Houdini 21, of the “Intermediate” Level, by Sam Taylor. The series shows new character features and workflows in Houdini 21 while combining the production readiness of Epic’s MetaHuman system with Houdini rigging and simulation workflows to build an approachable full human workflow.

That matters because it narrows the promise. This is not a inspiration reel, but a character pipeline exercise, with the character coming from MetaHuman and the heavy lifting happening in Houdini. If your day job sits anywhere near character setup, deformation, or character-adjacent sims, Project Violet wants to show you how to reuse, get a decent iteration speed, and getting a believable human through a procedural toolset without constantly falling back to manual rig babysitting.

The pipeline pitch: MetaHuman base, Houdini control

The main idea: take MetaHuman as the starting point and use Houdini for rigging and simulation versatility. It calls MetaHuman “production-ready” (we could discuss that, yet, the character is still in intensive care), and it presents that as the baseline you inherit rather than something you rebuild. Everything after that becomes a question of how far you can push Houdini’s character toolset once you stop spending weeks on initial asset authoring.

Houdini 21: Like good wine (Part1, VFX & Geo)

A separate SideFX-side (hehehe) for Project Violet describes it as an evolution of an earlier character-centric project, and it wants to focus on greater realism and expanded capability of the character, to showcase Houdini rigging and animation capabilities updated for new features and efficiencies in Houdini 21, and demonstrate a character pipeline that emphasises proceduralism while using MetaHumans as a base for the workflow.

That language is still a pitch, but it dosn’t widen the scope. The project is about a workflow, not a single solver trick. It aims to demonstrate procedural character work in Houdini 21 with a MetaHuman starting point.

One practical caveat: none of these claims your exact studio constraints, problems and idiosyncrasies of the colleagues get solved. Your skeleton naming rules, mesh structure, and export requirements still exist. Project Violet shows a route, not a universal treaty.

Houdini character tooling under the hood: APEX Autorig Builder

If Project Violet is the show, the APEX Autorig Builder is one of the stagehands. The APEX Autorig Builder SOP is a tool to interactively apply and configure pre-built and custom rig components through the viewport, which aims to make character setup more intuitive and lets you quickly build a complete rig.

SideFX draws a line between the APEX Autorig Builder SOP and the APEX Autorig Component SOP. The Builder can add multiple rig components, supports interactive viewport rigging, and allows modifying a limited set of component parameters in the viewport. The Component SOP adds one rig component at a time, can be used to create custom components, and exposes the full set of parameters in the parameter editor.

Back to Project Violet, because it glues the workflow in Houdini’s modular rig component approach rather than a one-off rig graph built for a single hero asset. Even if you do not adopt the exact tutorial approach, those constraints and mechanics tell you what Houdini 21 expects when you try to scale character setup.

Unreal and MetaHuman side of the bridge

Project Violet ties into Unreal. Epic’s MetaHuman are tools to assemble a MetaHuman character or create MetaHuman-compatible grooms in SideFX Houdini.

That tells you two things. First, the pipeline is not only about ex/im-porting Alembic and hoping for the best. It involves a toolset that lives in the Unreal ecosystem but targets Houdini as the working environment for certain tasks. Second, the workflow depends on version compatibility and installation details that can change across engine builds, pipeline images, and studio IT lockdowns.

This is where the series may appeal to teams that want to get to motion and deformation problems quickly, or to studios that already standardised on MetaHuman for certain classes of characters and now want deeper procedural control on top.

Either way, run a controlled wokrflow test before you bet a show schedule on it.

https://www.sidefx.com/tutorials/project-violet/

https://www.sidefx.com/docs/houdini/character/kinefx/autorigbuilder.html

https://dev.epicgames.com/documentation/metahuman/metahuman-for-houdini

The post Project Violet links Houdini and MetaHuman first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: KeenTools makes tracking plugins for Nuke, Blender, and Adobe After Effects. The new GeoTracker for SideFX Houdini sits between matchmove and FX layout, and it runs as a SOP node in OBJ and Solaris.

Houdini gets geometry first tracking

GeoTracker for Houdini runs as a native SOP node inside Houdini and works in both OBJ and Solaris contexts. The tool targets geometry based object tracking and camera tracking from 2D footage, with the goal of keeping the full workflow in the Houdini scene rather than bouncing to a separate tracking app.

The core interaction stays intentionally direct. You align an imported or scene built 3D model to the filmed object, then use viewport pinning to keep that object stuck to the plate while the tool reconstructs motion across the shot. That tracked geometry can then feed downstream Houdini work where it actually matters, like driving FX timing, layout, and interactions.

If you already treat layout as the first FX department, this kind of geometry tracked handoff can save a lot of back and forth. It also means you can keep shot scale, scene units, and the rest of your Houdini context consistent, instead of trying to trcak down why a solve looks fine in one app and wrong in another.

Camera solves, lens guesses, and the boring parts

Alongside object motion, the Houdini beta supports camera tracking by aligning static objects or environment models, including LiDAR style environment meshes. It also includes focal length estimation for cases where camera parameters are unknown, plus zoom tracking to follow focal length changes over time.

The Houdini integration also calls out camera import and export in both OBJ and Solaris contexts. That matters because camera plumbing can become the silent time sink, especially when a show uses Solaris for USD centric lighting and layout but still relies on OBJ context for parts of the FX build.

GeoTracker remains geometry based, so you need a 3D model to start tracking. That model can be anything you import or create in the Houdini scene. More detail can help, but extremely dense meshes can get heavy. The beta also includes Surface Masks to exclude parts of the model from tracking when occlusions or reflections would otherwise pollute the solve.

Beta reality check, installs, and pricing

The plugin ships as an open beta and it is free during that beta period. Each beta version stays valid for 30 days, with regular updates planned until a stable release is ready.

Installation stays old school by design. You drop the extracted package into your Houdini packages directory on Windows, macOS, or Linux, and Houdini picks it up. Updates and removal work the same way: delete the old files, replace with new ones, or remove them entirely. There is no auto updater for the beta yet, so you own the housekeeping.

System requirements keep the target clear: Houdini 20.5 or newer on 64 bit Windows, macOS on Intel or Apple Silicon, or Linux. The guidance for graphics hardware stays refreshingly unromantic: a decent GPU that can handle Houdini.

As always, treat new tools like you treat new render builds: test in a controlled setup before you bet a delivery on it, even if the demo looks clean.

https://keentools.io

https://keentools.io/products/geotracker-for-houdini

The post KeenTools GeoTracker enters Houdini open beta first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: VirtuCamera is a mobile virtual camera for realtime camera motion capture into DCCs via plug-ins for Blender, Autodesk Maya, Autodesk 3ds Max, SideFX Houdini, and Maxon Cinema 4D.

What VirtuCamera 2 actually is

VirtuCamera 2 turns an Apple or Android device into a six degrees of freedom controller for a camera inside supported DCC software. The app captures device motion and sends it to the host plug-in over a network connection, then records the move into keyframes when you hit record. It also streams the DCC viewport back to the device for framing while you operate.

The new release includes a redesigned user interface and a full screen viewport. It also adds an Android version alongside iOS, with live viewport streaming over Wi-Fi, capture and streaming at up to 60 frames per second, on device controls for playback and camera switching, focal length sliders, and the ability to scale camera movement for longer travel.

Supported DCCs and versions, now with fewer workarounds

The current plug-ins list the following versions: Blender 5.1, 5.0, and LTS 4.5, Autodesk Maya 2027 and 2026, Autodesk 3ds Max 2027 and 2026, SideFX Houdini 21, and Maxon Cinema 4D 2026.

If you live in mixed DCC land, this is the rare case where one handheld capture app claims first-party plug-ins for five major platforms at once. You still need to validate the exact DCC build and pipeline constraints in your environment, but at least the compatibility targets are stated clearly.

Viewport streaming, latency, and why tethering exists

VirtuCamera 2 streams the viewport to the device so you can frame from the phone or tablet. On paper, that reduces the whole remote monitor dance. In practice, the network decides how cinematic your day will be.

The tethering documentation spells out why. Wi-Fi can drop packets, jitter, or kill long connections due to congestion, roaming, power saving, and network restrictions even when normal browsing looks fine. The guide recommends tethering as a way to make the computer treat the phone as a wired network interface, avoiding Wi-Fi variability and often improving latency. USB tethering also commonly keeps the phone charging during use. If you have ever watched a handheld take turn into a stuttering mess at the exact moment the director liked it, you already know why this section exists.

There is also Ethernet tethering, described as plug and play across macOS, Windows, and Linux, assuming you use a USB to Ethernet adapter compatible with the phone so the device recognizes it as a network interface. Also, test this stuff before you trust it in production. Network quirks love showing up when they shouldn’t be there.

Scale settings, because meters are not a suggestion

VirtuCamera 2 includes a scale setting designed to map real world movement to DCC units. You need to establish how much 3D software units equal real world units. In the app settings, you set a value so that one meter in the real world matches the software units you choose.

That sounds simple, but it solves a recurring problem in virtual workflows: a physically reasonable move can become a microscopic nudge or a teleport depending on scene scale. Making this an explicit setting in the app puts the responsibility in the right place. You calibrate once per scene scale, then operate like you mean it.

If you work across projects with different unit conventions, write the chosen mapping into your show notes and keep it consistent. Otherwise you will spend an afternoon wondering why yesterday’s operator feels like they had longer arms.

https://twitter.com/CosmoMidias/status/1779701979431985161

Plug-ins, Python, and rolling your own integration

VirtuCamera’s official site shared the underlying Python module. VirtuCamera plug-ins for Maya, Blender, Houdini, Cinema 4D, and 3ds Max are based on the PyVirtuCamera module, and PyVirtuCamera uses FFmpeg for video encoding. PyVirtuCamera exists as a public repository on GitHub and a Python module API to create VirtuCamera plug-ins, with downloadable releases and a wiki for usage details.

This matters for two audiences. If you are a pipeline TD, a published API reduces the risk of being blocked by missing official plug-ins for your in house toolset. If you are a plugin developer, a shared module means feature parity across host DCCs depends on the same core, not five separate implementations drifting apart.

Somebody will ask whether this means you can jam it into anything. The official site says you can create your own plugin with the PyVirtuCamera Python API and that it does not need to be a DCC.

Pricing and availability

On the German Apple App Store and on the Google Play listing, VirtuCamera 2 is priced at 18€ currentl. On the US App Store listing, it is priced at $20. If you are evaluating total cost, also account for the time cost of validating networking, device mounting, and scene scale conventions. The app cost is rarely the expensive part.

https://virtucamera.com/

https://apps.apple.com/de/app/virtucamera-2/id6761327593

https://play.google.com/store/apps/details?hl=en&id=com.theweirdbyte.virtucamera2

https://github.com/theweirdbyte/PyVirtuCamera

The post VirtuCamera 2: The Weird Byte goes Android first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: World Creator is a GPU terrain tool from BiteTheBytes with bridge plugins for Blender, Cinema 4D, Godot, Houdini, Unity, and Unreal Engine.

The big headline is a small textbox

World Creator 2026.4 lets you type mathematical expressions into numerical fields. That sounds like a nerdy feature, because it is. It also means fewer hand-calculated offsets, fewer copy-and-paste accidents, and more repeatable setups when building layered terrain that needs to stay art-directable. The same release adds full decal support. Decals are often the difference between a terrain that looks generated and one that looks dressed. They also help when you need localised detail without turning every change into another texture bake cycle.

Seams get quieter

Terrain normal blending wants to improve object-to-terrain transitions, so reduce the obvious cut line where a hero object meets the ground. If you build environments where a single rock edge can pull focus in a wide shot, this is the kind of “small” addition you end up using all day. World Creator 2026.4 also introduces configurable object shadow settings. That gives artists another lever for matching scene lighting behavior when objects sit on terrain, especially in lookdev and layout passes where readability beats physical purity.

Performance fixes that actually sound like production

VRAM scaling links the Max Object Count to available GPU VRAM. In practice, this ties a key scene limit to the hardware ceiling instead of a fixed guess, which can make scenes behave more predictably across machines.

There is another performance change that targets daily workflow friction. Shape Design Mode no longer triggers automatic material recomputes.

Bug fixes: import, UI, syncing, crashes

World Creator 2026.4 fixes an importing issue where Raw and R16 formats were hidden during import. It also corrects compass centering in the UI. On the data side, the update fixes missing Baseshape Color and Emissive toggles in the sync.xml file, resolves issues involving empty model objects, and fixes Stochastic Distribution failing when used with height blending. The release notes also state that several crashes were resolved.

Community Edition and licensing tiers

BiteTheBytes now offers a free Community Edition, positioned as a way to learn the realtime terrain workflow before upgrading to a commercial license. The export is disabled in Community Edition, while paid tiers enable export, with Indie listed as up to 8k and higher tiers listed as unlimited.

Yearly subscription pricing on the buy page lists Indie Yearly at $49 per year for revenue under $100,000, Professional Yearly at $99 per year for revenue up to $200,000, Studio Yearly at $199 per year for revenue up to $1,000,000, and Enterprise Yearly at $799 per year for revenue above $1,000,000.

Perpetual pricing includes Indie Perpetual at $99 and Professional Perpetual at $199. Enterprise Perpetual includes 12 months of updates with an optional renewal listed at $449 per year. Lifetime pricing shown includes Indie Lifetime at $249, Professional Lifetime at $499, Studio Lifetime at $999, and Enterprise Lifetime at $3,999.

https://docs.world-creator.com/release-notes/version-2026.x/world-creator-2026.4

https://www.world-creator.com

The post World Creator 2026.4 adds expressions and decals first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Redshift is a production renderer that plugs into DCCs like Cinema 4D, Autodesk Maya, SideFX Houdini, Autodesk 3ds Max, Foundry Katana, and Blender, so lighting TDs can argue about samples in the app they already love.

The night shift arrives everywhere

So, after sorting through the heap, it is time to talk about Redshift, specifically. Redshift 2026.5.0 adds a night sky representation to the Sun and Sky system across hosts, including stars, moon, and Milky Way, with time and location controls.

That matters less for hero closeups and more for the boring shots that still need to ship: wide establishing frames, background domes, and lighting continuity on sequences that bounce between day and night. And also, to keep the internet sleuths ansd “Actually-s…” at bay.

The same update also includes a fix for the Physical Sun and Sky light where the milky way could render in flipped coordinates. It is the kind of bug that makes you doubt your compass and your life choices at the same time.

OpenPBR takes the default seat in Cinema 4D

For Cinema 4D, OpenPBR becomes the default material, and the default material list in preferences gets updated. The shader model itself comes from OpenPBR, the OpenPBR Surface specification hosted under the Academy Software Foundation umbrella.

In practical terms, the change means new scenes in that host start from OpenPBR unless a user switches the preference. It also comes with a cleaned up material menu that puts OpenPBR up front and pushes older options out of the spotlight.

If your pipeline has older material libraries, this is the moment to check how presets migrate, how template scenes behave, and whether old lookdev assumptions still hold. New tools and innovations should always be tested before use in production.

Texture Displacement gets smarter and less picky

Texture Displacement continues to expand, building on the system introduced earlier as an alternative to vertex displacement. In 2026.5.0, texture-based displacement gains preliminary UDIM and UVTILE support. It also gets mirror repeat mode when smart baking is enabled, plus improved quality when displacement is driven by UV projections.

There is also enhanced auto bump mapping support meant to improve bump mapping quality when used with displacement nodes. This addresses a common pain point where displacement and bump interplay can get noisy or fight each other in shading.

A set of fixes targets stability and interactivity too. The release notes list multiple cases where texture displacement could disappear or show artefacts in interactive preview rendering when using bucket mode, and those issues have received fixes.

One more fix calls out self-shadowing artefacts on objects with extremely high polygon angles when using Texture Displacement. If you have ever seen displacement turn into a crunchy self-shadowed mess on near-planar geometry, that line will feel oddly personal.

Some Cinema 4D specific fixes also land here, including a bug where UDIMs were not correctly rendered when using Team Render, plus a bug that could cause random black images when rendering heavy meshes with deformation blur enabled. Redshift 2026.5.0 also sets a minimum plugin requirement of Cinema 4D 2026.2.

In the middle of all that, one of the most important workflow wins is banal: fewer special cases. The more often displacement works the same way across UV layouts, projections, and preview modes, the less time artists spend building around the renderer instead of using it. Also, please rmember that displacement tends to be the first place where a scene crosses from fine to on fire, so keep an eye on memory and subdiv settings when you roll this out.

AMD ray tracing via HIP RT, marked experimental

Redshift 2026.5.0 adds experimental support for HIP Hardware Ray Tracing, also known as HIP RT. HIP RT itself is an AMD HIP RT ray tracing library designed for applications using HIP.

The release notes call the feature experimental. That is a polite way of saying you should not bet a deadline on it without testing it on your actual scenes, drivers, and farm images.

The same build also mentions improved render startup performance in scenes with high primitive counts when using Hardware Ray Tracing. Together, those notes make a clear point: hardware ray tracing paths continue to expand, and more of the heavy lifting is expected to land in that codepath over time.

Windows on Arm joins the CPU party

Redshift 2026.5.0 adds native Windows Arm64 support for Redshift CPU in Cinema 4D, ZBrush, and via the command line renderer. That is specifically CPU rendering, not GPU rendering. For the broader platform context, Windows on Arm covers Arm64 devices running Windows, including systems where native Arm apps run without emulation while other binaries may run under emulation.

If you are eyeing Arm based Windows laptops for travel kits or lightweight previs work, this change removes at least one hard block for CPU rendering workflows in those supported routes. It does not magically turn an ultraportable into a render node, but it does make it a more honest option for tests, turntables, and emergency output.

Bottom line for production

None of that removes the usual responsibility from leads and TDs. Update one step at a time, validate looks against show frames, and test your farm and plugin versions before you flip defaults for everyone. That advice feels boring, right up until it saves your weekend.

https://www.maxon.net/en/redshift

The post Maxon ships Redshift 2026.5 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Beeble Background Remover is a Cloud roto and matte extractor for comps, now offering CorridorKey or MatAnyone before upload, so your key tests can happen before your pipeline meeting turns into a sequel.

What changed in Background Remover

Beeble‘s Background Remover now lets you choose between MatAnyone and CorridorKey before you upload footage. MatAnyone stays positioned as the general-purpose option. CorridorKey is positioned as the green screen option, aimed at cleaner edges and more accurate keying on chroma key shots. Background Remover runs only in the Cloud app and does not run in the desktop product.

The fastest way to try it without committing

CorridorKey has the kind of momentum that makes people want to try it immediately, and also the kind of setup that can make them postpone it indefinitely. If you do not want to download code, install dependencies, and explain to your producer why your machine is now compiling something called a model, running CorridorKey inside the Background Remover toolkit gives you a low-friction way to test it on your own footage first. That includes testing it against your current keys, and checking whether your exports land cleanly in your comp toolchain, without rebuilding that toolchain just to run an experiment.

How CorridorKey was invented

CorridorKey started as a response to a workload problem. A greenscreen-heavy show needed a lot of shots, and the team wanted an automated way to cut subjects out so they could spend time on the creative side of VFX instead of hand-cleaning keys frame after frame.

The design focus landed on a specific compositing headache: a greenscreen edge pixel often contains a mix of foreground and background light. A matte can be good and the color can still be wrong, because the plate already baked the screen contribution into semi-transparent detail. The CorridorKey approach targets a straight color foreground output paired with an alpha output, so semi-transparent materials, motion blur, and hair can keep behaving like actual transparency instead of looking like tinted cutouts.

Training data was coming from CG so the model could learn from mathematically clean answers. The workflow renders greenscreen plates, then renders the same foreground without the background and with a perfect alpha, giving the model ground truth for both color and transparency. Scale was coming from procedural variation, including procedural scene generation work in tools like Houdini and Blender to produce many variations in lighting, materials, objects, and motion without rebuilding each shot by hand.

Early results were treated as tests and iterated on through retraining. One tactic for pushing quality was to composite results over random backgrounds and neutral gray during testing, so leftover contamination becomes obvious and gets punished during training. The tool is being used as a first step in a broader pipeline, with outputs intended to drop into comp and realtime contexts in apps like Adobe After Effects and Unreal Engine.

What you get out of Beeble after a run

If you are testing CorridorKey for greenscreen work, this matters because the outputs determine how painful your handoff is. A quick trial that ends in a format conversion detour still counts as pain. It just wears a different hat.

Background Remover is built around alpha extraction for compositing and VFX workflows. You can upload a video, an image sequence, or a single image, then download results intended to slot into a comp.

On the Cloud pricing page, export options are listed as RGBA exports in MOV or PNG sequence and alpha exports in MP4 or PNG sequence. MOV here refers to the QuickTime container, PNG refers to the PNG format, and MP4 refers to the MPEG family container.

Pricing, credits, and practical limits

Background Remover usage is credit-based. The Cloud pricing is around image uploads as consuming one credit per image and video uploads as consuming one credit per second of video.

The plans listed include a free Starter tier that includes ninety credits per month and is labeled non-commercial. Two paid tiers have Background Remover included. “Creator” is listed at nineteen US dollars per month or sixteen US dollars per month when billed annually, with five hundred forty credits per month. “Professional” is listed at seventy-five US dollars per month or sixty US dollars per month when billed annually, with two thousand four hundred credits per month.

Per-upload maximums for video length are thirty seconds on the five hundred forty credit tier and one minute on the two thousand four hundred credit tier. There is also a batch upload up to twenty files at once on the paid tiers.

A production reality check

CorridorKey is a model option, not a replacement for judgement. Every keying tool behaves differently across compression, sensor noise, spill, lens artifacts, and the very special chaos of talent wardrobe choices. Test CorridorKey on your own porudction plates before you trust it with a deadline, and keep your existing approach ready for the shots that refuse to behave.

If the results look good, treat the first integration step as a controlled experiment: run a small batch, validate edge stability, validate color behavior in the semi-transparent areas, validate the exports in your comp, then scale up. That is less romantic than a revolution, but it is how tools earn their place in compositnig pipelines.

https://docs.beeble.ai/beeble/background-remover

https://github.com/nikopueringer/CorridorKey

https://beeble.ai

The post Beeble adds CorridorKey green screen model first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Natsura, the Houdini foliage toolkit lives inside Houdini, can push assets to Unreal Engine workflows, and now leans harder into assemblies, mapping, and export glue.

What shipped in 0.6

Version 0.6.0.0 landed on March 25, 2026, with support for Houdini 20.5 and Houdini 21.0. The release calls out modular effectors, Nanite assemblies, an assembly decorator, a revamped UI, analytics, scan extension, and Houdini 21 support. The update introduces an Assembly workflow aimed at quickly rigging twig and branch libraries and assembling canopies. There is also a set of tools for Unreal Nanite skeletal assembly support, paired with wind authoring tools. Assembly-related nodes are flagged as experimental in the release notes, though. Be careful.

On the shaping side, the release adds a modular effector system like a bolt on simulation modifiers with no VEX required. Effectors are an extendable stack, and the base effector node supports writing VEX to extend the simulation and respond to geometry and inputs.

Assemblies, decorators, and Unreal export

The release adds new nodes for an assembly pipeline, including an assembly resource node for mesh library import and auto rigging, an assembly decoration node for canopy decoration that can pick modules based on traits and transform instance hierarchies with rigid rotations, and a classify node for trait-based module classification.

Export to Unreal related workflows gets multiple mentions. The export node for Unreal Nanite assembly lists updates including material support, skeletal and static assembly, fixed instance naming, and removal of a transform on points that broke instancing. There is also a LOP node for USD workflows that creates a Nanite assembly for SOP based creation.

Wind support is expanded through new nodes for wind initialisation and validation, wind class assignment for Unreal, a wind preview visualisation tool that is functional but not accurate or meant to look good, and a node that exports UE5 DynamicWindSkeletalData as JSON. If your environment team already has a wind data convention, this is the part to validate early, especially around naming, material binding, and what your in-engine tooling expects.

Effectors, guides, and growth controls

Several new effectors are listed: deflection, magnet attraction, gravitropism, gravity, and noise based growth perturbation. The grow node line gets a long set of updates in this release, including a new spiral parameter with absolute and relative modes, integration with the effector stack, and an updated decorator stack format to match the effector stack.

One practical change is the way mapping and prim construction are described. Map prim construction is deferred to grow, which is described as reducing node count and compile time. There is also an instant colour preview mentioned, plus options for skeleton swapping and custom draw modules. Growth workflows appear to be treated as a family of versions, with backwards compatibility restored across multiple grow versions and various mapping and parameter warning cleanups.

Rig simplification and reskinning

Rig simplification tooling shows up both as a new simplify rig node and as updates to a simplify rig reskin path, as well as multi stem tree support, chaining of simplify nodes, and added carve method and max joints count. If your pipeline needs a predictable joint budget for game ready trees, this is where you will want to spend time.

Analytics and privacy details

Analytics is “opt-in” and disabled by default, with no data collected without explicit user consent. If you work in an environment with strict compliance rules, the opt in default and EU cloud note are helpful details, but you still need to run your own review. Make sure your team knows what is allowed, and that tool telemetry decisions match your facility policy.

The notes also state that 0.7 will be a breaking release, and this 0.6 release includes precursor work such as a standardised mapping architecture, groundwork for decorator cook trigger decoupling, and a foundation for mappable decorator parameters. Read that as a warning to keep a rollback plan, and to budget time for update testing before you touch active porudction setups.

Compatibility notes for Houdini artists

Houdini 21 support is obvious, including mention of an APEX graph schema enforcement fix. The release also claims continued full Houdini 20.5 support, plus compatibility work around Qt bindings.

In practice, this release spans a lot of surface area: SOP level nodes, UI panels, export to Unreal, USD workflow hooks, analytics, and a mapping engine refactor. That is a lot of moving parts for a minor release number, even if the changelog is transparent about what is experimental. Treat the upgrade like you would any node library update: keep a copy of old scenes, validate the graphs, and test exports end to end before shipping anything client facing.

https://www.natsura.com/

The post Natsura 0.6 adds effectors and Nanite export for Houdini Foliage first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Cargo is a desktop asset browser that connects to Blender, Unreal Engine, Cinema 4D, and more, so you can browse, download, and send models and materials straight into scenes without spreadsheet cosplay.

One app, two libraries, fewer tabs

KitBash3D made the app as the “front door” for discovering and importing its kits, with the bundled library concept now expanded to cover both catalogs.

Two previously separate collections now live side by side inside the same interface, with one sign-in and one search. The combined catalogue includes kits and models alongside scan-based materials, textures, and surface imperfections, all presented as a single system meant to keep structure and surface close together.

That unification also shows up in how content gets packaged. The app emphasizes a consistent pipeline based on OpenUUSDSD and MaterialX, aiming to keep hierarchies and instances intact while translating materials into native shader setups for the target renderer. This is a foundation-level rebuild rather than a cosmetic refresh.

The free starter pack is not tiny

A free account includes a curated set of assets you can browse and download without a credit card. That free set is described as 100 plus assets, and an independent count lists 483 total free items. Its a start :)

245 models, largely building and vehicle parts from two free kits plus a set of semi-abstract biomorphic forms. There are also 189 materials, including fabric, brick, and tile options, plus 44 textures of mostly geometric grids with additional bokeh and dirt textures.

If your day job involves pitching lookdev choices at 9am and shipping frames at 6pm, the free selection matters because it lets you test the pipeline end-to-end. You can confirm how the importer behaves, how instances land, how shader graphs translate, and how your render engine reacts to the material schema before you commit budget.

Search got smarter, and also weirder in a good way

The browsing experience leans hard on discovery features designed to reduce the number of times you type a noun and get punished for it. Smart Search supports natural-language descriptions like “dark industrial”, interpreting intent rather than matching exact keywords. Image Search lets you drop in a reference image and find assets that match its visual style. Show Similar pulls results that share visual DNA with the currently selected asset, encouraging variation hunting without restarting the search. Random Roll reshuffles results within your active filters to push controlled surprise when your brain has gone full beige.

On the surface, these read like creature comforts as they target the most annoying part of asset libraries: you know what you want, but you do not know what the library decided to call it. Natural language and visual matching try to bridge that gap, and the similar and random tools try to keep you moving when the first pick is close but not quite it.

This is also where the unified catalog changes behavior. Similarity searches and random rolls can traverse the combined library rather than staying fenced within a single vendor silo, so discovery sessions can jump between hard-surface set dressing and material detail work without switching apps or accounts.

One click import, persistent connections, and fewer ritual steps

The workflow pitch is straightforward: select an asset, then send it to your scene. The importer is organizing geometry into clean hierarchies and instances, reusing existing assets automatically, and translating materials directly into the native format of the chosen renderer based on render settings. The goal is predictable structure on arrival, so your outliner does not turn into a haunted attic.

The connection model matters as much as the importer. The app supports connecting to installed DCCs and then sending assets through a targeted connector, rather than relying on manual export and import steps for each move. A desktop-based app is available on Windows and macOS including Apple Silicon machines.

Supported host applications and versions are listed in current documentation. The app supports Autodesk 3ds Max versions 2021 through 2024 using a non-USD legacy plugin workflow. It supports Autodesk Maya versions 2024 through 2026. It supports SideFX Houdini versions 20 through 21, including render paths that reference MaterialX. It supports Unreal Engine versions 5.2 through 5.7 using official Epic Games Launcher builds, and it supports Blender versions 4.2 through 5.0 when downloaded from blender.org.

Render engine support is Redshift, OctaneRender, V-Ray, and Arnold. Blender is listed with Cycles and Eevee. Maya is listed with Arnold and Redshift. Houdini is listed with Karma, Mantra, Arnold, and V-Ray.

The practical takeaway is that the connectors and supported versions are specific, not vibes-based. If you live on a source-built Unreal branch or a newer 3ds Max version outside the supported range, you should expect friction and plan your testing accordingly. Also: USD is king here – it might be time to get on the train.

Pricing and membership tiers

Cargo 3.0 is free to download. Subscriptions are three main individual plans and a teams option.
Greyscalegorilla Library plan at $39 per month or $468 billed yearly, which includes 3,500 plus scanned and procedural materials, 1,000 plus models, 650 plus textures, and 600 plus HDRIs.
The KitBash3D Library plan at $59 per month or $708 billed yearly, and includes 20,000 plus textured models, 2,000 plus game ready assets, 300 plus hero props and vehicles, and 200 plus Substance Source materials.
And an Everything Bundle at $79 per month or $948 billed yearly. The Everything Bundle includes full access to every new release from both libraries under one subscription.

There are also Team plans at $99 per user per month billed annually with a four-seat minimum.

What to actually do with this on a deadline

Start with the free assets and run a full pipeline pass in a throwaway project. Test search with a mood phrase, then test Image Search with a real reference frame from your show bible. Send a small cluster of assets into your primary DCC, then verify the resulting hierarchy, instances, and material graphs. Render a quick turntable in your production renderer, then repeat the same asset in a second host app if your studio straddles multiple tools.

If you rely on 3ds Max, treat the legacy plugin note as a sign to double-check compatibility before you promise anything to your producer. If you rely on Unity, the end-of-life date for the older integration means you should map out alternatives now, not when the build breaks the night before a milestone.

Cargo 3.0 sells itself on momentum. The real win is not that it can download assets, every library can do that. The win is whether it reudces the number of tiny interruptions that burn your attention budget. Install, connect, search, send, render, repeat. Then decide if the time saved is real enough to justify the subscription tier you need.

https://kitbash3d.com/pages/cargo

https://kitbash3d.com/pages/pricing
// Quoted info
https://help.kitbash3d.com/en/articles/7833635-cargo-3-0-supported-3d-software-and-render-engines

The post Cargo 3.0 merges two asset libraries first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Feature animation gets performance-obsessed

A new set of feature animation sessions puts character performance front and centre. Supervising Animator Adam Sarophim will present how performance-driven animation gets built at Sony Pictures Imageworks using work from KPop Demon Hunters and GOAT. The session description focuses on crafting emotion, personality, and audience connection through movement, timing, and subtle detail.

Animator Jacob Frey will present The Animation of Zoomania 2 and describe collaboration between art and technology as part of the filmmaking process at Walt Disney Animation Studios. The session description frames the work as an example of how tools and artistic intent meet inside a feature pipeline. Details about specific story beats, pipeline tooling, or shot counts are not specified in the Sources.

Two European-leaning projects also land on the slate: The Last Whale Singer (a teenage humpback whale named Vincent), and a procedural real-time pipeline segment called Trash Island. The speakers listed for that session are Jan Hofmann, a CG Supervisor and Unreal Engine expert at Telescope Animation, and Amir Ashkezari, an FX Supervisor and Technical Director at PFX. The pipeline description centers on Houdini generated assets moving via OpenUSD into both real-time Unreal Engine and a traditional Autodesk 3ds Max and V-Ray workflow, connected by custom tools intended to support daily collaboration between studios in different locations.

Zako is a feature project based on a true story about an Armenian painter during World War II and the Soviet Union. Director Tigran Arakelyan of OnOff Studio will present how VR animation can serve as a core creative tool for sketching, staging, and animating directly in 3D space, as well as practical methods for integrating VR animation into a feature film production pipeline.

AI talks that aim past hype

The Artificial Intelligence track is around practical production use and the question of what AI should do in modern pipelines, with an emphasis on keeping a human artist in the loop.

Ben Grossman of Magnopus is listed for an individual session, followed by a panel appearance. Mohsen Mousavi, Senior Director of Visual Pioneering at Eyeline Studios, is also in an individual session and on the same panel. Hao Li, founder of Pinscreen, is about to present on work spanning computer vision and facial performance technology, having completed AI work on Fallout Season 2. The track is curated by Mike Seymour, co-founder of fxguide.

Cinematography goes deep into the lens mess

The Cinematography track highlights craft from stop-frame production through to photoreal VFX . Cinematographer Dave Alex Riddett will present Work Aard Play Aard, a behind-the-scenes look at decades of cinematography at Aardman and the practical skills involved in stop-frame storytelling.

VFX Supervisor Victor Perez will present GLASS: Capturing the Lens Look for Photorealistic VFX. The session description focuses on lenses having distinct optical characteristics including distortion, chromatic aberration, field curvature, vignetting, iris behavior, and micro-contrast, and on methods to analyze, measure, and reconstruct those characteristics inside VFX pipelines so CGI inherits the visual identity of the camera that shot the plate. The track is curated by Sara Coppola-Nicholson, Director of Research and Education at Cooke Optics.

Partners bring cloud and tools to the conversation

Two newly announced partners add their own angle on production infrastructure and creative tooling. AWS Visual Computing is about cloud-based solutions for visual effects, animation, and 3D content production, including scalable rendering, virtual workstations, and high-performance storage optimised for media workflows. It also highlights AWS Deadline Cloud as a fully managed render management service.

Foundry is … well, if you don’t know the company making Nuke, you should reconsider and read the rest of this website. The partner programming showcases compositing, lighting, look development and texturing, with participating studios named as Industrial Light and Magic, RISE FX, Outpost VFX, and Mikros Animation.

The partner section also includes an in-person day at Raum Mannheim featuring project insights on Fallout Season 2, Netflix’s The Dinosaurs, and Teenage Mutant Ninja Turtles: Chrome Alone 2 – Lost in New Jersey, plus a talk by Director and VFX Supervisor Hugo Guerra.

Dates and tickets, plus the reality check

Tickets are on sale, and the “On Site” runs at Haus der Wirtschaft in Stuttgart from May 5 to 7, Online and On Campus run on May 8, and On Demand runs from May 9 to June 9. See all of you there!

https://fmx.de/en

The post FMX 2026 adds animation, lens talks and of course AI first appeared on DIGITAL PRODUCTION and was written by Bela Beier.