Noise functions turn raw randomness into structure that can be tuned, reproduced, and layered. That is why they appear everywhere in procedural graphics: terrain, clouds, water, fire, masks, surface breakup, and any system that needs variation without obvious repetition. The point is not only that the output looks organic. The point is that the function has a controllable relationship between position and value, so you can change scale, rearrangement, or detail without rewriting the whole effect.

Three terms usually appear first: value noise, Perlin noise, and fractal noise. They are related, but they are not the same object. Value noise interpolates random scalar values on a lattice. Perlin noise changes the lattice data to gradients and then interpolates the resulting influence. Fractal noise is a composition rule that stacks multiple octaves of a base noise to create detail across scales.

The first visual below starts with the simplest of those three ideas: one base noise field and the way frequency changes its visible scale.

Value Noise As Interpolation

Value noise starts with a lattice and assigns one random scalar to each lattice point. In one dimension, the simplest version looks like this:

$$v(x) = (1 - t)a + tb$$

with $t = s(x - i)$.

Here, a and b are the random values at the two nearest lattice points, i is the integer cell index, and s(.) is a smooth fade function that turns a raw coordinate into a soft interpolation weight. In two dimensions, the same idea becomes bilinear interpolation across four corners. The sample point first blends left and right, then blends those intermediate results top to bottom.

$$v(x,y) = \mathrm{lerp}\big(\mathrm{lerp}(v_{00}, v_{10}, u), \mathrm{lerp}(v_{01}, v_{11}, u), w\big)$$

with $u = s(x - x_0)$ and $w = s(y - y_0)$. The value at the point is therefore not random in the direct sense. It is a weighted combination of nearby lattice values.

That is the core intuition to watch in the generator. When frequency rises, the interpolation happens over a smaller spatial distance, so the same noise function shows more tightly packed hills and valleys. When the seed changes, the interpolation rule stays the same but the corner values change, so the arrangement changes without changing the feature scale. And when octaves increase, the generator is no longer just one interpolated field; it becomes a sum of fields at different scales.

The key mathematical detail is that the smoothness comes from the interpolation curve, not from the random numbers themselves. If the fade curve is linear, the result has visible kinks where cells meet. If the fade curve is smooth, the transitions are gentler and the field is easier to use for graphics work. That is why value noise is often the first noise function people learn: the implementation is direct enough to map cleanly to the math.

Value noise is useful, but it has a particular character. The stored data lives at the corners, so the grid can still leave a trace in the result if the pattern is inspected closely or used in situations where the field drives lighting or geometry. That makes it a good baseline, but not always the best final answer when a more directional local structure is needed.

Perlin Noise Changes The Lattice Data

Perlin noise keeps the same lattice-and-interpolation structure, but it changes what is stored at each corner. Instead of a scalar value, each corner stores a gradient vector. At sample position $p$, the corner contribution is the dot product between the corner gradient and the offset from that corner to $p$:

$$c_i(p) = g_i \cdot (p - p_i)$$

The final value is then built by interpolating those corner contributions across the cell. So the field is still smooth, but the smoothness now comes from directional influence rather than from blending stored heights.

That difference matters because gradients encode local push or pull. If the sample point is close to a corner whose gradient points toward it, the dot product is positive. If the gradient points away, the dot product is negative. The result is a field that usually feels more coherent than value noise because the information at each corner is directional, not just scalar.

There is also an important continuity reason Perlin noise became so influential. The smooth fade curve is chosen so the interpolation does not introduce visible seams at lattice boundaries. In practice, that means the field can be sampled repeatedly without obvious cell edges showing up in the result. The improved Perlin formulation is discussed in Improving Noise, and the original procedural-texture framing is in An Image Synthesizer.

You can read the math of Perlin noise as a two-step process:

1. Measure how each gradient relates to the sample point through a dot product.
2. Interpolate those local influences with the same kind of fade curve used in value noise.

That is why Perlin noise is often called gradient noise. The term identifies the stored lattice data, which is the part that changed. The visible effect is not just “smoother random texture”; it is a different local field structure.

Perlin noise is also the place where the scale controls start to matter more clearly. If the frequency is too low, the gradients change too slowly and the field reads as broad undulation. If the frequency is too high, the structure becomes tight and busy. The underlying equation is still the same, but the coordinate transform $p \mapsto f p$ changes the visible result a lot.

Fractal Noise Adds Octaves

Fractal noise is not a separate base noise formula. It is a sum of layers, usually written as an octave stack:

$$F(p) = a_0 n(f_0 p) + a_1 n(f_1 p) + \cdots + a_{N-1} n(f_{N-1} p)$$

Here, $n$ is the base noise function, $N$ is the number of octaves, $f_i$ is the frequency of octave $i$, and $a_i$ is its amplitude. In the common fBm setup, the frequency grows by a constant factor each octave and the amplitude shrinks by a constant factor:

$$f_i = f_0 \lambda^i, \qquad a_i = a_0 g^i$$

