Baking Simulations — Bake simulations and manage cache files

Historical Context & Motivation

Physics simulation in 3D computer graphics has always faced a fundamental tension between computational cost and creative control. Early visual effects studios in the 1990s ran cloth, fluid, and particle simulations that could take hours or even days to compute, yet a single parameter tweak would invalidate the entire result and require a full recalculation. The concept of baking — pre-computing simulation data and writing it to disk as a persistent cache — arose from the practical need to separate the expensive solve phase from the iterative compositing and rendering phases of production.

Blender's simulation infrastructure has evolved significantly since its open-source release, incorporating increasingly sophisticated caching systems that mirror those found in proprietary packages like Houdini and Maya. Understanding this evolution helps contextualize why baking is not merely a convenience feature but a critical part of any simulation-based production pipeline.

The central question this lesson addresses is both practical and conceptual: how does one transform a volatile, frame-dependent physics calculation into a stable, portable dataset that can be reliably rendered, shared across a team, and archived for future iterations? The answer lies in mastering the bake-and-cache workflow — a workflow that governs every simulation type in Blender.

Core Principles & Definitions

Before diving into specific workflows, it is essential to establish a shared vocabulary and understand the foundational ideas that underpin simulation baking in Blender. Every simulation system in the software — whether it handles cloth draping over a character, rigid bodies colliding in a destruction sequence, or fluid pouring into a glass — relies on the same core loop: a solver steps through time, computing forces and positions frame by frame, and the results are either held temporarily in memory or permanently committed to disk as a cache.

A critical distinction for production work is the difference between internal caching (data stored within the .blend file) and external caching (data written to a folder on disk). Internal caches are convenient for small simulations and personal projects because everything lives in one file. External caches, however, are essential for team workflows, large datasets, and render farms because they decouple the simulation data from the scene file, allowing multiple artists or machines to access the same cached result without transferring a bloated .blend.

Visual Explanation — The Baking Pipeline

The following diagram illustrates the complete baking pipeline from simulation setup through cache management. Each stage represents a discrete step that you will encounter in Blender's Physics Properties panel, and the arrows indicate the directional flow of data — from solver to cache, and from cache to render engine.

Notice that the pipeline is not purely linear. The Cache Management Zone introduces a feedback loop — a reality of production work where artists iterate repeatedly. When you change a collision object's position or alter the viscosity of a fluid, Blender marks the existing cache as stale. You must explicitly free the bake (delete the old cache data), adjust your parameters, and then re-bake. This deliberate invalidation model protects you from accidentally rendering with outdated simulation data — a mistake that in professional studios can waste hours of render-farm time.

How Baking Works Under the Hood

While Blender abstracts much of the complexity behind a single "Bake" button, understanding the underlying mechanism deepens your ability to diagnose problems, optimize performance, and make informed decisions about cache strategies. At its core, baking is a serialization process — the solver's in-memory state is converted into a structured data format and written to storage.

The Frame Loop

When you click "Bake," Blender enters a sequential frame loop beginning at the cache's start frame and ending at the end frame. At each frame, the solver evaluates the physics equations for that timestep, considering all forces, collisions, and constraints. Crucially, simulations are temporally dependent — frame 50 cannot be computed without first solving frames 1 through 49, because each frame's state depends on the previous frame's result. This is why you cannot bake arbitrary frame ranges out of order, and why a partial cache break at frame 100 invalidates everything after it.

Cache Size Estimation

For production planning, estimating cache size is important. The total disk footprint of a baked simulation depends on the amount of data per frame multiplied by the number of frames. For particle systems, each particle stores position (3 floats × 4 bytes), velocity (3 × 4 bytes), and additional attributes, while fluid simulations store full 3D voxel grids whose size scales with the cube of the resolution divisor.

Detailed Breakdown — Cache Types & Management

Different simulation systems in Blender produce different types of cache data, and understanding these distinctions is critical for managing disk space, organizing project directories, and collaborating with other artists or departments. The following diagram provides a classification of cache types organized by simulation category.

Cache Directory Structure

When you set an external cache path, Blender creates a folder structure that organizes cache files by object name and simulation type. A well-organized cache directory is essential for team workflows. A typical Mantaflow fluid bake generates three sub-caches within the domain's folder: data (the volumetric simulation data), mesh (the generated liquid mesh), and particles (spray, foam, and bubble secondary particles). Each sub-cache must be baked independently, and they must share the same frame range to remain synchronized. Failure to bake all three results in partial or invisible fluid renders — a common pitfall for artists new to Mantaflow.

Worked Example — Baking a Cloth Simulation

Let us walk through a complete baking workflow for a common visual arts scenario: a fabric curtain affected by wind, draped over a collision object. This example covers the full cycle from setup through cache management and demonstrates the decisions you will make in any baking workflow.

Strengths, Limitations & Comparisons

Baking is not without tradeoffs. Understanding when to bake, when to rely on live preview caches, and when to use alternative approaches like Alembic export or bake-to-keyframes requires weighing several factors including disk space, iteration speed, portability, and render-farm compatibility.

Bake-to-Keyframes vs. Bake-to-Cache

Rigid body simulations offer a unique option: Bake to Keyframes (found under Object → Rigid Body → Bake to Keyframes). Instead of writing cache files, this converts the simulation into traditional location and rotation keyframes on each object's F-curves. The advantage is that you can then manually edit the motion in the Graph Editor — nudging a bouncing box's final resting position, for instance. The disadvantage is that the simulation's physical accuracy is lost once you begin editing individual curves, and the approach does not scale well to scenes with hundreds of rigid bodies.

Connections to Advanced Workflows

The baking concepts covered thus far form the foundation for more advanced simulation workflows that you will encounter as you progress in visual effects production. Two major areas extend naturally from this lesson: Geometry Nodes simulation zones and cross-application cache pipelines.

The OpenVDB format deserves special mention as a bridge to cross-application workflows. Because OpenVDB is an open-source industry standard maintained by the Academy Software Foundation, smoke and fire caches baked in Blender can be imported directly into Houdini, Nuke, or any VDB-compatible renderer. Similarly, Alembic (.abc) serves as the universal mesh-cache format for exchanging animated geometry between Blender, Maya, Cinema 4D, and Unreal Engine. As a visual arts student, developing fluency with these interchange formats positions you to work effectively in multi-software studio environments.

Practice Problems

The following problems test your understanding of simulation baking concepts, cache management, and production decision-making. Work through them in order; they progress from conceptual understanding to applied critical analysis.

Lesson Summary