3D Simulation
Explosions, cloth, water, smoke, destruction. It all runs on the same handful of ideas. Learn the shared vocabulary once and every simulation tool starts making sense, whether you open Blender, Houdini or EmberGen. Every demo below is a real physics simulation running live in your browser. Grab things. Break things.
What a simulation actually is
Animation is you telling the computer where things go. Simulation is you setting up the rules and letting the computer figure out where things go - in this way it has similarities with AI generation. The technology is fundamentally different, but it overlaps conceptually - you're trying to set everything up so that you can press “Go” and a computer does the work for you. Like AI, it's incredibly powerful, but also frustrating, because directing it efficiently is the main challenge.
Initial state
Where everything starts. Positions, velocities, pins, temperatures. Frame one of your sim.
Apply forces
Gravity, wind, turbulence, buoyancy. Anything that pushes the system around.
Solve
The solver works out the consequences: collisions, constraints, pressure. This is the maths engine.
Step time
Advance one timestep, write the result, feed it back in as the new state. Repeat until done.
Solver
The algorithm doing the physics. Rigid body solvers, cloth solvers, fluid solvers. Different maths, same job: given this state, what happens next?
Timestep
How big each slice of time is. Usually one frame, often split smaller. Smaller steps mean more accuracy and more compute.
Cache / Bake
Saving the sim result to disk so it plays back instantly and identically every time. You do not render a live sim. You render a cache.
Three ways to represent matter
Before any solver runs, the software has to store what a thing is. There are three ways to do it, and every simulation type is really just one of these three under the hood. Flip between them below: it is the same shape each time, described three completely different ways. Which one you go with depends on what effect you're using. Something that's solid (like cloth) is going to look weird if it's not represented by polygons, which are made to appear solid - whereas polygonal smoke is going to look off for the same reason.
Geometry — a hollow shell of surfaces
A skin of flat triangles stretched over points (vertices). It is hollow: only the surface exists, nothing inside. Cheap, sharp, and what you model and render with. Rigid bodies and cloth live here. The catch: it cannot represent a substance that has no clean surface, like smoke.
Geometry Surfaces
Vertices, edges and faces forming a shell. Rigid bodies, cloth, characters. Anything with a clear skin. Resolution means polygon count.
Particles Points
A cloud of individual points, each carrying its own position and velocity. Liquids (FLIP), sparks, dust, debris. Great for things that split, spray and scatter. Resolution means particle count.
Voxels Grid
3D pixels: a fixed grid of little cubes, each storing values like density and temperature. Smoke, fire, explosions. The only way to represent a continuous volume with no surface. Resolution means voxel size.
The rule of thumb: a clear skin means geometry, something that scatters means particles, a formless volume means voxels. Many effects mix them, for example a FLIP liquid is simulated as particles then wrapped in geometry to render.
Substeps, or why fast things go through walls
The single most common beginner problem: a fast object teleports straight through a collider. Why? The solver only checks the world once per timestep. If the bullet is on one side of the wall this step and the other side next step, it never touched it. The fix is substeps: cutting each frame into smaller slices so nothing gets missed. Fire the ball and watch.
Substeps
How many times the solver divides each frame. More substeps: better collisions and stability, longer sim times. First knob to raise when things explode or tunnel.
Collision object Collider
Geometry the sim bumps into but does not simulate. Also called a passive or static object. Give it thickness where you can; paper-thin colliders invite tunneling.
Scale
Physics runs in real-world units. A 10 metre "coffee cup" falls like a boulder. Model to real scale before you simulate anything. Half of all "broken" sims are scale problems.
Rigid bodies: things that fall and smash
The simplest sim type and the best place to start. Objects that keep their shape while gravity, bounces and collisions throw them around. Destruction, debris, dice, falling rubble: all rigid bodies. Click anywhere in the tank to drop more.
Active vs passive
Active bodies are simulated: they fall, bounce, react. Passive bodies only get collided with: the ground, walls, a table. Every rigid body setup is just deciding which is which. Try it above: make a few objects passive and watch the rest pile up on them.
Restitution & friction
The two numbers that define a material. Restitution is how much energy survives a bounce. Friction is how much things grip when sliding. Concrete: low bounce, high friction. Glass marble: the opposite.
Fracturing
Destruction is pre-shattering an object into chunks (often called Voronoi fracture), gluing them together with constraints, then letting the sim break the glue on impact.
Sleeping
Once a body stops moving the solver freezes it until something touches it. Free performance. If piles of debris keep jittering forever, your sleep threshold is too strict or your scale is off.
Fracturing: breaking things properly
Here is the secret of every CG demolition: nothing breaks during the sim. The object is shattered into chunks beforehand (pre-fracturing, usually with a Voronoi pattern), the chunks are glued back together with constraints, and the sim merely decides when the glue snaps. Click the slab to hit it. Notice the crack pattern appears across the whole slab, but only pieces near the impact break free. The rest hold their glue. Click again to break more.
Pre-fracture, then glue
The workflow is always: shatter first, hold together with glue constraints, let impacts break the glue. The sim never cuts geometry. If your software offers runtime fracturing, treat it as a toy: you get no art direction and no control over where cracks go.
Chunk distribution is the art
Uniform Voronoi screams CG. Real impacts make small dense fragments at the hit point and big lazy chunks further away. Scatter your fracture points with a density falloff from the impact, and paint extra points along lines where you want cracks to travel.
Your mesh must be watertight
Fracturing solid chunks requires closed, manifold geometry. Holes, internal faces and non-manifold edges produce corrupt chunks and exploding sims. Hollow objects (walls, pots, hulls) need real thickness first: fracture the shell, not an infinitely thin surface.
Interior faces need dressing
Freshly cut faces are perfectly smooth with no UVs: instant cut-cheese look. Assign an inside material, add noise or displacement to the cut surfaces, and roughen the crack edges. Most packages tag interior faces for you; use it.
Mass comes from volume
Chunks must weigh what they look like. Density times volume, computed per piece, or the tiny shards will fly like boulders and the boulders drift like paper. Check your solver is set to calculate mass from volume, not a shared fixed mass.
Material decides the pattern
Concrete: chunky Voronoi. Glass: radial spokes plus concentric rings from the impact. Wood: long splinters, made by stretching (scaling) the fracture pattern along the grain before cutting. One Voronoi setting does not fit all materials.
Proxy collision geometry
Do not collide high-res chunks. Solvers use simplified convex hull proxies per piece; concave chunks may need convex decomposition. If chunks jitter, interpenetrate or rest in mid-air, inspect the collision proxies, not the render mesh.
Layer the secondaries
The hero chunks are maybe half the shot. Sell it with debris particles (small rubble instanced on points emitted from the break), dust pyro sourced from fresh crack faces, and matching sound design. A bare RBD sim always reads as fake.
Soft bodies: things that squash and wobble
Rigid bodies keep their shape. Cloth is a flat surface. Soft bodies are the missing middle: solid objects that deform and spring back. Jelly, tyres, rubber, flesh, a stress ball. Under the hood they are the same trick as cloth (points held together by springs) but the springs fill the whole volume, not just a surface, so the object resists being squashed as well as stretched. Drop the blob and poke it around.
Filled with structure
A hollow shell of springs would just collapse flat. Soft bodies add interior structure: either springs crossing through the inside, or a solid mesh of tetrahedra (a tet mesh). That inner scaffold is what gives the object volume and resistance to being crushed.
Stiffness is the whole dial
One value takes you from a bowling ball to a water balloon. It is really how hard the springs pull back to their rest shape each step. Like cloth, high stiffness needs more solver iterations or the object stretches like putty and never holds form.
Volume preservation
Squash a real water balloon and it bulges out sideways: the volume has to go somewhere. Good soft body solvers enforce this (pressure or volume constraints). Without it, a squashed blob just gets thinner and looks wrong, like it is losing material.
The simulation cage
You rarely simulate the detailed render mesh directly, it is too heavy. You sim a low-res cage and bind the pretty high-res model to follow it. Same idea as rigging: cheap thing drives expensive thing. If your hero prop wobbles wrong, inspect the cage, not the render mesh.
Cloth: a net of springs
Cloth is a normal polygonal mesh, driven by a grid of points connected by tiny springs (constraints). Each frame the solver pulls every spring back toward its rest length. How many times it pulls per frame is the solver iterations setting: few iterations and the cloth stretches like rubber, many and it holds shape like canvas.
Pinning
Points excluded from the sim and locked in place (or animated by hand). A flag is cloth pinned on one edge. A cape is cloth pinned at the shoulders. Pin groups are how you attach cloth to characters.
Stiffness & stretch
Real fabric barely stretches. If your cloth looks like melted cheese, raise solver iterations or stiffness before touching anything else. Bend stiffness separately controls how sharply it creases.
Self-collision
Cloth colliding with itself so folds stack instead of passing through each other. Expensive but essential for anything that crumples, drapes or piles up.
Damping
Artificial energy loss. A little stops endless jiggling. Too much and the cloth moves underwater. Every sim type has a damping knob and the advice is always the same: as little as you can get away with.
Liquids: millions of particles pretending
Water in CG is usually a FLIP sim: a huge cloud of particles that push each other apart to stay evenly spaced (that push is pressure), while a grid keeps their motion smooth. Sometimes you render the particles themselves, and sometimes you wrap a mesh around them afterwards (meshing or surfacing) and render that. Stir this tank with your mouse.
Resolution / particle separation
How fine the fluid is divided. Low res: thick, blobby, fast to sim. High res: thin sheets, fine droplets, hours of sim time. Always look-dev at low res, only up-res the final.
Viscosity
Internal thickness. Water is near zero, honey is high, lava is huge. One slider takes you from splash to ooze.
Surface tension
The skin that pulls small amounts of liquid into droplets and beads. Matters at small scale (drips, pours), invisible at ocean scale.
Whitewater
Foam, spray and bubbles added as a secondary particle sim on top of the main fluid, spawned where the water is fast and churning. It is what sells an ocean.
Pyro: smoke, fire & explosions
Smoke and fire are volume sims. The container is divided into a 3D grid of little cubes called voxels (think Minecraft...) and each voxel stores numbers: how much smoke (density), how hot (temperature), how much unburnt fuel. Heat makes voxels rise (buoyancy), rising air curls into rolling shapes (turbulence), and smoke slowly thins out (dissipation). An explosion is just all of that happening very fast from a single violent burst.
Voxel size / division size
The pyro version of resolution. Smaller voxels: crisp licking flames and fine smoke detail, plus exploding sim times and RAM use. Same golden rule: test coarse, finalise fine.
Sourcing / emission
How stuff enters the sim: an object or particle system injecting density, temperature and fuel each frame. A campfire sources gently forever. An explosion sources everything in two frames.
Fire is temperature
Flames are not painted on. They are the hottest voxels rendered as glowing light (blackbody shading: white-hot to orange to red as it cools). Smoke is the cooled remainder.
Velocity field
The invisible wind inside the container that everything rides on. Advanced trick: sim a cheap velocity field, then drive particles or other sims with it. Art-directing pyro is mostly art-directing velocity.
Particles: the glue of every effect
Under everything above sits the humblest sim of all: points flying through space. Sparks, rain, dust, debris, magic trails, crowds. Learn four words and you can read any particle system in any software, and make friends at any particle party.
Emitter
Where and how particles are born: from a point, a surface, a volume, or per-vertex. Key settings: birth rate (how many per second) and initial velocity (which way they launch).
Lifespan / age
How long each particle lives before dying, usually with random variation. Almost every visual property (size, colour, opacity) is animated over life: sparks shrink and fade, smoke puffs grow and thin.
Forces
The same cast as everywhere else: gravity, wind, drag, turbulence (noise), attract and repel. Layering two or three forces is how random points start looking like intentional motion.
Instancing
Particles are usually invisible points used as placement: you instance real geometry onto them (rocks, leaves, ships) or render them as sprites. One sim, a million copies, tiny memory cost.
The workflow every pro follows
The software changes. This sequence never does.
Fix your scale first
Real-world units before anything else. Physics does not care what looks right in the viewport, only how many metres things are.
Block it at low resolution
Get timing, direction and scale of motion working with a coarse, fast sim you can iterate on in seconds. Nobody art-directs at final quality.
Art-direct with forces, not wishes
Sim not doing what you want? Add invisible forces: wind to push smoke screen-left, a drag field to slow debris, noise for chaos. Cheating is the job.
Up-res, then walk away
When the coarse sim reads well, raise resolution and substeps, hit simulate, and go make coffee. Never keep tweaking at high res.
Cache everything
Bake the result to disk before you light, shade or render. A cache scrubs in real time, survives crashes, and guarantees every render frame matches.
Sell it in the render
Motion blur on debris, glow on fire, refraction on water, and grade to match the plate. Half of a great sim is what happens after the sim.
Where to actually do this
Same concepts everywhere; only the button names change. For a first-time filmmaker the honest map looks like this:
| Tool | Best for | The catch |
|---|---|---|
| Blender | Free. Rigid bodies, cloth and particles are genuinely good. Fluids and smoke (Mantaflow) fine for learning and mid shots. | Big fluid and pyro sims get slow and fiddly at scale. |
| Houdini | The industry standard for all of it. Apprentice version is free to learn on. FLIP, Pyro and Vellum (cloth/softbody) are best in class. | Node-based and famously steep. Worth it, but budget real learning time. |
| EmberGen | Real-time GPU fire, smoke and explosions. Iterate on a shot in minutes instead of hours. | Pyro only, and it is paid software. |
| Marvelous Designer | Cloth and garments specifically, built like a tailoring app. | Only clothes. Paid. |