Here, $\lambda$ is lacunarity and $g$ is gain. That compact notation describes the whole idea of fractal layering: broad structure comes from low-frequency layers, and finer detail comes from higher-frequency layers that contribute less strongly.

The visual result is easy to understand once you read the formula in that direction. The first octave sets the large form. The second octave refines it. The later octaves keep adding detail, but their lower amplitude keeps them from overpowering the shape. That is why fractal noise feels natural: real surfaces often have structure at several scales, not just one.

The important practical warning is that more octaves are not automatically better. If the amplitude does not decay fast enough, the fine layers start to compete with the broad layers and the result looks noisy rather than structured. If the decay is too aggressive, the later octaves add too little to matter. The ladder visualization below makes that tradeoff easier to see.

Octave Stacking As A Ladder

The ladder turns the octave sum into a visual hierarchy. Each row is one octave, and each octave has a different frequency and amplitude. The lower rows contribute the broadest shape, while the upper rows sharpen or roughen that shape at smaller scales. That is the visual meaning of the equation above: each term is a separate scale band, and the final signal is their weighted sum.

The controls in the ladder match the symbols in the formula. Octaves changes $N$, the number of layers in the sum. Lacunarity changes $\lambda$, which determines how quickly the frequency increases from one octave to the next. Gain changes $g$, which determines how quickly the amplitude falls off. The draggable probe is useful because it keeps one spatial position aligned across every row, so the same point can be read at several scales at once.

The bottom track is the summed output. That is the important thing to compare. If the upper rows make the combined shape easier to read, they are doing useful work. If they only add grain, they are past the point of diminishing returns. The article on Random Fractals: Self-Affinity in Noise, Music, Mountains, and Clouds is a good conceptual reference for why multi-scale structure often looks more natural than a single-scale field.

The ladder also clarifies why fractal noise is a composition rule rather than a new primitive. The base noise can be value noise or Perlin noise. What makes the result fractal is not the specific base choice by itself, but the repeated rescaling and reweighting across octaves. That distinction is easy to miss if you only look at a single finished image.

Seed, Frequency, And Octaves Are Different Knobs

Noise controls are easy to confuse because they all change the picture, but they do so in different ways. The cleanest separation is:

$$n(x, y; seed, f, N)$$

Here, $seed$ changes the pseudo-random arrangement, $f$ changes the input scale, and $N$ changes the number of layers. That compact notation hides the implementation details, but it is useful because it makes the control roles explicit.

Seed changes the hash input. If a lattice point is assigned by a hash function $h(i, j, seed)$, then changing the seed changes the corner data without changing the interpolation rule. That is why seed is about reproducibility and rearrangement, not feature size.

Frequency rescales the coordinates before sampling. The simplest form is $n(fx, fy)$. Increasing $f$ compresses the pattern in world space, so the same domain contains more variation. Decreasing $f$ stretches the pattern, so the field reads as broader and calmer.

Octaves changes the number of summed layers. In other words, it changes the length of the series in the octave equation. It is not a style knob and it is not a brightness knob. It is a hierarchy knob. That is why it is so effective for terrain and cloud work, where the goal is often to get broad form plus fine breakup without losing the original shape.

Once those roles are separate, the downstream use cases become easier to reason about. If you are building a heightmap, frequency tells you how wide the hills are before the surface is meshed. If you are perturbing a signed distance field, the same base noise can deform the surface without destroying the signed distance structure. If you are evaluating noise in a shader, the octave count directly affects cost, because every extra layer adds another sampling pass. Those downstream concerns connect directly to heightmap to mesh, signed distance fields, and vertex and fragment shaders in the graphics pipeline.

A Practical Reading Order

The most useful way to read the three techniques is to keep the pipeline in order. Start with one base field. Value noise gives the simplest version of that idea: random scalars at lattice points, smoothly interpolated. Perlin noise keeps the lattice but changes the corner data to gradients, so the local field is directional instead of purely scalar. Fractal noise then stacks either base field across scales so the final result keeps both form and texture.

That order is deliberate. You do not begin with octaves. You begin with the scale of the base field. If that scale is wrong, octaves only make the mistake more complicated. If the base scale is right, octaves are the part that gives the pattern believable richness.

The same pipeline logic is why the terminology matters. If a control changes the pseudo-random arrangement, it is a seed control. If a control changes the spacing of features, it is a frequency control. If a control changes how many scales are present, it is an octave control. Once those three roles are separate, the math and the visuals line up with each other instead of fighting each other.

Summary

Value noise, Perlin noise, and fractal noise are related, but they are not interchangeable. Value noise interpolates random scalar corner values. Perlin noise interpolates gradient influence. Fractal noise sums multiple octaves so one signal can cover broad structure and fine detail at the same time.

The visualizations above are meant to keep those differences concrete. The noise generators show how frequency, seed, and octaves affect the visible field. The ladder shows how the octave sum builds a hierarchy instead of a single layer. The math explains why those changes matter: different stored corner data, different coordinate scales, and different octave weights produce different kinds of structure.

That is the main lesson to carry forward when noise becomes an input to a larger pipeline, especially in ray marching and other field-based rendering workflows.