How do you animate fire? Not with a mesh — flame has no surface to model. It flickers, splits, curls and dies, and it has no fixed shape from one frame to the next. The same is true of smoke, sparks, rain, dust, a waterfall's spray, or the shimmer of movie magic. These fuzzy phenomena defeated the polygon-and-mesh pipeline entirely — until, in 1982, Bill Reeves needed to set a dead planet ablaze for the "Genesis effect" in Star Trek II: The Wrath of Khan and reached for a completely different idea: don't model the shape, simulate a crowd of thousands of tiny independent points and let the look emerge.
That idea — the particle system — is still the workhorse for every fuzzy effect in
games and film. This page teaches what a particle is, how an emitter births them, how each
one is pushed around by forces and then quietly dies, and how millions of them get drawn as glowing
camera-facing sprites. It builds on
The whole trick rests on making each particle as cheap as possible, because you want a great many of them. A particle is not a mesh, not an object — it is a lightweight bundle of numbers: a point that carries a little state.
In code a particle is just a struct, a dozen numbers wide:
There is no geometry, no vertices, no faces. One particle on its own is invisible-dull — a single dot. The magic is entirely in the numbers: put ten thousand of these together, each following the same simple rules with slightly different starting conditions, and the crowd behaves like fire.
Particles don't exist forever, and a fire needs a steady supply of fresh ones to replace those that burn out. That supply comes from an emitter — a source that spawns new particles at some spawn rate (say 500 per second), handing each newborn its initial state. Emitters come in shapes:
| Emitter | Spawns particles… | Good for |
|---|---|---|
| Point | all from one spot | a spark shower, a fountain jet |
| Area / disc | across a 2-D patch | rain over a region, a campfire base |
| Volume | throughout a 3-D box or sphere | dust in a room, a fog bank |
| Mesh surface | over an object's skin | a body catching fire, steam off a kettle |
The single most important thing an emitter does is randomise those initial conditions. If every particle launched with the identical velocity, they would all move in lockstep and read as one rigid clump. Instead the emitter jitters each birth: a random direction inside a cone, a random speed in a range, a random lifetime, a small colour variation. That scatter is exactly what gives the system its organic, stochastic look.
Every frame (a time step
The forces are what give each effect its character. A short menu of the common ones:
Let's do a single step by hand. Take a spark just launched straight up:
1. Force → acceleration. The only force is gravity, so
2. Integrate velocity.
3. Integrate position. Using the new velocity,
4. Age and fade. New age is
Below is a tiny fountain of nine particles launched from a point emitter in a spread of directions, each an independent projectile under gravity. Drag the time slider (or press Play) to march the simulation forward and watch the arcs; drag launch speed and gravity to reshape the spray. Fast launch + weak gravity throws a tall, wide plume; slow launch + strong gravity gives a squat dribble. Every dot obeys the very same two integration lines — the variety comes entirely from their differing launch directions.
In 1982 the Pixar-to-be team at Lucasfilm had to show a barren planet erupting into a spreading wall of fire that races across its surface. There is no object there to model — a wall of fire is pure turbulent chaos. Bill Reeves's insight, written up in his 1983 paper "Particle Systems — A Technique for Modeling a Class of Fuzzy Objects," was to represent the fire as thousands of glowing particles thrown outward from expanding rings of emitters, each living a second or two, changing colour from white-hot to red to dark as it aged, and dying. No single particle looks like fire; the emergent behaviour of the whole cloud does. It was one of the first times computer graphics animated something with no surface at all, and the technique it launched now renders every explosion, waterfall and dust cloud you see on screen.
A particle is a mathematical point, but you can't draw a point — you draw a small sprite (a textured quad: a soft blob, a smoke puff, a spark streak) at the particle's position. To avoid the illusion breaking when the camera moves around, the quad is a billboard: it is rotated every frame to always face the camera, so you never catch it edge-on and see it vanish.
Two rendering choices sell the effect:
Because every particle updates independently with the identical little program, particle systems are almost perfectly parallel — which is exactly what a GPU eats for breakfast. A modern GPU particle system keeps the entire particle buffer in video memory and runs the spawn / integrate / age / cull loop in a compute (or vertex) shader, thousands of particles per shader invocation, all in flight at once. The particles never make a round trip back to the CPU. This is what lifts the budget from a few thousand CPU particles to millions: dense sandstorms, volumetric smoke, sparks by the fistful, all simulated and rendered on the graphics card in real time.
The reason particle systems are so cheap is a deliberate cheat: particles are almost always
independent. Each one integrates against the global force field (gravity, wind,
drag) but does not see the other particles — no collisions, no pushing, no piling up. The
cost of the update is then simply linear,
This is exactly why cheap fire, smoke, sparks and rain look right: those things really are clouds of
near-independent bits that pass through one another. But it is also why a naive particle system makes
a terrible pile of sand or heap of gravel — a pile only exists because grains
collide and rest on each other, and independent particles just fall straight through
the floor into an overlapping mush. The moment you need particles to interact — sand, cloth, fluid
with pressure, stacking — you must add inter-particle forces (collisions,
SPH pressure, neighbour queries), and the cost jumps toward
A particle system is a beautiful example of emergence: no particle knows it is part of a fire, yet many simple points running one three-line update produce something that convincingly is one. The recipe never changes — an emitter randomises births, a per-particle update integrates forces and ages each one, dead particles are culled, and survivors are drawn as camera-facing sprites whose size and colour ride their age. Swap the forces and the sprite and the same machine gives you sparks, smoke, rain, dust, or magic.