Stable Fluids C# Implementation for Rhino/Grasshopper

A C# implementation of Jos Stam's "Stable Fluids" algorithm, specifically designed for use in Rhino/Grasshopper plugins. This implementation provides real-time fluid simulation with bitmap visualization and vector field output.

Overview

This implementation answers your three key questions:

1. Modern Relevance

Jos Stam's 1999 "Stable Fluids" paper remains the gold standard for real-time fluid simulation. The algorithm is:

• Unconditionally stable - won't explode regardless of time step
• Fast - suitable for real-time applications
• Simple - relatively easy to implement and understand
• Widely used - still used in modern games, VFX, and interactive applications

2. Algorithm Understanding

The Stable Fluids algorithm consists of four main steps:

1. Add Forces: Apply external forces (mouse input, obstacles, etc.)
2. Advection: Move quantities along the velocity field using semi-Lagrangian method
3. Diffusion: Smooth velocities using viscosity (solved with Jacobi iteration)
4. Projection: Ensure velocity field is divergence-free (incompressible flow)

Key concepts:

• Velocity Field (u,v): 2D vector field representing fluid motion
• Pressure: Scalar field used to enforce incompressibility
• Divergence: Measures field "spreading" - must be zero for incompressible flow
• Jacobi Iteration: Iterative solver for linear systems

3. C# Implementation

The provided implementation includes:

• StableFluidSimulation.cs - Core simulation engine
• FluidVisualization.cs - Bitmap generation and streamline creation
• GrasshopperFluidComponent.cs - Example Grasshopper integration

Files Description

Core Implementation

• StableFluidSimulation.cs: Main simulation class implementing Jos Stam's algorithm
• FluidVisualization.cs: Visualization helpers for creating bitmaps and vector fields
• GrasshopperFluidComponent.cs: Example Grasshopper component integration

Key Features

• Real-time fluid simulation
• Bitmap output for velocity and density fields
• Streamline generation
• Vector field visualization
• Mouse/cursor interaction support
• Configurable parameters (viscosity, diffusion, grid size)

Usage

Basic Usage

// Create simulation (64x64 grid)
var simulation = new StableFluidSimulation(64, 64, 0.016f, 0.0001f, 0.0001f);
var visualization = new FluidVisualization(simulation);

// Add forces and density
simulation.AddForce(32, 32, 10.0f, 5.0f);
simulation.AddDensity(32, 32, 100.0f);

// Run simulation step
simulation.Step();

// Generate visualization
var velocityBitmap = visualization.CreateVelocityMagnitudeBitmap();
var streamlines = visualization.GenerateStreamlines(10, 50, 0.3f);

Grasshopper Integration

The FluidSimulationComponent provides:

• Inputs: Grid size, viscosity, diffusion, force points/vectors, density points/amounts
• Outputs: Velocity bitmap, density bitmap, streamlines, velocity vectors

Parameters

• Width/Height: Simulation grid resolution (higher = more detail, slower)
• Viscosity: Fluid thickness (0.0001 = water-like, 0.01 = honey-like)
• Diffusion: How quickly density spreads (0.0001 = slow, 0.01 = fast)
• Time Step: Simulation time step (0.016 ≈ 60 FPS)

Modern Alternatives and Libraries

C# Libraries

• Unity-based: keijiro/StableFluids - GPU-accelerated Unity implementation
• This implementation: CPU-based, suitable for Grasshopper plugins

Python Libraries

• Taichi: Modern GPU-accelerated physics simulation
• PyFluid: Various GitHub implementations
• NumPy/SciPy: For educational/research purposes

Why Stable Fluids is Still Relevant

1. Stability: Never explodes, always produces reasonable results
2. Speed: Fast enough for real-time interaction
3. Simplicity: Relatively easy to implement and modify
4. Flexibility: Can be extended with obstacles, boundaries, different forces
5. Visual Quality: Produces convincing fluid-like motion

Implementation Details

Algorithm Steps

1. Velocity Step:

   • Add forces
   • Diffuse velocities (viscosity)
   • Project to remove divergence
   • Advect velocities
   • Project again

2. Density Step:

   • Diffuse density
   • Advect density along velocity field

Numerical Methods

• Semi-Lagrangian Advection: Trace particles backward in time
• Jacobi Iteration: Solve linear systems iteratively
• Projection: Use pressure to enforce incompressibility

Boundary Conditions

• Velocity: No-slip boundaries (velocity = 0 at walls)
• Density: No-flux boundaries (density doesn't escape)

Performance Considerations

Grid Resolution

• 32x32: Very fast, low detail
• 64x64: Good balance for real-time interaction
• 128x128: High detail, may be slow for real-time
• 256x256+: Very high detail, likely too slow for real-time

Optimization Tips

1. Use appropriate grid resolution for your needs
2. Reduce Jacobi iterations if speed is critical (20 is good, 10 may suffice)
3. Consider GPU implementation for larger grids
4. Cache visualization results when possible

Extensions and Modifications

Possible Enhancements

1. Obstacles: Add solid boundaries within the fluid
2. Temperature: Add buoyancy effects
3. Multiple Fluids: Different density fluids
4. 3D Version: Extend to three dimensions
5. GPU Acceleration: Port to compute shaders
6. Vorticity Confinement: Add swirl preservation

Grasshopper-Specific Features

1. Geometry Interaction: Use Rhino curves as obstacles
2. Point Cloud Forces: Apply forces at point locations
3. Animation Export: Save sequences of bitmaps
4. Parameter Animation: Animate viscosity, forces over time

References

1. Stable Fluids - Jos Stam (1999) - Original paper
2. Real-Time Fluid Dynamics for Games - Jos Stam (2003) - Simplified version
3. Fast Fluid Dynamics Simulation on the GPU - Mark Harris (2004) - GPU implementation
4. keijiro/StableFluids - Modern Unity C# implementation

License

This implementation is provided as educational/research code. The original Stable Fluids algorithm is from Jos Stam's public research papers.