Here comes Houdini 22

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.