BLENDER • SIMULATION AND EFFECTS

Fluid & Smoke Simulation — Understand fluid/smoke simulation concepts (Mantaflow)

Master the physics-based tools that bring realistic liquids and gaseous volumes to life in Blender's Mantaflow engine.

Historical Context & Motivation

Long before digital artists could press a button to generate swirling smoke or crashing waves, fluid simulation was a frontier problem in computational physics. Researchers needed to solve systems of partial differential equations that describe how fluids move, interact with obstacles, and dissipate energy—calculations so intensive that they were confined to supercomputing labs for decades. The quest to bring these simulations into real-time and artist-friendly environments drove a remarkable chain of innovations, each one making physically plausible motion more accessible to creators working in film, games, and motion graphics.

Blender's journey through fluid simulation reflects this broader arc. Its earliest fluid tools were rudimentary, but the community's appetite for photorealistic natural phenomena—explosions, ocean surfaces, atmospheric fog—pushed the developers to adopt increasingly sophisticated solvers. Understanding this history is essential because the design decisions embedded in today's Mantaflow engine directly reflect lessons learned from each prior generation of simulation technology.

1999
Stam's Stable Fluids Paper
Jos Stam publishes "Stable Fluids," introducing a semi-Lagrangian advection method that enables large time steps without numerical explosion—laying the foundation for real-time fluid simulation in computer graphics.
2005
Blender Gets Its First Fluid Solver
Nils Thürey integrates a Lattice Boltzmann-based fluid solver (El'Beem) into Blender, giving open-source artists their first physics-based liquid tool.
2012
Mantaflow Research Project Begins
Thürey's research group at TU Munich develops Mantaflow as an open-source framework for fluid simulation research, combining grid-based and particle-based methods with machine-learning extensions.
2020
Mantaflow Integrated into Blender 2.82
Blender replaces its legacy smoke and fluid systems with Mantaflow, unifying liquid and gas simulation under one modern, extensible solver accessible to all users.
2023
Ongoing Improvements in Blender 3.x / 4.x
Continued optimization, viewport preview enhancements, and integration with Geometry Nodes bring fluid simulation closer to a non-destructive, node-based creative workflow.

The central question Mantaflow addresses is deceptively simple: how can an artist generate visually convincing fluid and gaseous motion without manually keyframing every detail? The answer lies in leveraging the Navier-Stokes equations—the mathematical backbone of fluid dynamics—discretized onto a voxel grid that Blender can process frame by frame. Everything that follows in this lesson unpacks the concepts, controls, and creative strategies that make this possible.

Core Principles & Definitions

Before diving into Blender's interface panels, it is important to internalize the foundational ideas that govern every fluid and smoke simulation. These principles determine how the solver interprets your scene, how detail is distributed across the volume, and why certain settings produce dramatically different visual results. Mantaflow operates on an Eulerian grid paradigm—meaning it divides space into a three-dimensional lattice of cells (voxels) and calculates velocity, density, and temperature at each cell per frame. This grid-centric approach contrasts with particle-based (Lagrangian) methods, though Mantaflow can combine both through its FLIP/APIC liquid solver.

1

Domain

The bounding box that defines the simulation volume. Every fluid or smoke event occurs inside this container. Its resolution (number of divisions along the longest axis) controls the fineness of the voxel grid and, consequently, both visual detail and computation time.
2

Flow Object

Any mesh designated as a source or sink of fluid data. A flow object can emit smoke density, temperature, liquid particles, or fuel for fire. Its surface normals and velocity influence the initial direction and speed of emitted material.
3

Effector Object

A collision or guide object that redirects or blocks fluid motion. Effectors can act as solid obstacles (walls, characters) or as velocity guides that steer smoke along artist-defined paths.
4

Advection

The process of transporting density, temperature, and velocity through the grid over time. Advection is the heart of every simulation step; it determines how smoke drifts, how flames lick upward, and how liquids flow downhill under gravity.
5

Noise / Upresolution

A secondary pass that adds high-frequency turbulent detail on top of a coarse base simulation. Noise upresolution lets artists bake at lower grid resolutions for speed, then layer in fine wisps and eddies procedurally.
KEY TAKEAWAY
Think of the simulation domain as a block of invisible graph paper suspended in 3D space. Each tiny cube on that graph paper holds a slip of paper recording the local wind speed, smoke thickness, and temperature. Every frame, the solver reads all the slips, applies the rules of physics, and rewrites them—much like a stadium crowd doing a coordinated wave. The finer your graph paper (higher resolution), the more nuanced the motion, but the longer each "wave" takes to calculate.

Visual Explanation — Anatomy of a Mantaflow Domain

The diagram above illustrates the key actors in a Mantaflow simulation: the domain (purple dashed boundary) contains the voxel grid, the flow object emits smoke density (pink plumes), and the effector deflects the flow. Resolution divisions along the longest axis determine voxel size and, therefore, visual fidelity.

In the diagram, notice how the voxel grid subdivides the domain into discrete cells. Each cell stores a velocity vector, a density scalar, and optionally a temperature value. When the flow object emits smoke, it writes density values into the cells that overlap its mesh surface. On every subsequent frame, the solver advects those values through the velocity field, creating the characteristic upward drift and turbulent mixing we associate with real smoke. The effector blocks velocity in the cells it occupies, forcing the flow to route around it—exactly as smoke wraps around a physical obstacle.

Resolution is the single most impactful parameter. Doubling the resolution along one axis effectively multiplies the total number of voxels by eight (since the grid is three-dimensional), which means bake times and memory consumption increase roughly by a factor of eight as well. For initial creative exploration, a resolution of 32–64 is advisable; final production renders typically require 128–256 or higher, depending on how close the camera approaches the effect.

Mathematical Framework — The Navier-Stokes Equations

Mantaflow's simulation loop is grounded in the incompressible Navier-Stokes equations, which govern the conservation of momentum and mass for a fluid. Although Blender handles the numerical solving internally, understanding the equations at a conceptual level gives you direct intuition about what each slider in the physics panel actually controls. Two equations form the core: the momentum equation (which tracks how forces change velocity) and the incompressibility constraint (which ensures volume is conserved).

MOMENTUM EQUATION
∂u/∂t = −(u · ∇)u − (1/ρ)∇p + ν∇²u + f
u = velocity field, t = time, ρ = density, p = pressure, ν = kinematic viscosity, f = external forces (gravity, buoyancy). The terms from left to right represent: self-advection, pressure gradient, viscous diffusion, and body forces.
INCOMPRESSIBILITY CONSTRAINT
∇ · u = 0
This divergence-free condition ensures the fluid neither compresses nor expands—volume going in equals volume going out. In Blender, the pressure solve step enforces this constraint every frame by adjusting velocities so that net flow into every voxel is zero.
BUOYANCY FORCE (SMOKE/FIRE)
f_buoy = −α · d + β · (T − T_amb) · ẑ
α = density influence (smoke weight), d = smoke density, β = temperature difference factor (mapped to Blender's "Heat" parameter), T = local temperature, T_amb = ambient temperature. Positive β drives hot smoke upward; α pulls dense smoke downward.

In practical terms, when you increase the Vorticity slider in Blender's domain settings, you are amplifying rotational components of the velocity field, encouraging the formation of rolling turbulent structures. The Buoyancy Density and Buoyancy Heat parameters correspond directly to α and β in the buoyancy force equation above. Understanding this mapping means you can predict the visual outcome of parameter changes before committing to an expensive bake.

💡 Why Viscosity Is Often Ignored for Smoke
In the momentum equation, the viscous diffusion term (ν∇²u) smooths out velocity differences. For smoke and fire simulations, kinematic viscosity is typically set to zero or near-zero because atmospheric gases have very low viscosity—turbulent, chaotic motion is precisely the visual effect you want. Liquid simulations, on the other hand, may use non-trivial viscosity to simulate honey, oil, or lava.

Detailed Breakdown — Gas vs. Liquid Simulation Types

Mantaflow in Blender supports two primary simulation domains: Gas (smoke and fire) and Liquid (water, paint, viscous fluids). Although both share the same underlying Navier-Stokes framework, their solvers, data representations, and artistic controls diverge significantly. Gas simulations operate purely on a voxel grid, while liquid simulations use a hybrid FLIP (Fluid Implicit Particle) method that combines grid-based pressure solving with Lagrangian particles to track the free surface of the liquid.

The two pipelines share a common pressure-solve step that enforces incompressibility. The critical difference is that the gas pipeline stores and advects data entirely on the voxel grid, whereas the liquid pipeline shuttles velocity back and forth between particles and the grid (the FLIP method), ultimately generating a polygonal mesh via marching cubes for rendering.
Comparison of Gas and Liquid simulation types in Mantaflow
FeatureGas (Smoke / Fire)Liquid (Water / Viscous)
Data representationVolumetric voxel grid (density, temperature, fuel, velocity)Hybrid FLIP particles + voxel grid; surface mesh via marching cubes
Key parametersBuoyancy Density, Buoyancy Heat, Vorticity, Dissolve Time, Noise ScaleParticle Radius, FLIP Ratio, Viscosity, Mesh Smoothing, Fractions
RenderingVolume shader (Principled Volume) applied to domain; samples density attributeSurface shader applied to generated mesh; can add particle instances for foam/spray
Typical resolution64–256 (with noise upres multiplier of 2×–4×)100–300 (particle count scales with volume)
Cache formatOpenVDB (.vdb) for volumetricsBinary (.bobj.gz) for mesh + Uni for particles

A crucial creative distinction: gas simulations are inherently volumetric—they have no hard surface boundary. This means their appearance is heavily dependent on the volumetric shader settings (density multiplier, scattering anisotropy, blackbody radiation color for fire). Liquid simulations, by contrast, produce a polygonal mesh that can receive surface shaders just like any modeled object, with additional secondary particle systems for spray, foam, and bubble effects.

Worked Example — Setting Up a Smoke Simulation from Scratch

This step-by-step walkthrough demonstrates how to create a basic smoke simulation in Blender using Mantaflow, from an empty scene to a baked result ready for rendering. Follow along in Blender 3.6 or later.

Creating a Rising Smoke Column
1
Step 1 — Create the DomainAdd a cube (Shift+A → Mesh → Cube) and scale it to encompass the area where smoke will exist—for example, scale it to 3 × 3 × 5 meters so smoke has vertical room. In the Physics panel, click Fluid and set the Type to Domain. Under Domain Type, select Gas. Set Resolution Divisions to 64 for a balance of speed and detail during setup.
Domain created — 64³ effective voxel grid mapped to the bounding box.
2
Step 2 — Create the Flow (Emitter)Add a second, smaller mesh (e.g., a UV Sphere or Ico Sphere) inside the domain near the bottom. In the Physics panel, add a Fluid modifier and set the Type to Flow. Set Flow Type to Smoke (or Fire + Smoke for flames). Set Flow Behavior to Inflow for continuous emission, or Geometry for a one-time burst. Adjust Smoke Color if desired, and set Temperature to around 1.0 for visible buoyancy.
Flow object configured — smoke will emit from the sphere's surface each frame.
3
Step 3 — Tune Domain Physics SettingsBack on the domain object, expand the Gas section. Set Buoyancy Density to -0.5 (pulls smoke down slightly for weight) and Heat to 1.0 (drives hot smoke upward). Increase Vorticity to 0.15 to add rolling turbulence. Optionally enable Dissolve with a time of ~25 frames so smoke gradually fades rather than filling the domain.
Physics tuned — buoyancy, vorticity, and dissolve control the visual character.
4
Step 4 — Bake the SimulationIn the domain's Cache section, set the End Frame (e.g., 120) and choose a cache directory. Select Type: Modular so you can bake the base data and noise pass separately. Click Bake Data. After the data bake completes, optionally enable Noise (upres factor 2), adjust Noise Strength (0.5–2.0), then click Bake Noise for the detail pass.
Cache written to disk — playback now shows the simulation in the viewport.
5
Step 5 — Apply a Volume Shader for RenderingSelect the domain and open the Shader Editor. Add a Principled Volume node to the Volume output of the Material Output. The node automatically reads the domain's density attribute. Adjust Density multiplier (try 5–20 for visible smoke) and Color to taste. For fire, enable Blackbody Intensity to map temperature to emission color. Render with Cycles or EEVEE for the final result.
Render-ready — the smoke column appears with natural buoyancy-driven motion and turbulent detail.
Pro Tip: Adaptive Domain
Enable Adaptive Domain in the domain settings to dynamically shrink the simulation volume to only the region containing active smoke. This can dramatically reduce bake times and memory usage, especially when smoke occupies a small fraction of the total domain.

Strengths, Limitations, and Workarounds

Mantaflow is a powerful general-purpose fluid engine, but like every simulation tool, it operates within constraints. Recognizing these strengths and limitations early in your production pipeline helps you allocate resources wisely, choose the right resolution, and decide when to complement the simulation with procedural shaders or compositing tricks rather than brute-forcing higher fidelity.

Mantaflow Strengths vs. Limitations with practical workarounds
StrengthsLimitationsWorkaround
Unified gas + liquid solver under one interfaceNo native multiphase (e.g., oil on water) simulationRun separate domains and composite or overlap in post
Noise upresolution adds detail without re-baking the base simNoise can introduce unrealistic mushroom-shaped artifacts at high strengthsKeep Noise Strength below 2.0 and increase base resolution instead if artifacts appear
Adaptive Domain saves memory for sparse simulationsBake times scale cubically with resolution—doubling resolution ≈ 8× slowerIterate at low resolution (32–64); only final bake at 128+
OpenVDB export for interop with Houdini, Cinema 4D, etc.No GPU-accelerated baking; simulation is CPU-onlyRender on GPU (Cycles/EEVEE) but accept CPU bake times; consider cloud rendering for heavy jobs
FLIP liquid solver produces realistic free-surface behaviorThin features (sheets, droplets) can lose particles and break apartIncrease particle sampling (Sampling Substeps) and reduce particle radius for thin features
KEY TAKEAWAY
Think of Mantaflow's resolution setting like the DPI of a printed image. A low-DPI print is fast and cheap—perfect for draft proofs—but pixelated up close. A high-DPI print is gorgeous but demands far more data and processing. The art of fluid simulation lies in finding the minimum resolution that looks convincing at your camera's framing distance, then strategically layering noise upresolution and shader tricks to push apparent detail beyond what the grid alone provides.

Connection to Advanced Techniques & Industry Tools

Mantaflow provides an excellent foundation, but professional VFX pipelines often extend fluid simulation with more specialized solvers. Understanding where Mantaflow sits in the broader landscape helps you recognize its capabilities as a college-level artist and anticipate the tools you may encounter in studio environments. The table below situates Blender's Mantaflow alongside industry-standard alternatives.

Blender Mantaflow vs. industry fluid simulation tools
AspectMantaflow (Blender)Houdini Pyro / FLIPEmberGen (Real-Time)
MethodGrid-based (gas) / FLIP hybrid (liquid)Sparse grid (OpenVDB), FLIP, multi-solver graphsGPU-accelerated Eulerian grid
InteractivityRequires full bake before final previewInteractive viewport with GPU OpenCL accelerationTrue real-time viewport at production quality
CustomizationLimited to built-in parameters; Python scripting for advanced controlFully node-based; procedural per-voxel control via VEXNode graph with real-time feedback; limited to gas sims
CostFree and open source$4,495 (commercial) / free for learning (Apprentice)$19.99/month (indie)
Best forIndie projects, short films, learning fundamentalsFeature film VFX, complex multi-solver setupsGame VFX, quick iteration on fire/smoke lookdev

Advanced techniques that extend beyond Mantaflow's current scope include machine-learning-guided upresolution (using neural networks to predict high-resolution detail from coarse simulations), narrow-band FLIP (simulating only particles near the liquid surface to save memory), and multi-phase solvers (handling the interaction of distinct immiscible fluids such as oil and water). Interestingly, the Mantaflow research project has published papers on several of these topics, so future Blender versions may incorporate them.

🔮 Looking Ahead: Geometry Nodes & Simulation Nodes
Blender's development roadmap includes a Simulation Nodes system built on top of Geometry Nodes, which will eventually allow artists to build custom solvers visually—without Python scripting. This node-based approach mirrors Houdini's philosophy and will significantly expand what artists can achieve directly inside Blender.

Practice Problems

PROBLEM 1CONCEPTUAL
Explain why increasing the Resolution Divisions parameter from 64 to 128 on a Mantaflow gas domain causes bake time to increase by roughly a factor of eight, not two. Reference the underlying data structure in your answer.
PROBLEM 2BASIC CALCULATION
A gas domain's bounding box is 4 m × 2 m × 6 m and the Resolution Divisions parameter is set to 120 (applied to the longest axis). Calculate the approximate voxel size in meters and the total number of voxels in the domain.
PROBLEM 3INTERMEDIATE
You are simulating a campfire scene. The smoke rises too quickly and looks unrealistically uniform. Identify at least two Mantaflow parameters you would adjust and explain the physical reasoning behind each change based on the buoyancy force equation f_buoy = −α · d + β · (T − T_amb) · ẑ.
PROBLEM 4APPLIED
You need to create a liquid pour into a glass for a product commercial. The glass is 8 cm tall and the camera will be within 30 cm. Outline a complete Mantaflow setup strategy, including domain size, resolution choice, mesh smoothing approach, and how you would handle secondary effects like foam or droplets. Justify each decision.
PROBLEM 5CRITICAL THINKING
Mantaflow's gas solver operates on an Eulerian (grid-based) framework, while its liquid solver uses a hybrid FLIP (particle + grid) approach. Analyze why a purely grid-based method works well for smoke but is inadequate for liquid free-surface tracking. In your response, discuss numerical diffusion, surface definition, and conservation of volume.

Lesson Summary

Blender's Mantaflow engine unifies gas (smoke and fire) and liquid simulation under a single physics framework rooted in the Navier-Stokes equations. The simulation operates within a domain—a bounding volume subdivided into a voxel grid whose Resolution Divisions control detail and bake time in a cubic relationship. Flow objects emit density, temperature, or particles, while effectors create collisions and guides. The solver loop—emission, force application, pressure solve, and advection—executes once per frame, with optional noise upresolution for added turbulent detail.

Key artistic controls map directly to physics: Buoyancy Heat (β) drives hot gas upward, Buoyancy Density (α) pulls heavy smoke downward, and Vorticity amplifies turbulent rolling motion. Gas simulations output volumetric density grids rendered via Principled Volume shaders, while liquid simulations use the FLIP hybrid method to track free surfaces with particles and generate polygon meshes. By iterating at low resolution for creative exploration and reserving high resolution for final bakes, artists can manage the inherent computational cost and produce stunning, physically plausible effects.

Varsity Tutors • Blender • Fluid & Smoke Simulation — Understand fluid/smoke simulation concepts (Mantaflow)