A random number generator returns unrelated values at nearby points. A noise function returns related values: nudge the input and the output changes by a small amount instead of jumping to a new number. That single property is what makes noise useful in graphics, because a smooth field can be read as a height, a density, or a color without tearing or flickering as it is sampled.

Three names show up almost every time the topic comes up: value noise, Perlin noise, and fractal noise. Value noise and Perlin noise are base functions that differ in what they store on a grid before interpolation. Fractal noise is a composition rule that stacks either base function across several scales. Keeping those roles apart is the main thing this page sets out to do.

You will build the picture with three interactive fields, then connect it to the controls you actually turn: seed, frequency, and octaves. The deeper mathematics and the applications live in the linked articles.

Value Noise: Random Values on a Grid

Value noise is the simplest version of the idea. Lay a grid over space and give every grid corner a random number. To read the noise between corners, blend the corner numbers according to how close the sample point sits to each corner. In one dimension that blend is

$$v(x) = (1 - t),a + t,b, \qquad t = \mathrm{fade}(x - \lfloor x \rfloor)$$

where $a$ and $b$ are the random values at the two nearest corners. The function $\mathrm{fade}$ eases the weight so the field joins smoothly where cells meet; with a plain linear blend the slope changes abruptly and you see kinks along cell boundaries. In two dimensions the same operation runs twice, first blending left and right, then blending those two results top to bottom.

The practical consequence is that no value is random in isolation. Every sample is a weighted average of the corners around it, so the field is smooth and predictable between them.

The field starts with a single octave, so it shows pure value noise. Drag anywhere on the map to move the probe: the dashed crosshair follows, and the orange curve below traces the field along the probe row, with a dot marking the value directly under the probe. Drag the frequency track and the humps crowd together, because a higher frequency packs more grid cells into the same view; drag it the other way and the field stretches into broad rolling shapes. Drag the seed track and the humps rearrange without changing their spacing, since the seed rewrites the corner numbers while the grid stays put. The rounded profile is the smooth fade at work; a kink in that curve would mean a kink in the whole field.

Value noise is easy to reason about, and that is also its limitation. The stored data sits at the corners, so each cell has its own local shape, and the field can read as rounded bumps arranged on a grid. For soft effects that is fine. For lighting, geometry, or anything inspected closely, the grid can start to show through.

Perlin Noise: Directions Instead of Values

Perlin noise keeps the grid and the smooth blend and changes only the data at the corners. A value-noise corner stores a number; a Perlin corner stores a direction. To read the field, measure how much each corner’s direction agrees with the offset from that corner to the sample point, using a dot product:

$$c_i = \mathbf{g}_i \cdot (\mathbf{p} - \mathbf{p}_i)$$

Here, $\mathbf{g}_i$ is the direction stored at corner $i$, and $\mathbf{p} - \mathbf{p}_i$ is the vector from that corner to the sample. A corner whose direction points toward the sample contributes a positive amount, and one pointing away contributes a negative amount. Blending those contributions with the same fade curve produces a smooth field whose local shape comes from the surrounding directions rather than from stored heights.

That is why Perlin noise is also called gradient noise. The name describes the stored data, not the look of the result. Ken Perlin introduced the function in An Image Synthesizer and later refined it in Improving Noise, largely to remove artifacts at the cell boundaries.

Both demos start from the same frequency, seed, and octave count, so the only difference is the stored corner data. Drag the probe across the Perlin map and compare the profile with the value-noise profile: Perlin noise trades the rounded, cell-centered bumps for elongated ridges and valleys that flow across cell boundaries, so the grid is much harder to spot. Frequency still sets the feature size, the seed still rearranges features without resizing them, and the octave track still adds detail on top.

Value Noise vs Perlin Noise

Both functions sit on the same grid, blend with the same fade curve, and respond to the same controls. The difference lives entirely in what happens before the blend.

	Value noise	Perlin noise
Stored at each corner	One random number	One direction (a gradient)
What a sample uses	The corner value itself	Dot product of the gradient and the offset
Visual character	Rounded bumps aligned with cells	Flowing ridges that cross cells
Good default for	Soft, low-frequency variation	Fields that drive shading or geometry

Value noise is often the better first field for gentle variation such as cloud density or a broad terrain base, because it is simple to implement and easy to predict. Perlin noise is the better default when the field feeds shading or geometry, since the grid is less likely to show through. Neither is a strict upgrade over the other; the right choice depends on whether you want the simplest possible blend or a more coherent local structure.

Fractal Noise: Building Detail with Octaves

A single noise field has one feature size. Real surfaces rarely do. A mountain has broad ridges, smaller gullies, and fine gravel at the same time. Fractal noise gets that range by summing several copies of a base noise, each at a higher frequency and a lower amplitude. Each copy is an octave:

$$F(p) = \sum_{i=0}^{N-1} a_i, n(f_i p)$$

Here, $n$ is the base noise, which can be value or Perlin noise, $N$ is the number of octaves, $f_i$ is the frequency of octave $i$, and $a_i$ is its amplitude. In the common setup the frequency multiplies by a constant factor from one octave to the next, and the amplitude multiplies by a constant factor below one:

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

