Liquids were the last thing still waiting on the CPU

Smoke and fire moved to the GPU years ago. Liquids did not: Houdini’s FLIP solver can use OpenCL for a few sub-steps, but the solver itself is CPU-bound. That is why a simple splash still means “start the sim, get a coffee”.

Paradigm, from the team behind Axiom, is a sparse FLIP solver that runs entirely on the GPU. The developer describes it as a FLIP solver that borrows ideas from SPH. The interesting question for a production is not “is it faster?” – it obviously is – but how much faster on a real shot, and what changes in the look.

Three ways to simulate water in Houdini 22

One dam break, three solvers

A dam break is the classic fluid benchmark: a column of water collapses, runs across the floor and slams into an obstacle. It stresses everything at once – pressure projection, collisions, thin sheets and splash.

• Tank – 4 × 3 × 2 m, closed on all sides
• Water column – 1 × 1.6 × 2 m against the left wall, sourced once on frame 1
• Obstacle – 0.4 × 0.6 × 0.7 m block in the path of the wave
• Resolution – particle separation 0.02 m, grid scale 2 (4 cm voxels), roughly 400,000–490,000 particles
• Length – 96 frames at 24 fps, max. 2 substeps for all three solvers
• Hardware – AMD Threadripper PRO 3975WX (32 cores) · NVIDIA RTX 5090

96 frames: 94 seconds vs. 4 seconds

At these numbers the simulation stops being the thing you wait for. A full 4-second shot solves faster than Houdini opens a file dialog – which changes how you work: you can try a different obstacle position, a different viscosity or a different source shape and see the result before you have lost the thought.

Same shot, different water

Speed is only half the story. With default settings the three solvers do not produce the same splash:

• DOP FLIP throws the most energy upwards – the tallest sheet and the most separated droplets.
• SOP FLIP is very close in motion, slightly more contained. Expected: it shares most of the core with the DOP solver.
• Paradigm keeps the wave lower and the sheets more coherent. It wraps around the obstacle instead of shooting up the back wall.

That is not a quality verdict – it is a calibration note. Paradigm uses its own pressure, separation and collision model (bounce, friction and stick live on the solver). If you switch a shot from FLIP to Paradigm, plan a short look-matching pass instead of expecting a one-to-one result. Because a full iteration takes seconds, that pass is cheap.

What tripped us up

None of these are bugs – but each one cost a re-sim, so here they are:

1. SOP FLIP: the container has three outputs. Sources, Container and Collisions must all travel through FLIP Boundary and FLIP Collide into the solver. If the domain output is missing, the solver stops with “gridscale and particlesep are required detail attributes”.
2. SOP FLIP: use FLIP Boundary for an initial fill. A FLIP Source merged into the stream produced no particles in our test. FLIP Boundary with the column geometry in its 4th input and Activate set to “$F<=1” worked first time.
3. SOP FLIP: the container is not a tank. Without collision walls the water drained out of the domain floor. We added the tank walls as collision geometry – which also kept all three setups identical.
4. DOP FLIP: Volume Sample needs an SDF. A Static Object in “Volume Sample” mode reading plain polygons gives no collision at all – the water fell through the floor. Convert the colliders with VDB from Polygons first.
5. DOP FLIP: merge order matters. The Merge DOP’s default relationship is “left affects right”. Put the static tank on the left input and the FLIP solver on the right.
6. Paradigm: shapes are unit primitives. Source Shape boxes span −1 to 1, so scale is the half-size. A Collision box with “Invert Shape” is the tank; “First Frame Only” timing makes a clean dam break.

# Source Shape  "water"     type Source,    box, t(-1.5,0.8,0)  s(0.5,0.8,1.0), timing: First Frame Only
# Source Shape  "tank"      type Collision, box, t(0,1.5,0)     s(2,1.5,1),     Invert Shape on
# Source Shape  "obstacle"  type Collision, box, t(0.6,0.3,0)   s(0.2,0.3,0.35)
# Merge  ->  Paradigm Solver, input 2 "Source Shapes"
divisionSize   = 0.02
gridResolution = Grid Scale
gridScale      = 2
subSteps       = 2

Now meshing is the slow part

Once the solve takes 0.04 s per frame, everything around it shows up in the profiler. Particle Fluid Surface needed about 1.2 seconds per frame at 0.02 m separation – roughly 30 times the Paradigm solve. In a GPU pipeline you will want to:

• Mesh only what the camera sees – clip the particles to the frustum before surfacing.
• Use Paradigm's SDF output – since 1.0 it can write a surface field that Convert VDB turns into a mesh.
• Look-dev on particles – iterate on motion with points, mesh only the final take.

Our recommendation

Paradigm costs $199 for a node-locked commercial licence or $99 for Indie (Houdini Indie only), according to Theory Accelerated's release. It is a plugin – check that it fits your render farm and licence setup before you commit a show to it.

The takeaway

• On our dam break Paradigm solved 22× faster than DOP FLIP and 16× faster than SOP FLIP at the same resolution.
• The look differs out of the box – budget a short calibration pass when you switch.
• With a GPU solver, meshing and rendering become the real cost. Optimise there next.