Watch a resting character in a good game or film and they are never truly still: the chest lifts and falls, the weight drifts subtly from one foot to the other, a stray lock of hair sways, the eyes make tiny wandering saccades. None of that is hand-keyed frame by frame — it would take forever and still look mechanical. It is procedural motion, and the engine that quietly drives almost all of it is coherent noise: Ken Perlin's 1983 invention (he won an Academy Award for it) that turns a clock into a natural, living wobble.

This page is about one deceptively simple move: sample a smooth noise function along time and feed the result into a parameter — a camera offset, a flicker, a sway angle. The trick is entirely in which random function you sample. Reach for the obvious one and you get garbage; reach for Perlin (or its faster cousin, simplex) and you get life.

Why random() is useless for motion

The naive idea is to jitter a value with a fresh random number every frame: x(t) = \text{amplitude} \cdot \texttt{random}(). It looks fine frozen on a single frame, but in motion it is a disaster. Plain random() is uncorrelated: the value at frame 100 knows nothing about frame 99, so every frame teleports to a brand-new spot. The eye reads that as static — buzzing, epileptic noise, not motion. Real things have momentum; where they are now is close to where they were a moment ago.

Those three properties are exactly what hand-keyed "organic wobble" tries to fake. Perlin noise gives them for free, as a pure function you can evaluate anywhere.

How Perlin noise is built

The construction is neat. Lay down a regular grid of integer points. At each grid point, deterministically hash its coordinates into a fixed pseudo-random gradient vector (in 1D just a slope, positive or negative). To evaluate the noise at some point p between grid points:

Because the value is pinned to 0 at each grid point and eased between them, the result glides smoothly, never repeats obviously, and stays inside a bounded range (roughly [-1, 1]). Simplex noise is Perlin's later reworking that uses a triangular/tetrahedral grid instead of a square one — cheaper in high dimensions and free of the faint axis-aligned artefacts of the classic version — but the idea and how you use it are identical. (For the maths of the interpolation kernels, see value and gradient noise.)

Sampling noise along time

Here is the whole idea in one line. Instead of a fresh random number per frame, evaluate 1D noise at the current time and use that as your parameter:

The amplitude A sets how far the value swings; the frequency f sets how fast it wanders (it stretches or squeezes the time axis before sampling). Because \operatorname{noise} is coherent, consecutive frames read consecutive, nearby points on the curve — the motion is smooth by construction. Swap in different amplitudes, frequencies and channels and one function paints a whole catalogue of "alive":

Every one of these used to be tedious hand-keyed wobble. As procedural motion, it is a single call per frame, and it never loops or repeats.

Worked example: procedural camera shake

Suppose we want a handheld feel: a small, restless offset added to the camera each frame. We drive it with \text{offset}(t) = A \cdot \operatorname{noise}(f \cdot t). Play with the two knobs below and watch the curve.

Two things to notice. Raising the frequency f makes the wobble jittery — more wiggles packed into the same span, a nervous, caffeinated camera. Raising the amplitude A makes it wilder — the same wandering, but with bigger swings. Yet through all of it the curve stays smooth: no vertical jumps, no teleports. Plot plain random() beside it and you would see a solid band of vertical static instead — that is the whole difference between noise and randomness. Because the underlying noise here is fully deterministic (a fixed seed), replaying the shot gives byte-for-byte the same shake: reproducible for review, unlike a per-frame RNG.

Layering detail: fBm and octaves

A single noise call gives one scale of motion — either a slow drift or a fast buzz, not both. Real motion has structure at many scales at once: a big lazy sway with tiny quick tremors riding on top. You get that by summing several noise samples at doubling frequencies and halving amplitudes — octaves — a sum called fractional Brownian motion (fBm):

The first octave gives the broad, slow shape; each further octave adds finer, faster detail at progressively smaller amplitude. Two extra parameters control the mix: lacunarity (how fast frequency grows per octave, usually 2) and gain or persistence (how fast amplitude shrinks, usually \tfrac12). Coarse + fine layered together is what makes handheld camera shake read as a real operator's hands rather than a metronome.

Multi-dimensional wander: the meandering firefly

To make something drift around a 2D area — a firefly, a bird, a hovering drone — you need two smoothly-varying numbers, one for x and one for y. The instinct is to sample the same noise curve for both. Don't — that is the classic trap below. Instead read the noise at two different offsets (or with two different seeds), so the channels vary independently:

Because the two samples come from unrelated stretches of the noise, x and y rise and fall on their own schedules, and the firefly traces a lazy, looping, never-repeating path. (In 2D/3D noise you would instead pass a whole point, \operatorname{noise}(x, y), and sample it at a moving location — same principle, different signature.)