User Rating 0.0 ★★★★★

Total Usage 0 times

Category Graphic Generators

Presets

Noise Type Seed

Scale 80 Octaves 6 Lacunarity 2.0 Persistence 0.5

Position X Offset 0 Y Offset 0

Adjustments Contrast 1.0 Brightness 0.0

Canvas Width 800 px Height 600 px

Color Palette

Adjust parameters and press Generate

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Perlin noise, introduced by Ken Perlin in 1985 and refined in 2002, produces coherent gradient noise that avoids the visual artifacts of white noise. This generator implements the improved algorithm with a permutation table of 256 entries and the smoothstep fade function f(t) = 6t⁵ − 15t⁴ + 10t³. Fractal Brownian motion (fBm) layers multiple octaves of noise at increasing frequency and decreasing amplitude, controlled by lacunarity and persistence. Misconfigured parameters produce mud: too many octaves with high persistence saturate contrast, while low scale values collapse detail into uniform color. The tool maps noise output through curated color gradients. Results depend on the interaction between seed, scale, and octave count. This approximation assumes 2D sampling on a regular grid and does not account for tiling or seamless wrapping.

Formulas

The improved Perlin noise function evaluates gradient noise at point (x, y) using the quintic fade curve and bilinear interpolation of gradient dot products:

fade(t) = 6t⁵ − 15t⁴ + 10t³

Fractal Brownian motion sums n octaves with frequency doubling and amplitude decay:

fBm(x, y) = n−1∑i=0 pⁱ ⋅ noise(x ⋅ Lⁱ, y ⋅ Lⁱ)

For ridged noise, the absolute value is inverted to create sharp crease lines:

ridged(v) = 1 − |v|

For turbulence, the absolute value produces billowing cloud forms:

turb(v) = |v|

The final noise value is normalized to [0, 1], then contrast and brightness are applied:

v_out = clamp((v − 0.5) ⋅ C + 0.5 + B, 0, 1)

Where p = persistence, L = lacunarity, n = octave count, C = contrast multiplier, B = brightness offset. The output v_out indexes into the selected color palette gradient for final pixel color.

Reference Data

Parameter	Range	Default	Effect
Scale	1 - 500	80	Zoom level of noise pattern. Lower values produce tighter, more detailed features.
Octaves	1 - 10	6	Number of layered noise passes. Each adds finer detail at cost of computation.
Lacunarity	1.0 - 4.0	2.0	Frequency multiplier per octave. Higher values increase detail separation.
Persistence	0.1 - 1.0	0.5	Amplitude multiplier per octave. Higher values retain more fine detail contrast.
Seed	0 - 65535	Random	Initializes permutation table shuffle. Same seed reproduces identical output.
X Offset	−1000 - 1000	0	Horizontal translation across the noise field.
Y Offset	−1000 - 1000	0	Vertical translation across the noise field.
Width	256 - 2048 px	800	Output canvas width in pixels.
Height	256 - 2048 px	600	Output canvas height in pixels.
Contrast	0.5 - 3.0	1.0	Post-processing contrast multiplier applied before color mapping.
Brightness	−0.5 - 0.5	0.0	Post-processing brightness offset added before color mapping.
Noise Type	Standard, Ridged, Turbulence	Standard	Standard uses raw fBm. Ridged inverts absolute value for sharp creases. Turbulence uses absolute value for cloud-like forms.
Gradient Stops	2 - 6	Palette-dependent	Number of color anchors in the mapping gradient.
Total Pixels	65,536 - 4,194,304	480,000	Width × Height. Computation time scales linearly with pixel count.
fBm Amplitude Sum	Varies	-	Normalization divisor: 1 − pⁿ1 − p where p is persistence and n is octaves.

Frequently Asked Questions

The seed only controls the permutation table shuffle, which determines the gradient vectors at integer lattice points. Changing octaves alters how many noise layers are summed, and changing scale modifies the sampling coordinates fed into the noise function. The seed guarantees reproducibility only when all parameters are identical. Think of the seed as fixing the terrain, while scale and octaves control your camera zoom and detail level.

Standard fBm returns the raw summed noise, producing smooth flowing gradients. Turbulence takes the absolute value of each octave before summing, creating billowing cloud-like or marble textures with visible folds. Ridged noise inverts the absolute value (1 − |v|), which concentrates contrast along sharp crease lines resembling mountain ridges or vein networks. Ridged noise typically benefits from lower persistence values around 0.3-0.4 to avoid saturation.

Lacunarity controls how quickly frequency increases per octave. At lacunarity = 2.0, each octave doubles in frequency. Higher values like 3.0 create more separated detail layers. Persistence controls how much amplitude each successive octave retains. At persistence = 0.5, each octave has half the influence of the previous. High persistence (> 0.7) with many octaves produces noisy, grainy output because fine detail overwhelms the base pattern. The product of these two parameters determines the noise character: low lacunarity + high persistence = soft, flowing; high lacunarity + low persistence = crisp base with subtle texture.

The algorithm evaluates the noise function independently for every pixel. At 2048×2048 resolution, that is 4,194,304 noise evaluations, each requiring multiple octaves of gradient computation and interpolation. With 8 octaves, that becomes over 33 million gradient lookups. The generator uses a Web Worker to avoid blocking the UI thread. On typical hardware, expect 1-3 seconds at maximum resolution. Reducing octaves to 4 roughly halves computation time.

This implementation samples a 2D plane without wrapping. The edges will not tile seamlessly. Seamless tiling requires sampling noise on the surface of a higher-dimensional torus (mapping 2D coordinates through 4D noise). This tool focuses on single-canvas abstract art rather than tileable texture production. For tileable output, you would need to modify the sampling coordinates to wrap through a 4D noise space.

The normalized noise value v ∈ [0, 1] is mapped through a piecewise linear gradient defined by color stops. If a palette has stops at positions 0.0, 0.33, 0.66, and 1.0 with corresponding RGB colors, the algorithm finds which two stops bracket v, computes the local interpolation factor t = (v − stop_low) / (stop_high − stop_low), and linearly interpolates each RGB channel: channel_out = channel_low × (1 − t) + channel_high × t. This produces smooth color transitions without banding.

Contrast values above 2.0 expand the value range beyond [0, 1], which gets clamped. This means mid-range noise values spread further apart, but extremes saturate to pure black or white in the palette. At contrast = 3.0, any noise value below approximately 0.33 or above 0.67 clips to the palette endpoints. This can produce dramatic high-contrast art but destroys subtle gradient transitions in the highlights and shadows.