Houdini Fluid Source: Building Custom Emission Shapes for FLIP

Have you ever struggled to shape fluid emissions beyond a simple sphere or box in Houdini? Do you find yourself fighting the default settings, trying to force a unique water or smoke pattern into a rigid workflow?

The standard Fluid Source node offers limited presets. When you need a ring of droplets or a precise silhouette, the built-in options can feel restrictive, leaving you frustrated and second-guessing your setup.

In this guide, you’ll explore how to build truly custom emission shapes for FLIP simulations. You’ll learn how to convert any geometry into a fluid source, leverage SOP nodes, and use VDB workflows to define complex emission regions.

By following these steps, you’ll gain fine-tuned control over your fluid sources, eliminate guesswork, and smoothly integrate advanced shapes into your Houdini projects. Let’s get started on mastering the Fluid Source node.

What is a Houdini fluid source in the FLIP context and which simulation fields does it provide?

In Houdini’s FLIP workflow, a fluid source is any Geometry or SOP that feeds emitting attributes into a FLIP solver. It defines where particles or volumes are injected, and with what properties. Conceptually, it bridges the SOP and DOP contexts by converting surface or volume data into simulation inputs.

When you configure a FLIP Object and attach a Particle Fluid Source (or Volume Source) DOP, Houdini examines specific simulation fields. These fields govern how particles behave and how volumes evolve over time. You can even drive custom behaviors by creating and importing extra attributes.

• density: A scalar controlling particle creation per voxel or the initial voxel fluid density.
• vel (velocity): A vector field prescribing initial particle velocities or volume advection.
• temperature: A scalar used in thermal buoyancy and smoke shading routines.
• fuel (optional): Enables combustion and pyro simulations when coupled with temperature.
• Cd (color): A vector that carries RGB values into the renderer for colored fluids.
• active: A mask (0 or 1) denoting where sources are enabled; helps control emission regions.
• source_volume: A Signed Distance Field to define precise geometry-based emission boundaries.

Beyond these built-in fields, you can use the Import Fields tab on the Volume Source DOP or the SOP Import DOP to bring in custom attributes—such as viscosity or surface tension multipliers. In production, mapping SOP attributes to DOP fields enables procedural control, letting artists tweak emission shapes or field strengths without rewriting simulation networks.

How should I prepare and validate source geometry for reliable FLIP emission?

Before driving FLIP emission, your source geometry must be watertight and manifold. Non-manifold edges or holes cause irregular velocity fields and unstable partitions. Start by inspecting topology with the PolyDoctor SOP, closing gaps and eliminating zero-area faces. A closed mesh ensures consistent volume sampling when converting to SDF or particles.

Next, confirm normals and scale. Use a Normal SOP to align all normals inward or outward—uniform orientation prevents flipped velocity injection. Freeze transforms to 1:1:1 scale; mismatched object scales distort grid resolution and lead to aliased emission regions. Always apply a Transform SOP and reset pivot to world origin.

• Check manifoldness: PolyDoctor with “Remove Zero Areas”
• Uniform tessellation: Remesh SOP targeting edge length
• Normals consistency: Normal SOP set to “Conform”
• Scale reset: Transform SOP with “Freeze Transform”

Once geometry passes the initial audit, build a VDB SDF using the IsoOffset SOP. Drive voxel size from your FLIP container’s cell size to guarantee matching resolution. Apply a VDB Smooth SOP to eliminate spikes that spawn unwanted jets. A clean SDF surface generates uniform particle emission and prevents isolated clusters.

Finally, validate by scattering points on the SDF and visualizing initial velocity fields. Use the Scatter SOP for uniform seeding, then compute velocity via Attribute Transfer from a guiding mesh. Inspect particle boot patterns in the viewport or flipbook. Any density voids or high-speed outliers indicate residual geometry issues that need correction before simulation.

How to build a procedural emitter network (SOP → DOP) for arbitrary custom shapes

SOP-side: converting geometry to volumes (VDB/SDF) and creating per-primitive attributes

First, import your custom mesh and feed it into a VDB From Polygons node. Set a uniform voxel size to control resolution. Use VDB Resample to smooth topology. To drive emission, add a density attribute via an Attribute Wrangle: @density = 1.0; and generate a unique @id per primitive with prim intrinsic (primnum). If needed, compute a per-point velocity field using a Volume VOP or another Wrangle: @velocity = normalize(@P) * speed.

• VDB From Polygons → uniform voxel size
• VDB Resample → adjust smoothing
• Attribute Wrangle → @density, @id
• Volume VOP/Wrangle → @velocity vector

DOP-side: Source Volume/Source Particle nodes — configuring density, velocity and id attributes

Inside a new DOP network, drop a FLIP Object and connect a FLIP Solver. Add a Source Volume DOP. In its SOP Path, point to your SOP container. Enable “Density” and map to the @density field. Under “Source Attributes,” add velocity and id to ensure consistent seeding and merging across frames. For particle-based emission, swap in Source Particle and import the same attributes.

Key parameters:

• Activate Region: use your packed prim boundaries
• Emission Type: set to “All” for continuous or “Impulse” for burst
• Density Scale: controls mass injected per frame
• Velocity Scale: multiplies @velocity field
• Id Attribute: ensures old and new volume fragments merge

How can I precisely control emission rate, seeding patterns and per-particle velocity?

In Houdini, the Particle Fluid Source SOP is your gateway to procedural emission control. For FLIP simulations you often need to drive per-frame birth count and spatial distribution via attributes rather than fixed sliders. Start by preparing a density or mask field in SOPs, then feed it into Particle Fluid Source’s Density Source. This setup lets you modulate emission rate by voxel value instead of global constants, ensuring regions with higher density emit more particles and vice versa.

