# Fractals in Computer Graphics & Procedural Generation

> From Loren Carpenter's standing-ovation terrain film to the landscapes of modern open-world games, fractal mathematics has quietly been the engine beneath the surface of computer-generated reality.

*Published 2026-06-25 · Updated 2026-06-25 · By Dr. Elena Marchetti*

Key Takeaway: Fractal geometry is not decorative mathematics in computer graphics — it is load-bearing infrastructure. Every photorealistic mountain, every seamless game terrain, and every compressed texture you have ever seen on a screen owes a structural debt to Benoit Mandelbrot's insight that nature is built from self-similar, scale-invariant patterns.

## How Are Fractals Used in Computer Graphics?

Fractals enter computer graphics through a deceptively simple observation: nature is self-similar. A mountain range, photographed from 10,000 metres or from 10 metres, shows the same statistical texture of peaks, ridges, and valleys. A coastline measured with a kilometre ruler and with a centimetre ruler reveals the same jagged, recursive detail. This property — **statistical self-similarity across scales** — is the mathematical signature of a fractal, and it turns out to be exactly what a renderer needs to synthesize convincing natural surfaces.

Classical Euclidean geometry, with its smooth spheres, planes, and cones, fails catastrophically at describing natural irregularity. You can build a perfect pyramid in a CAD package, but you cannot build a convincing mountain without fractal mathematics. The gap between Euclidean shapes and natural ones was first rigorously quantified by [Benoit Mandelbrot](https://en.wikipedia.org/wiki/Benoit_Mandelbrot) in his 1967 paper *"How Long Is the Coast of Britain?"* and expanded into a full geometric theory in his 1982 masterwork [The Fractal Geometry of Nature](https://www.amazon.com/dp/0716711869). Within two years of that book's publication, its central ideas were already being applied in Hollywood.

Today, fractal mathematics underlies at least four major domains of computer graphics: **terrain and landscape generation**, **procedural noise and texture synthesis**, **fractal image compression**, and **real-time rendering in video games**. Each deserves careful examination.

## What Was the First Fractal Landscape in Film?

The answer is definitive: **Loren Carpenter's *Vol Libre***, premiered at [SIGGRAPH](https://en.wikipedia.org/wiki/SIGGRAPH) on 14 July 1980. The two-minute computer-generated short film depicted a fly-through over a photorealistic mountain range — and the audience gave it a standing ovation.

Carpenter had been working at Boeing when he began experimenting with **recursive midpoint displacement** — a fractal algorithm that takes a triangle, finds the midpoint of each edge, perturbs those midpoints randomly by a decreasing amount, then recursively subdivides the resulting smaller triangles. Repeated enough times, flat geometry blooms into terrain indistinguishable from aerial photography. The key mathematical insight is that the random perturbation is scaled by a factor controlled by the **Hurst exponent** (typically 0.5–0.8): higher values produce smooth rolling hills; lower values yield jagged, alpine crags. This scaling is what gives the result its fractal character — the same statistical texture appears at every level of subdivision.

The standing ovation at SIGGRAPH earned Carpenter an immediate invitation to join Lucasfilm's nascent Computer Division. Two years later, that team produced the **Genesis Effect sequence in *Star Trek II: The Wrath of Khan* (1982)** — the first use of a fractal-generated landscape in a theatrical release. The sequence, depicting a dead planet transformed into a living world in real time, used [fractional Brownian motion](https://en.wikipedia.org/wiki/Fractal_landscape) to simulate mountainous terrain during the fly-through. It was so visually spectacular that it was reprised in the next three *Star Trek* films.

The formal algorithmic foundation for this work was codified in the landmark 1982 paper by **Alain Fournier, Don Fussell, and Loren Carpenter**, ["Computer Rendering of Stochastic Models"](https://dl.acm.org/doi/10.1145/800064.801296), published in *Communications of the ACM*. This paper introduced the midpoint displacement method and its fractal properties to the graphics research community, and every terrain generation algorithm in use today traces its lineage to this work.

  Milestone Timeline: Fractals in Computer Graphics

      Year
      Event
      Significance

      1967
      Mandelbrot's coastline paper
      First rigorous quantification of fractal dimension in natural geometry

      1980
      Loren Carpenter, Vol Libre (SIGGRAPH)
      First fractal terrain film; standing ovation; Carpenter joins Lucasfilm

      1982
      Fournier, Fussell & Carpenter paper; Genesis Effect, Star Trek II
      First theatrical fractal landscape; midpoint displacement formalized

      1985
      Ken Perlin, "An Image Synthesizer" (SIGGRAPH)
      Perlin noise introduced; Academy Award for Technical Achievement, 1997

      1987–1992
      Barnsley & Jacquin, fractal image compression (IFS/PIFS)
      Lossless-quality compression via iterated function systems

      2001–present
      Procedural engines in AAA games (Minecraft, No Man's Sky, etc.)
      Real-time fractal terrain at planetary scale becomes mainstream

## What Is Perlin Noise and Why Is It Fractal?

Two years after Fournier, Fussell, and Carpenter's paper, Ken Perlin was working on Disney's *Tron* (1982) and found himself frustrated by the synthetic, inhuman look of computer-generated surfaces. The problem was that standard random noise — a uniform, memoryless process — produces textures that look like television static: spatially uncorrelated and utterly unlike anything in the natural world. What Perlin needed was noise with *spatial coherence*: smooth at close range, varied at longer range, and statistically self-similar across scales.

The algorithm he developed, presented in his 1985 SIGGRAPH paper ["An Image Synthesizer"](https://dl.acm.org/doi/10.1145/325334.325247), assigns a pseudo-random **gradient vector** to each point on an integer lattice, then smoothly interpolates between adjacent gradients. The result is a continuous, band-limited noise function — smooth over short distances, varied over longer ones — with a single characteristic scale. On its own, this is not yet fractal. The fractal magic comes from **layering**.

When multiple octaves of Perlin noise are summed — each at double the frequency and half the amplitude of the previous — the result is **Fractional Brownian Motion (fBm)**, a fractal process first analyzed by [Mandelbrot and van Ness in 1968](https://en.wikipedia.org/wiki/Benoit_Mandelbrot). The power spectrum of fBm follows a **1/fβ** power law, the hallmark of scale-invariant, fractal behavior. In graphical terms: low-frequency octaves establish continental outlines and mountain ranges; mid-frequency octaves carve valleys and ridges; high-frequency octaves stipple the surface with rocks and pebbles. Each octave contributes detail at its own scale — exactly as fractal geometry predicts.

The practical consequence was transformative. Cloud shaders, marble textures, fire simulations, ocean surfaces, procedural stone walls — all of these can be produced by summing fBm-weighted Perlin noise. In 1997, the Academy of Motion Picture Arts and Sciences awarded Perlin a **Technical Achievement Award** in recognition of the algorithm's impact on visual effects. Modern variants — [Simplex noise](https://en.wikipedia.org/wiki/Simplex_noise) (Perlin, 2001) and **Worley/cellular noise** — extend the approach while preserving the fractal, self-similar character that makes it so natural-looking.

## How Does Fractal Image Compression Work?

In 1988, mathematician [Michael Barnsley](https://www.ams.org/notices/199606/barnsley.pdf) at the Georgia Institute of Technology — already famous for introducing the [Barnsley fern](https://fractal.us/mathematics/fractal-geometry) via iterated function systems — realized that the same IFS framework that generates fractals might be used in reverse: given a natural image, find the IFS whose attractor approximates that image. Compress the image to its IFS description; decompress by iterating the IFS from any starting point until convergence.

Barnsley's doctoral student **Arnaud Jacquin** made this computationally tractable in his 1992 landmark paper ["Image Coding Based on a Fractal Theory of Iterated Contractive Image Transformations"](https://ieeexplore.ieee.org/document/119698) in *IEEE Transactions on Image Processing*. Jacquin's key innovation was **Partitioned Iterated Function Systems (PIFS)**: rather than searching for a single IFS for the entire image (computationally intractable), partition the image into small non-overlapping *range blocks* and find, for each block, a larger *domain block* elsewhere in the image that, under a contraction mapping, approximates it. The compressed file stores only the contraction parameters — a compact mathematical description from which the decompressor reconstructs the image by iterating until convergence, regardless of what starting image it uses.

Fractal compression has two remarkable properties. First, it is **resolution-independent**: because the image is stored as an IFS, it can be decompressed at any resolution — zoom in and the algorithm *generates* new detail consistent with the fractal structure rather than blurring pixels. Second, it is **asymmetric in cost**: compression is slow (searching for matching domain blocks across the entire image), but decompression is fast (simply iterating the stored IFS). This made it attractive for CD-ROM encyclopaedia publishing in the 1990s, where content was compressed once and decompressed millions of times. Microsoft Encarta used fractal-compressed images at a time when storage was precious.

Modern codecs — JPEG 2000 (wavelet-based) and AV1 — have largely supplanted fractal compression for general photography, but the technique remains active in specialized applications including [satellite imagery compression](https://arxiv.org/pdf/1206.4880) and super-resolution upscaling, where its resolution-independence is genuinely irreplaceable.

## How Are Fractals Used in Video Game Terrain Generation?

The same midpoint displacement and fBm algorithms that Carpenter and Perlin developed for film have become the backbone of open-world game development. The challenge is substantial: generating worlds of continental scale — sometimes literally planetary scale — in real time, on consumer hardware, without visible repetition or seams.

The canonical algorithm for real-time fractal terrain is the [diamond-square algorithm](https://en.wikipedia.org/wiki/Diamond-square_algorithm), introduced by Fournier, Fussell, and Carpenter in 1982 and refined by Gavin Miller at SIGGRAPH 1986. It operates on a square grid of side 2n+1: the four corners are seeded with heights, then alternating *diamond* and *square* passes compute midpoints as the average of their neighbors plus a scaled random perturbation — with the perturbation halving at each iteration to preserve fractal scaling. The result is a heightmap whose statistical character matches natural terrain across all spatial scales.

Modern implementations layer several fractal techniques simultaneously:

  - **fBm for macro-scale topology** — continental plate positions, mountain ranges, oceanic trenches — using low-frequency octaves of Perlin or Simplex noise.

  - **Domain-warped fBm for geological realism** — the input coordinates themselves are displaced by a second fBm function before sampling the first, producing twisted, eroded-looking terrain rather than uniform mathematically-regular ridges. This technique, popularized by graphics researcher [Íñigo Quílez](https://iquilezles.org/articles/warp/), reproduces the visual signature of real erosion with minimal additional computation.

  - **Voronoi noise for geological features** — cellular noise (Worley, 1996) produces the cracked-earth and cobblestone patterns characteristic of dried lakebeds, basalt columns, and skin texture.

  - **Hydraulic erosion simulation** — after fractal terrain is generated, a brief particle-based erosion simulation carves river valleys and talus slopes, bringing the result closer to geologically plausible landscapes.

*Minecraft* (2011) is the most-played demonstration of fractal terrain in history: its world is 64 million square kilometres — larger than Earth's land surface — generated on demand from a seed value via layered Perlin noise. [No Man's Sky](https://www.nomanssky.com/) (Hello Games, 2016) extends this to **18 quintillion procedurally generated planets**, each with unique terrain, atmosphere, and biomes, all produced from deterministic fractal algorithms that run in real time on a consumer GPU. Neither game stores terrain geometry; it is computed from mathematical rules the instant the player looks at it — the definition of procedural generation, and fractal mathematics in practice at scale.

For a deeper look at the mathematics of self-similarity that underlies all of these techniques, see our explainer on [fractal geometry](https://fractal.us/mathematics/fractal-geometry) and the overview of [real-world fractal applications](https://fractal.us/science/fractal-applications).

## What Other Graphics Techniques Use Fractal Geometry?

Terrain and noise are the most visible applications, but fractal geometry runs through computer graphics far more broadly:

**L-Systems for botanical simulation.** [Lindenmayer systems](https://en.wikipedia.org/wiki/L-system), invented by biologist Aristid Lindenmayer in 1968 and given graphical form in Prusinkiewicz and Lindenmayer's *The Algorithmic Beauty of Plants* (1990), generate fractal plant geometry through string-rewriting rules. Every tree, bush, and fern in a modern game or film rendering is produced by some variant of an L-system — a fractal description compact enough to store in a few kilobytes yet capable of producing billions of branches.

**Fractal antennas in mobile devices.** The same fractal self-similarity that generates terrain also enables compact, multi-band antennas. [Koch curve and Sierpiński gasket antenna geometries](https://en.wikipedia.org/wiki/Fractal_antenna) can resonate at multiple frequencies simultaneously, allowing a single antenna — smaller than its Euclidean equivalent — to handle 4G, 5G, Wi-Fi, and Bluetooth. Every modern smartphone contains a fractal antenna, though the marketing materials rarely say so.

**Level-of-detail (LOD) rendering.** Fractal geometry provides a principled framework for LOD: because the statistical character of terrain is scale-invariant, a coarse-resolution mesh can be refined by adding fractal detail at finer scales without requiring manual artistic work. This is the foundation of techniques like [geometry clipmaps](https://en.wikipedia.org/wiki/Geometry_clipmaps) and the adaptive mesh refinement used in flight simulators and GIS visualization tools.

**Ray-marched fractal rendering.** Modern GPUs are fast enough to render mathematical fractals directly — without polygons — by [ray marching through signed distance functions](https://iquilezles.org/articles/distfunctions/). Objects like the [Mandelbulb](https://fractal.us/famous-fractals/3d-fractals-mandelbulb) (a 3D generalization of the Mandelbrot set, first described by Daniel White and Paul Nylander in 2009) and the **Menger sponge** are impossible to represent as polygon meshes — their self-similar detail is infinite — but can be rendered exactly by evaluating their distance-field equations at each pixel. Demo-scene programmers routinely encode entire worlds of fractal geometry in under 4 kilobytes of code.

## Sources

1. [https://en.wikipedia.org/wiki/Loren_Carpenter](https://en.wikipedia.org/wiki/Loren_Carpenter)
2. [https://en.wikipedia.org/wiki/Fractal_landscape](https://en.wikipedia.org/wiki/Fractal_landscape)
3. [https://en.wikipedia.org/wiki/Diamond-square_algorithm](https://en.wikipedia.org/wiki/Diamond-square_algorithm)
4. [https://dl.acm.org/doi/10.1145/800064.801296](https://dl.acm.org/doi/10.1145/800064.801296)
5. [https://en.wikipedia.org/wiki/Perlin_noise](https://en.wikipedia.org/wiki/Perlin_noise)
6. [https://dl.acm.org/doi/10.1145/325334.325247](https://dl.acm.org/doi/10.1145/325334.325247)
7. [https://en.wikipedia.org/wiki/Fractal_compression](https://en.wikipedia.org/wiki/Fractal_compression)
8. [https://www.ams.org/notices/199606/barnsley.pdf](https://www.ams.org/notices/199606/barnsley.pdf)
9. [https://ieeexplore.ieee.org/document/119698](https://ieeexplore.ieee.org/document/119698)
10. [https://en.wikipedia.org/wiki/L-system](https://en.wikipedia.org/wiki/L-system)
11. [https://en.wikipedia.org/wiki/Fractal_antenna](https://en.wikipedia.org/wiki/Fractal_antenna)
12. [https://iquilezles.org/articles/warp/](https://iquilezles.org/articles/warp/)
13. [https://mathworld.wolfram.com/Fractal.html](https://mathworld.wolfram.com/Fractal.html)
14. [https://www.amazon.com/dp/0716711869](https://www.amazon.com/dp/0716711869)
15. [https://en.wikipedia.org/wiki/Mandelbrot_set](https://en.wikipedia.org/wiki/Mandelbrot_set)
16. [https://homes.cs.washington.edu/~lazowska/impact/carpenter.html](https://homes.cs.washington.edu/~lazowska/impact/carpenter.html)
17. [https://en.wikipedia.org/wiki/Simplex_noise](https://en.wikipedia.org/wiki/Simplex_noise)
18. [https://arxiv.org/pdf/1206.4880](https://arxiv.org/pdf/1206.4880)
19. [https://algorithmicbotany.org/papers/#abop](https://algorithmicbotany.org/papers/#abop)

---
Source: https://fractal.us/science/fractals-in-computer-graphics
Index: https://fractal.us/llms.txt · Full text: https://fractal.us/llms-full.txt