Are you struggling to create lifelike cloth in Houdini? Tired of endless trial and error to get realistic folds and drapes? You’re not alone. Many artists find traditional rigid body solvers too limiting for detailed fabric animations.
Adjusting stiffness, damping, collision thickness—or wrestling with mesh tearing—can drain your time and patience. When simulations lack subtlety, your projects lose their polish and realism. Sound familiar?
That’s where Houdini’s Vellum solver comes in. Vellum is a unified solver designed for cloth, soft bodies, and grains. It balances speed with accuracy, letting you iterate faster. We’ll break down its core concepts and workflows.
In this guide, you’ll learn how to set up a basic garment, tune constraint properties, handle collisions, and fine-tune for production. By the end, you’ll have a clear path to reliable, high-quality Vellum cloth animations in your next Houdini shot.
What is Houdini’s Vellum solver and why choose it for cloth & fabric?
The Vellum solver in Houdini is a unified, constraint-based engine designed for simulating cloth & fabric, hair, soft bodies, and grains. Built on Position Based Dynamics (PBD), it solves geometry interactions by enforcing constraints directly on vertex positions. This approach yields stable, controllable results with fewer numerical instabilities than traditional force-based methods.
Unlike legacy solvers, Vellum integrates directly into the SOP context. You configure material behavior using nodes such as Vellum Configure Cloth and Vellum Configure Solver, then drive the simulation with the Vellum Solver SOP. This procedural workflow keeps your network flexible—adjust constraints or remesh sources without breaking downstream relationships.
Production studios favor Vellum for its balance of performance and quality. The solver supports adaptive substepping and optional GPU acceleration, enabling high-resolution cloth meshes to interact with complex environments, from garment folds to sharp collisions. Its unified architecture also lets you mix different behaviors—say, combining cloth with soft-body patches in a single simulation—without switching solvers.
- Efficiency: Fast convergence via PBD ensures consistent frame times even at high mesh densities.
- Flexibility: SOP-level nodes let you remesh, refine constraints, or blend with other effects procedurally.
- Interoperability: Easily combine cloth, hair, and particles in one DOP network.
- Control: Strain limits, bend resistance, and damping parameters give artists precise tuning over fabric behavior.
Choosing Houdini’s Vellum solver for cloth & fabric workflows means leveraging a modern PBD framework that unifies multiple material simulations under a single, artist-friendly toolset—delivering reliable results in less time while maintaining full procedural control.
How do I prepare mesh topology, UVs, and attributes for accurate Vellum cloth?
Accurate Vellum cloth starts with clean, uniform topology. Aim for evenly sized quads: this ensures consistent constraint distribution. Begin by remeshing high-res sculpted geometry using the Remesh SOP, setting target edge length to your simulation scale (e.g., 0.02m). After remeshing, weld duplicate points with the Fuse SOP to eliminate micro-gaps that cause tearing.
Next, generate a non-overlapping UV layout. Proper UVs let you paint per-area stiffness and leverage strain limits. Use the UV Unwrap SOP and mark seams in areas of natural folds—underarms or waistlines. UV seams double as tearing guides if you enable Force Seams in the Vellum Configure Cloth node, giving you artistic control over rips.
Finally, assign simulation attributes. While the Vellum Configure Cloth SOP sets default stiffness, bendstiffness, and massdensity, you can override them per-vertex via Attribute Wrangle. For example:
- massdensity – higher values resist gravity better
- stiffness – controls stretch; paint via UV as
@stiffness - bendstiffness – affects fold sharpness; ramp by y-axis
- thickness – for self-collision margins
Use a Connectivity SOP to group UV islands, then feed those into the Vellum solver as distinct regions. This procedural setup ensures your cloth behaves predictably, with uniform drape and tear control exactly where you need it.
How to set up a basic Vellum cloth simulation in Houdini (step-by-step)?
Create cloth geometry and add required attributes (thickness, rest length, UVs)
Start by placing a Grid SOP in your geometry network. Adjust rows and columns to control tessellation. Add a UV Texture SOP set to planar projection; ensure UVs cover the cloth evenly for shading and weight painting.
Use an Attribute Create SOP to add a float attribute named thickness; a value around 0.005 units works well for most garments. To define stretching limits, add an Attribute Wrangle set to run over points. Compute restlength by measuring the distance to each connected neighbor; storing this gives the solver accurate base lengths.
Configure Vellum Cloth node, set constraints, add collisions, forces, and cache the sim
Insert a Vellum Configure Cloth SOP after your cloth geometry. In its constraints tab, enable stretch, bend, and shear. Set stretch stiffness (e.g., 500), bend stiffness (10), and shear stiffness (50) based on fabric type. Activate Compute Mass from area to assign mass automatically.
Dive into a Vellum Solver inside a DOP Network. Add a Static Object DOP for any collision geometry—link to your collision mesh and enable the deforming geometry flag if it moves. Add a Gravity Force DOP (9.8) and, if desired, a wind force. Wire all nodes into the solver.
Outside the DOP Network, use a DOP Import SOP to pull in the cloth output. Connect a File Cache SOP to save each frame as .bgeo.sc; define a file path with $F4 padding. Caching ensures fast playblasts and reproducible results on subsequent runs.
Which Vellum constraints and solver parameters control stretch, bend, sewing, and damping?
The foundation of cloth behavior in Houdini’s Vellum solver lies in its dedicated constraint nodes and global solver settings. Each cloth characteristic—stretch resistance, bending flexibility, seam strength, and energy dissipation—maps to specific parameters. Understanding how these interact lets you tune realistic fabric motion without brute-forcing high substeps or iterations.
Stretch is governed by the Vellum Stretch constraint. It uses a “stiffness” value (or its inverse, “compliance”) to determine how much the cloth resists in-plane deformation. A lower compliance makes the mesh hold its original edge lengths closely, ideal for woven fabrics. Conversely, raising compliance allows gentle stretching, useful for knits or drapes that need extra give.
Bending behavior comes from the Vellum Bend constraint, which enforces an angular spring between adjacent triangles. Its stiffness parameter controls the cloth’s tendency to maintain its initial curvature. Higher bend stiffness suits heavy materials (denim, leather), while lower values simulate lighter silks and chiffons that fold easily.
| Constraint | Key Parameter | Effect | Example Range |
|---|---|---|---|
| Vellum Stretch | Stiffness / Compliance | Controls edge length retention | Stiffness: 50–2000; Compliance: 0–1e-4 |
| Vellum Bend | Bend Stiffness | Controls dihedral angle resistance | 0.1–10 |
| Vellum Stitch | Glue Stiffness | Maintains seam closure | 200–500 |
| Solver | Velocity Damping | Global energy dissipation | 0.01–0.3 |
Sewing or zipping edges uses the Vellum Stitch constraint. By specifying pairs of points or edge loops, you enforce a “glue” effect. Adjust the glue stiffness to control how strongly the seam holds under tension—too high and the cloth may pop seams; too low and edges will gape.
Finally, damping lives both in constraint-specific parameters (e.g., stretch damping) and in the VellumSolver’s global settings: Velocity Damping for uniform drag, Air Viscosity for directional resistance, plus solver substeps and constraint iterations. Use substeps to stabilize fast motions and high stiffness; use iterations to converge constraint satisfaction.
How to optimize performance and troubleshoot common cloth issues (tearing, jitter, penetration)?
Efficient Houdini Vellum simulations balance resolution, substeps, and constraint settings. Start by reducing mesh complexity with a Vellum Configure Cloth SOP. Cache early and limit affected points via groups. Use proxy geometry during look development, then switch to final resolution only for caching.
- Lower particle separation to lighten constraint counts.
- Set solver Substeps to 2–4; increase only when needed.
- Enable multithreading and GPU acceleration if available.
- Cache simulations with File Cache DOP for faster iteration.
Tearing occurs when springs exceed their maxstretch threshold. In tight folds or high-stress areas, the solver will automatically break constraints. To control this:
- Adjust maxstretch in the Vellum Constraint Properties SOP.
- Use a Vellum Tear SOP to define manual tear lines.
- Reduce stiffness locally with a point attribute and weight map.
Jitter or high-frequency flicker often signals inadequate collision resolution. The cloth can pass through thin or fast-moving geometry if substeps are too low or damping is missing.
- Increase solver Substeps to 4–8 for fast motions.
- Add Vellum Damping to smooth out vibrations.
- Extrude collision geometry thickness to prevent edge clipping.
Penetration arises when cloth particles escape collision detection. Tuning padding and using volume-based methods yields more robust results.
- Set Collision Method to Volume SDF in the Vellum Solver.
- Increase Collision Padding on both cloth and collider.
- Enable Self-Collision with a small particle separation to avoid interpenetration.