Have you ever started a project in Houdini only to find your materials refuse to flow? You’re not alone if setting up a convincing melting effect feels like chasing a ghost. The parameters pile up, and the results stay stubbornly rigid.
At the heart of this challenge lies the balance between art and physics. Tweaking masses, viscosities, and collisions can feel like guesswork. Intermediate artists often get lost in the labyrinth of nodes, unsure which step truly makes the simulation yield.
That’s where the Vellum solver steps in. By leveraging its unified approach to cloth, hair, and grains, you can craft a fluid workflow tailored to melting scenarios. No more isolated tweaks—everything links in one dynamic network.
In the following sections, you’ll dive into a streamlined workflow that takes you from basic setup to final tweaks. You’ll learn how to set constraints, drive the melt process, and refine details for a polished look. Let’s demystify the melting process together.
What prerequisites, Houdini version, and knowledge should I have before starting this Vellum melting workflow?
To reliably achieve a convincing melting effect you’ll need a recent build of Houdini with the latest Vellum solver enhancements. We recommend Houdini 18.5 or later, since these versions introduced GPU acceleration support, improved constraint handling, and more stable Vellum grain and cloth interactions.
Beyond software, a workstation with at least 16 GB of RAM and a CUDA-capable GPU (if you plan to leverage GPU solving) will ensure smooth playback and caching. Avoid network storage for simulation caches—local SSDs deliver far better performance.
- Houdini 18.5+ (18.0 core features are available, but later builds include critical bug fixes)
- Solid grasp of SOP workflows: scattering, remeshing, attribute creation and transfers
- Familiarity with DOP networks and how Vellum constraints (cloth, grain, pressure) are configured
- Basic VEX or Attribute Wrangle skills for driving custom temperature or viscosity attributes
- Understanding of substep adjustment, collision padding, and solver iterations to prevent jitter
- Experience rendering simulations in Mantra or Karma for previewing char paths and shading
If you’re new to Vellum, start by simulating a simple cloth or softbody object. That hands-on practice with constraint setup, rest lengths, and friction will translate directly when you introduce dynamic melting attributes and temperature-driven stiffness decay.
How do I prepare and preprocess source geometry for a stable melting simulation (remesh, thickness, VDB conversion)?
Before running any Vellum simulation in Houdini, you must ensure your source mesh is clean, closed and uniformly distributed. Begin with a polygonal object that has correct normals and no non‐manifold edges. Use a Clean SOP or the PolyDoctor HDA to detect and repair open borders or overlapping vertices. A well‐formed base mesh prevents artifacts once internal constraints start driving the melt.
Next, apply a Remesh SOP to redistribute triangles evenly across the surface. Set your target edge length based on the smallest detail you need to preserve—typically 1/20th of the object’s bounding size. Choose “Adapt to Curvature” off for uniform grids. Uniform triangle sizes yield consistent stiffness and damping in the Vellum solver, reducing jitter and numerical blowouts.
Realistic melting simulates volume loss, so your object needs thickness. If you’re starting with a sheet or open surface, use PolyExtrude along normals to create a solid shell—2% to 5% of the object’s maximum dimension is a typical thickness. For complex shapes, switch to a volume workflow: convert the extruded mesh into a spare volume using VDB From Polygons, filling the interior to generate a signed distance field (SDF).
With a closed VDB, you can refine resolution by adjusting voxel size. Smaller voxels capture sharper features but increase compute time. After you’re satisfied, run VDB Smooth to eliminate tiny cavities that could destabilize the solver. Then use VDB Convert to Polygons with a suitable isovalue (usually 0.0) to retrieve a clean, manifold mesh. This guarantees no micro‐holes or isolated islands.
Finally, feed this preprocessed geometry into your Vellum configuration. The uniform triangulation, correct thickness and VDB‐repaired surface ensure stable constraint solving, predictable melting patterns, and robust collision handling. Proper preprocessing cuts down on simulation retries and lets you focus on tweaking material properties and temperature fields—rather than chasing geometry errors.
How do I build the core Vellum network and constraint setup to simulate soft melting behavior?
First, convert your solid object into a tetrahedral volume. Use a Tetrahedralize SOP on your input mesh, setting the max edge length to control resolution—smaller edges give finer detail but cost more in simulation time. Feed the result into a Vellum Configure Tetrahedral SOP. This node automatically creates stretch, bend and volume constraints. For a soft, gooey appearance set stretch stiffness low (0.1–0.3) and volume stiffness slightly higher (0.2–0.4) to prevent total collapse.
Next, drop in a Vellum Solver (either in SOP context or inside a DOP Network). In its settings, increase substeps to 3–5 and enable self-collision with a small collision margin (0.002–0.005). To drive the melt, promote the constraint stiffness parameters to attributes: initialize a @temperature or @melt attribute on the tet points and drive stiffness via a VOP or Attribute Wrangle. For example:
- Attribute Wrangle (point): @pscale = fit(@temperature, 0, 1, 0.5, 0.05); // lower pscale = softer constraints
- In Vellum Configure Tetrahedral, set Stretch Stiffness to ch(“../attribwrangle/pscale”)
Finally, use a Post-Solve chain to extract and smooth the surface. Feed the solver’s output into a Convert VDB SOP, then back to polygons to rebuild a clean, smooth mesh. Cache the result with a ROP Output Driver before moving on to shading or further deformations. This network ensures a stable soft-body base that gradually loses stiffness and “flows” like a melt under gravity.
How do I drive the melt using animated rest length, masks or temperature fields to control timing and rate?
Create a mask or temperature field with SOPs/VDBs to define melt regions and progression
Begin by generating a mask attribute that marks where melting should start. In a SOP network, you can use the Paint SOP or Attribute Wrangle to assign a float mask per point. Convert this mask into a VDB volume using the VDB From Particles or Volume Rasterize Attributes node to smooth transitions.
- Paint or procedural noise to define melt areas
- VDB Smooth to blur hard edges
- Volume VOP or Fit Range to remap mask into a temperature field
By remapping the mask into a temperature field, you gain fine control over the melt’s temporal progression. Higher temperature values correspond to earlier or faster melting, while zeros remain solid.
Use a SOP Solver inside the Vellum DOP to modify restlength, stiffness and constraint attributes over time
Inside your Vellum DOP network, dive into the Vellum Solver and append a SOP Solver. Reference the incoming geometry, then use an Attribute Wrangle or Attribute Adjust to drive animated rest length based on the temperature field. Example VEX:
restlength = lerp(orig_rest, target_rest, clamp((@temperature – t_start)/t_range, 0, 1));
@restlength = restlength;
Simultaneously, you can modify constraint attributes like stiffness or bend angle to simulate weakening material. Use the same temperature falloff to reduce stiffness from its default down to near zero, enabling the softening and collapse characteristic of melting.
How do I handle collisions, sticky surfaces and believable drips or breakup (including converting to particles/FLIP for splashes)?
First, set up collision geometry as a Static Object DOP using an SDF volume from your mesh (via IsoOffset). In the Vellum Solver collision tab, increase collision thickness and substeps to prevent interpenetration. Adjust friction in your Vellum Configure SOP—higher values will make the melt grip the surface, lower values let it slide smoothly.
To simulate adhesion on a sticky surface, create a Vellum Glue constraint in targeted groups (e.g., table contact area). In a Vellum Constraint Wrangle, drive the glue’s break threshold by a temperature or age attribute, gradually reducing strength so the melt holds briefly then releases into drips. This procedural approach mimics viscosity changes during melting.
For believable breakup, use Vellum Erode Constraints. Define erosion based on edge length or stress (CauchyStress attribute) so high-tension regions pinch off naturally. After erosion, isolate broken clusters and generate a VDB with IsoOffset. Activate it with VDB Activate, then scatter points on its surface to seed a FLIP solver—this captures splash detail and small droplets with accurate velocities.
- Collision setup: Static Object DOP + SDF from IsoOffset
- Sticky behavior: Vellum Glue + dynamic thresholds in Constraint Wrangle
- Breakup: Vellum Erode Constraints driven by length or stress
- FLIP conversion: IsoOffset → VDB Activate → Scatter Points → Flip Solver
How do I convert Vellum output into a renderable mesh, optimize caches, and set up shading for melted material?
After simulating the melting effect via Vellum output, our goal is to build a clean surface mesh that can be shaded and cached efficiently. We need to generate a closed surface, control polycount, and prepare the sim for both interactive playback and final render.
- Merge simulated points or packed prims using Object Merge in SOP context.
- Create a fluid surface with Particle Fluid Surface or VDB from particles; set voxel size to 0.01–0.05 for detail.
- Run VDB Smooth and VDB Reshape SDF to close holes and remove spikes.
- Convert the VDB to polygons, then apply a Remesh SOP for uniform triangles and adaptive edge length.
- Insert a File Cache SOP with .bgeo.sc, enable per-frame splitting and compression for fast reloads.
- Pack geometry primitives and strip unused attributes; use “Unpack Before Render” to minimize memory footprint.
For shading the melted material, assign a Principled Shader via a Material SOP. Increase subsurface weight for a waxy look, dial specular roughness for softened highlights, and add a subtle noise-based bump map in the normal input to mimic surface tension. If using Mantra, ensure you generate UVs or employ triplanar projection. For Redshift or Karma, switch to the corresponding material node and replicate the SSS, roughness, and bump channels.