Perlin Noise

If you scatter random numbers across a grid you get static — every pixel a different shade, nothing recognizable as a mountain, cloud, or river. But nature does not work that way. Altitude changes smoothly: a valley widens gradually, a cliff steepens over meters, not pixels. Replicating that smoothness in software is what Perlin noise solves.

Ken Perlin invented the technique in 1983 while working on the movie Tron at New York University. He needed textures that looked organic rather than hand-painted or purely random, and the result won him an Academy Award for Technical Achievement. Since then, Perlin noise has become the default tool for procedural generation — the branch of computing that invents content algorithmically instead of storing it.

The core idea is deceptively simple: assign a random gradient vector at every integer grid point, then blend those gradients smoothly across the space between them. The output is a continuous function that looks locally random but is globally smooth — exactly the texture of real terrain.

The canvas below draws a rolling cross-section of terrain generated by stacking layers of Perlin noise. Use the controls to change the number of octaves, the persistence (how much each layer contributes), and the base frequency.

<!-- {{c_html_intro}} -->
<div class="controls">
  <label>{{lbl_octaves}} <span id="oct-val">4</span>
    <input type="range" id="octaves" min="1" max="8" value="4">
  </label>
  <label>{{lbl_persist}} <span id="per-val">0.50</span>
    <input type="range" id="persistence" min="10" max="90" value="50">
  </label>
  <label>{{lbl_freq}} <span id="freq-val">3</span>
    <input type="range" id="frequency" min="1" max="10" value="3">
  </label>
  <button id="reseed" type="button">{{btn_reseed}}</button>
</div>
<canvas id="terrain" width="600" height="220"></canvas>
<p class="caption" id="caption">{{caption_default}}</p>

/* {{c_css_intro}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; background: #f5f7fa; color: #222; }
.controls {
  display: flex; flex-wrap: wrap; gap: .6rem 1.2rem;
  align-items: center; padding: .6rem .4rem .4rem;
}
label {
  display: flex; align-items: center; gap: .4rem;
  font-size: .85rem; font-weight: 600; color: #334;
}
input[type=range] { width: 90px; accent-color: #3d6fa8; cursor: pointer; }
#reseed {
  font: 600 13px system-ui, sans-serif; padding: .35rem .8rem;
  border: 1px solid #3d6fa8; background: #3d6fa8; color: #fff;
  border-radius: 7px; cursor: pointer;
}
#reseed:hover { background: #2d5a8e; }
canvas {
  display: block; width: 100%; max-width: 600px;
  border-radius: 8px; border: 1px solid #d0d8e4;
}
.caption {
  font-size: .8rem; color: #556; margin: .4rem 0 0;
  min-height: 1.3em; line-height: 1.4;
}

// Code not found

Watch what happens as you add octaves: the first octave gives broad hills; the second adds medium ridges; the third carves out fine gullies. Each layer doubles the frequency and multiplies the amplitude by the persistence value. That exponential relationship is called fractional Brownian motion (fBm), and it is the reason both coastlines and mountain ranges obey the same statistical self-similarity at every scale.

Step 1 – gradient grid. Divide the plane into unit cells. At each integer corner, pick a random unit vector (the gradient). The same seed always produces the same gradients, so the noise is deterministic.

Step 2 – dot products. For any query point $\mathbf{p}$ inside a cell, compute the vector from each corner to $\mathbf{p}$, then take its dot product with that corner's gradient. These four numbers measure how well $\mathbf{p}$ "lines up" with each surrounding gradient.

Step 3 – smooth interpolation. Blend the four dot products using the fade function

$$f(t) = 6t^5 - 15t^4 + 10t^3$$

This quintic ensures $f'(0) = f'(1) = 0$ and $f''(0) = f''(1) = 0$, so adjacent cells join with matching first and second derivatives — no visible seam, no grid artefact.

Step 4 – octaves (fBm). A single pass produces gently rolling hills. To add detail, sum $n$ copies with geometrically increasing frequency and decreasing amplitude:

$$\text{fBm}(x) = \sum_{k=0}^{n-1} p^{k} \cdot \text{noise}(2^{k} x)$$

where $p$ is the persistence (typically $0.5$). Each octave halves the amplitude and doubles the frequency, mimicking the self-similar roughness of real terrain. The related concept of compression explains why self-similar signals compress so efficiently — both rest on the same statistical regularity.

Complexity. Evaluating one noise sample at $n$ octaves costs $O(n)$ dot products and smooth interpolations — a handful of floating-point multiplications per pixel. That is why it runs in real time even on thousands of simultaneous samples.

Perlin noise has spread far beyond the film set where it was born:

• Video games: Minecraft uses a 3-D Perlin-style noise to carve caves and mountains; No Man's Sky uses it to seed billions of unique planets. Almost every modern game engine ships a noise library.
• Film and TV visual effects: fire, smoke, ocean surfaces, and alien atmospheres are all shaped by layered noise. Modern renderers evaluate hundreds of millions of noise samples per frame.
• Procedural textures: wood grain, marble, rust, and skin are approximated by noise fed through color ramps. A single function replaces gigabytes of hand-painted texture maps.
• Scientific simulation: noise initialises turbulent fluid fields in computational fluid dynamics solvers, seeding realistic eddies without expensive random-number overhead.
• Generative AI: diffusion models add structured noise to images during training and remove it during generation — the noise schedule is a distant conceptual cousin of fBm.

Perlin noise also inspired Simplex noise (also by Perlin, 2001), which removes the remaining grid bias by working on a triangular lattice, and OpenSimplex noise, an open reimplementation. These successors dominate non-convex optimization landscapes in machine-learning research, where smooth but irregular loss surfaces are deliberately constructed for testing.

Perlin noise is one of those rare algorithms whose elegance matches its utility. Three operations — assign gradient vectors, dot-product them with offset vectors, blend with a smooth fade curve — yield a function that looks natural at every scale, costs almost nothing to evaluate, and is infinitely reproducible from a single seed.

Stack enough octaves and you do not just get a mountain; you get a mountain with foothills, boulders, and pebbles, each level of detail obeying the same self-similar law. That is the promise of procedural generation: infinite content from finite code. The next time you wander an endless open world or watch fire ripple across a film screen, there is a good chance a descendant of Ken Perlin's 1983 trick is running beneath it all.