Are you struggling to get natural jiggling in Houdini when simulating soft bodies? Do your rubber-like objects feel too rigid or collapse unrealistically under collisions? You’re not alone in facing these challenges.
Many artists find soft body dynamics daunting: parameters have obscure names, collisions clip through geometry, and simulations chew up time without delivering the look you need.
If you’ve ever wondered how to turn a plain sphere into a wobbly jelly cube or a bouncy rubber ball that deforms convincingly, this guide is for you.
We’ll break down the core setup, explain stiffness and damping in simple terms, and show you a clear workflow for handling soft collision effects efficiently.
By the end of this introduction, you’ll know exactly what to expect and how to start refining your soft body simulations with confidence.
What are Houdini soft body systems and how do Jelly, Rubber, and soft collisions differ?
In Houdini, soft body systems simulate deformable geometry under force. Two popular frameworks are the FEM Solver and the Vellum Solver. FEM uses finite elements for accurate stress–strain behavior, while Vellum relies on mass-spring networks for speed and interactivity. Both support soft collisions by preserving volume and enabling self-collision resolution.
Jelly and Rubber are presets reflecting different material responses. Jelly typically uses low stiffness and high damping, yielding slow deformation and quick energy loss. Rubber does the opposite: high stiffness, low damping, and greater bounce. You can switch between these by adjusting constraint stiffness, damping ratio, and pressure settings in the Vellum Configure Softbody node.
- Jelly: low stiffness (20–50), high damping (0.5–0.8), soft rebound
- Rubber: high stiffness (200–500), low damping (0.1–0.3), elastic bounce
- Soft collision: thickness parameter, collision margin, self-collision toggles
Soft collisions require careful thickness and collision margin tuning to avoid interpenetration. In Vellum, enable “Self Collisions” and set a collision thickness around 1–2% of object size. For FEM, adjust volume constraints and use the Primitive Collision node to maintain surface integrity. Proper caching and substepping ensure stable results, especially with large deformations.
How to set up a production-ready soft body rig in Houdini: nodes, constraints, and solver selection
Begin by creating a dedicated geometry container for your soft body. Import or model your mesh, then dive into SOPs and add a Vellum Configure Soft Body node. This node automatically generates a point cloud and establishes basic distance constraints. Use a VDB from Polygons if you need consistent collision thickness across complex shapes.
Next, refine constraint behavior using Vellum Constraint Properties. Assign groups for tension, shear, and volume stiffness. Increase tension stiffness for rubber-like springs or reduce it for jelly-like wobble. Use bounding groups to protect rigid areas. Procedural attribute wrangling lets you drive stiffness per face or by distance to an impact point.
- Create Scatter on mesh to set rest points
- Use Connectivity to define constraint pieces
- Apply Vellum Configure Soft Body, then Vellum Constraint Properties
- Output to an AutoDopNetwork for simulation
For the solver, choose Vellum Solver for fast, stable work on interactive rigs. Opt for the FEM Solver when you need realistic material behavior—especially under large deformations. The Bullet soft-body solver is ideal for high-performance rigid-to-soft collisions in crowd simulations. Adjust substeps and collision padding in the DOP network to avoid jitter and interpenetration.
Step-by-step: Create a jelly simulation with Vellum — setup, tuning, and export
Essential Vellum solver and constraint settings (stiffness, damping, stretch limits)
In Houdini, a jelly simulation begins by converting your source mesh with the Vellum Configure Soft Body node. This node generates a mass-spring network; springs derive from the mesh’s edges. Tuning the spring stiffness parameter controls rigidity, while bend stiffness defines how easily folds form during deformation.
Next, open the Vellum Solver. Increase the constraint iterations to improve collision accuracy, and set substeps to prevent fast motions from blowing out. The global damping factor simulates internal friction, reducing oscillations. Stretch limits on the constraint properties enforce how far each spring can extend beyond its rest length, protecting against unnatural over-stretching.
Best practices for converting simulated vellum to render geometry and caching (ROP, geometry cache formats)
After a stable simulation, use a Vellum Post-Simulation node or a File Cache SOP set to .bgeo.sc for efficient local playback. When exporting for rendering, convert the Vellum particle cloud to render-ready polys with the Vellum to Polygons SOP. This rebuilds a continuous mesh that holds shading attributes and UVs.
For long shots or networked pipelines, prefer Alembic archives via a geometry ROP. Alembic maintains velocity and transform channels, ensuring motion blur fidelity. The ROP Geometry Output node in your out-network lets you specify file patterns, frame ranges, and compression. Using .bgeo.sc for simulation iterations and Alembic for final renders streamlines caching and playback across multiple Houdini instances.
Step-by-step: Simulate rubber-like elasticity using FEM and strain/volume preservation techniques
In Houdini, achieving a convincing rubber-like elasticity hinges on combining a well-structured tetrahedral mesh with a Finite Element Method (FEM) solver configured for strain and volume control. FEM computes internal stresses based on material properties, while explicit strain and volume constraints maintain shape fidelity under large deformations.
Follow these steps to set up a stable, high-quality rubber simulation:
- Mesh preparation: Start with your high-res surface. Use IsoOffset or VDB to create a solid volume, then apply the Tetrahedralize SOP. Ensure uniform tetra size—aim for 0.05–0.1 units for mid-scale props.
- DOP network: Inside a DOP Import Network, create a FEM Object, link your tetra mesh, and add a Finite Element Solver. Connect gravity and collision geometry (Static Object) to your solver.
- Material model: In the FEM Solver, select Neo-Hookean or Saint-Venant Kirchhoff. Set Young’s Modulus ~1e6 and Poisson’s Ratio ~0.48. These values deliver high elasticity with near-incompressible behavior.
- Strain preservation: Enable strain energy computation. Under the FEM Solver’s Advanced tab, adjust the Stretch and Bend stiffness multipliers to fine-tune how the mesh resists deformation paths.
- Volume preservation: Activate the “Incompressible” flag or insert a Volume Preservation Constraint DOP. Assign a weight (1–10) to enforce internal pressure and avoid collapse.
- Simulation tuning: Run short tests, then tweak damping (0.01–0.1) to damp high-frequency jitter. Monitor deformation heatmaps via the FEM Solver’s “Stress” output.
| Parameter | Recommended Range | Effect |
|---|---|---|
| Young’s Modulus | 5e5 – 2e6 | Controls overall stiffness |
| Poisson’s Ratio | 0.45 – 0.49 | Enforces near-incompressibility |
| Damping Ratio | 0.01 – 0.1 | Reduces oscillations |
| Volume Weight | 1 – 10 | Strength of volume constraint |
By combining a clean tetrahedral mesh, an FEM Solver with a neo-Hookean model, and explicit strain/volume constraints, you’ll achieve robust, rubber-like deformations. Always validate your settings on a simplified proxy before committing to a full-resolution sim.
How to set up reliable soft collisions with animated, rigid, and self-colliding geometry
When building soft body sims in Houdini, predictable collisions hinge on consistent geometry updates, proper velocity transfer, and solver ordering. Whether your soft body is meeting an animated surface, colliding with a rigid pack, or self‐intersecting, you must drive the solver with accurate collision shapes, maintain per‐frame motion vectors, and adjust collision thickness to prevent jitter or tunneling.
For animated colliders, import your deforming mesh as a SOP object in the DOP network with “Use Deforming Object” enabled. Ensure the solver sees a valid v (velocity) attribute by feeding a Trail SOP or the Attribute Velocity SOP before the DOP Import. This creates smooth contact response and avoids the solver guessing motion between frames. If your animation has sharp keyframe jumps, add substeps in the Vellum Solver to capture fast movements.
When mixing soft bodies with rigid, packed geometry, drive the rigid side through an RBD Packed Object node. Inside the same DOP network, connect your Vellum Solver to collide against the Bullet Solver output. In Houdini 18+, enable “Vellum RBD Collider” on the Vellum Solver to automatically generate collision constraints. Tune the collision “Threshold” and “Stiffness” parameters so your jelly or rubber reacts realistically without sticking to the pack.
For self‐collision on a single soft mesh, activate “Enable Self Collision” in the Vellum Configure Soft Body node. Define a lightweight group for faces that should avoid interpenetration, then adjust the Collision Constraint’s Distance and Damping values. A smaller collision distance prevents visible gaps, while sufficient damping keeps the mesh from jittering on itself. If performance drops, reduce the self‐collision group or increase the inner search radius in the solver to limit constraint counts.
How to optimize, cache, and prepare soft body sims for render and compositing pipelines
Efficiently handling a soft body simulation begins with minimizing overhead during playback. Use a low-resolution proxy or guide mesh to iterate faster. In DOPs, disable unnecessary forces and enable “Freeze Pre/Post Solve” on static objects. This stops redundant calculations and keeps your solver focused on deformable geometry.
Next, implement a robust caching workflow. The File Cache SOP suits quick iterations inside SOPs, while the DOP I/O ROP offers frame-sequenced output directly from the simulation node. Point your cache to local SSDs for high throughput. Always name your outputs with padded frame numbers and relevant sim labels to avoid confusion in larger pipelines.
- Prune attributes: delete velocity or rest data if unused in shading.
- Crop the bounding box: limit simulation extents to active areas.
- Use packed primitives: reduces memory and speeds I/O.
- Enable incremental caching: only recook changed frames.
For rendering, bake the sim into your chosen format. In Solaris, import caches as USD layers, assign consistent prim paths, and override material bindings via collection rules. Ensure UVs and normals are carried through by checking the DOP Import SOP settings. A clean USD stage allows render engines like Karma or third-party renderers to ingest high-fidelity geometry without extra conversions.
When preparing for compositing, generate a deep EXR or multilayer EXR to capture depth and texture channels. Crop to the action region in SOPs and include velocity vectors for motion blur passes. Label each layer clearly—depth.Z, diffuse.A, velocity.X/Y—to streamline downstream compositing in Nuke or After Effects.