The frequency factor $\lambda$ is called lacunarity, and the amplitude factor $g$ is called gain, though many tools expose them as unnamed sliders. The first octave carries the broad shape. Each later octave sharpens that shape at a smaller scale, and because its amplitude is smaller it refines the form instead of replacing it.

The fractal field starts with five octaves. Drag the octave track down to one and the fine layers drop away, leaving a single base field; raise it again and the large shapes stay where they were while smaller bumps gather on top of them, and the profile picks up fine wiggles. Push the octaves to the top of the range and the profile gains ever finer texture, though each added layer is half as strong as the one before, so the broad shape keeps control. Reading the tradeoff on the profile is easier than judging it in the color map.

How Octaves Stack into Detail

The octave sum is easier to read when the layers are visible separately. The ladder below puts one octave on each row, from the lowest frequency at the bottom to the highest at the top, and plots the weighted sum along the bottom track.

Drag the probe left and right and the orange line keeps the same horizontal position in every row, so you can read one location from coarse to fine. The bottom rows move slowly across the width and carry the big shape. The top rows oscillate several times and add the texture. The dark curve at the bottom is the weighted sum, which is what the finished field samples. Drag the amplitude column up or down to change gain, the rate at which each octave’s weight shrinks. Raise the gain and the fine rows start to compete with the coarse ones, turning the combined curve from structured into jittery; lower it and the fine rows fade to almost nothing, leaving a clean but plain shape. Click any row to set how many octaves contribute, with the row you click and every broader row below it staying active. The frequency ratio between rows stays fixed at two, so each row spans twice the detail of the row below.

What makes the result fractal is the rescaling and reweighting across rows, so the base row could be value noise or Perlin noise and the recipe still applies. That is the sense in which fractal noise is a composition rule rather than a base function. The layered structure also matches how natural surfaces tend to look, an idea developed for terrain, clouds, and music in Random Fractals: Self-Affinity in Noise, Music, Mountains, and Clouds.

What Seed, Frequency, and Octaves Control

The three controls in the demos all change the picture, which makes them easy to mix up. They act on different parts of the pipeline.

Seed changes the random numbers. If a corner is filled by a hash function of its integer coordinates and the seed, changing the seed rewrites every corner while leaving the grid, the blend, and the feature size untouched. Use it to get a different arrangement that is still exactly reproducible, because the same seed always returns the same field. That makes seed a tool for reproducibility and rearrangement, not for style.

Frequency rescales the input coordinates before sampling, in the simplest case $n(fx, fy)$. Raising $f$ packs more grid cells into the same span, so features get smaller and the field busier. Lowering it stretches the field into broader, calmer shapes. Frequency moves the whole pattern to a different scale; it does not add new detail.

Octaves sets how many scaled copies are summed. One octave gives a single scale, and each added octave contributes finer structure at lower strength. Octaves add detail on top of the shape you already have rather than resizing it.

Keeping the three roles separate is what lets you tune a field on purpose. If a pattern needs a different arrangement, change the seed. If it needs larger or smaller features, change the frequency. If it needs more texture without losing the overall form, add octaves.

Where Noise Functions Show Up

Noise is a signal source, and most of the time it feeds something else. In terrain, a noise field sampled at each grid point becomes a heightmap, and a meshing step turns that heightmap into ground. In clouds and smoke, the field drives density. In rendering, noise perturbs surface normals, colors, and material properties so large flat areas stop looking flat, and it can displace geometry to build rocks, bark, and water surfaces.

The same field also serves as a mask. Thresholding a noise value at some cutoff produces irregular patches, which is a quick way to scatter grass, break up a coastline, or vary a material without hand-authoring every boundary. Because the field is a function rather than a stored image, the mask stays sharp at any zoom level.

The table below maps common goals to the control that addresses them and to the article that continues the thread.

Goal	Control to reach for	Read next
Change the layout without changing feature size	Seed	The demos above
Make features wider or narrower	Frequency	The demos above
Add texture while keeping the broad shape	Octaves	The octave ladder above
Turn a noise height into ground	Frequency plus a meshing step	Heightmap to mesh
Deform an existing shape with noise	Sampled field plus displacement	Signed distance fields
Sample noise per pixel during rendering	Field cost and octave count	Ray marching
Evaluate noise on the GPU	Shader sampling and octave count	Vertex and fragment shaders

In field-based workflows the octave count matters for cost as much as for looks, because every extra octave is another sampling pass. That cost is the reason most production fields use a small number of carefully weighted octaves rather than stacking layers until the shape disappears into grain.

Summary

Value noise, Perlin noise, and fractal noise solve different problems. Value noise places random numbers on a grid and blends them, which is the clearest way to see where the structure comes from. Perlin noise keeps the grid but stores a direction at each corner, so the field gains local orientation and the grid stops showing. Fractal noise takes either one and stacks it across octaves, so a single signal carries broad form and fine detail together.

Those differences explain how the demos respond. Frequency changes the scale of the base field. Seed changes the arrangement and nothing else. Octaves add detail on top of the shape you already have. Once the three roles are separate, the math and the visuals line up, and tuning a noise field becomes a deliberate choice instead of a search.