To fine-tune the emission rate, enable “Volume Velocity” sampling and link “Emission Scale” to a custom attribute (e.g., @emitScale). In a preceding Attribute Wrangle you can write VEX like @emitScale = fit(noise(@P*2.3), -1,1, 0,1);, then in Particle Fluid Source map Density or Density Scale to @emitScale. This VEX-driven workflow permits real-time procedural tweaks: adjust noise frequency or falloff ramps on the mask SOP to instantly alter particle counts without re-simulating upstream geometry.

For advanced seeding patterns, combine a Scatter SOP with Poisson Disk sampling and relax iterations to avoid clustering. Drive the Scatter density by a grayscale texture or distance field, then randomize orientation by computing @N and @up vectors in an Attribute Wrangle. Use VEX such as @orient = dihedral({0,1,0}, normalize(@N));. Feeding these points into Particle Fluid Source ensures each seed inherits spatial masks and orientation, producing consistent, non-overlapping emission shells or patterns along complex surfaces.

Setting per-particle velocity is straightforward when you precompute vector fields. In SOPs create a volume with curl noise or import a Pyro advected velocity field, then sample it inside Particle Fluid Source. Alternatively, use a POP Wrangle after emission: vector vfield = volumesample(1, "vel", @P); @v = vfield + curlnoise(@P*3.5)*0.2;. This technique lets you layer directional drives, turbulence and swirl on each FLIP particle, giving fine control over initial fluid motion.

• Sample a density attribute to control emission rate in Particle Fluid Source.
• Use Poisson Disk Scatter with custom masks for uniform seeding patterns.
• Compute per-point orientation via dihedral in SOP wrangles.
• Sample velocity volumes or apply curl noise in POP Wrangle for per-particle velocity.

Which optimization strategies improve performance and stability for complex custom emitters?

Complex custom emitters in Houdini’s FLIP context can easily overwhelm memory and CPU if left at full resolution or detail. By adopting adaptive volumes, selective caching, and attribute packing, you focus compute only where it’s needed, keeping both performance and stability under control.

• Adaptive Bounding and Resizing: Use a Gas Resize Fluid Dynamic DOP to shrink your simulation grid to the active region of particles each frame. This cuts voxel count dramatically and avoids large empty domains.
• Proxy vs. Final Geometry: Emit from low-res proxy meshes or simplified VDBs, then switch to high-res shapes late in the pipeline. For example, feed a coarse VDB from VDB from Polygons into your Flip Source SOP, then substitute with detailed geometry via a SOP Solver just before output.
• Volume Attribute Compression: Rasterize only essential attributes (density, velocity) at reduced bit depth using Volume Rasterize Attributes SOP. Optionally apply Volume Blur to smooth noise and reduce grid complexity without visual loss.
• Pre-Baked Emission Fields: For repetitive or procedural forces, generate and cache velocity fields via a Volume VOP or Gas Field VOP network. Use File Cache SOP or Timeshift in DOPs to reuse these fields across shots, eliminating expensive recomputation.
• Substep and CFL Tuning: Balance solver accuracy and speed by adjusting the Flip Solver’s max substeps and CFL threshold. Lower substeps speed up simulation but require clearer sources; higher CFL stability settings prevent blowouts at the cost of computation.
• Domain Partitioning: Split complex emitters into multiple smaller Flip tanks or DOP networks, driven by separate bounding boxes. This allows parallel simulation of regions with different resolutions or behaviors, merging at the end with Merge DOP.

Combining these strategies—adaptive volumes, proxy geometry, attribute compression, cached fields, tuned solver parameters, and domain partitioning—ensures your custom emitter remains both performant and stable. In production, layering these techniques prevents memory spikes, accelerates iteration, and maintains predictable, high-quality fluid behavior.

How to implement advanced emitter types: VDB blending, metaballs and animated RBD-driven sources

Implementing advanced emitter types like VDB blending, metaballs and animated RBD-driven sources lets you sculpt complex FLIP emission shapes procedurally. Each method leverages Houdini’s volume SDF tools, dynamic primitives and DOP network integration to achieve fluid emission that interacts organically with your scene.

For VDB blending, convert individual emitter shapes into SDF volumes using VDB from Polygons or IsoOffset. Merge them with the VDB Combine SDF node set to union, intersect or subtract. Soften transitions via VDB Smooth SDF. Finally, feed the resulting mask into a Source Volume DOP, using Volume RasterizeAttribute to transfer any custom velocity fields.

Using metaballs allows smooth, blob-like emitters. Create metaprim primitives with the Metaball SOP and control their radius and threshold. Merge multiple metaballs either directly in SOPs or by converting them to a VDB SDF via IsoOffset for finer control. Animate their transforms or driving parameters in CHOPs or a SOP Solver to build evolving emitter shapes.

To drive emissions with animated rigid bodies, import your RBD sim into FLIP using a DOP Import or SOP Solver inside your FLIP DOP network. Scatter points on the packed collision geometry and use Source Particle or Source Volume to emit fluid. Capture the geometry’s velocity attribute with Attribute Capture, then sample @v on your particles so the fluid inherits the RBD motion each substep.

• Key nodes: VDB Combine SDF, VDB Smooth SDF, IsoOffset, Metaball, Source Volume, Attribute Capture
• Use SOP Solver for per-substep emitter updates
• Leverage Volume RasterizeAttribute for custom velocity fields