The Mandelbrot Formula Doesn’t Make the Image

From escape time to palettes, lighting, HDR, and export — how Mandelbrot Metal turns raw math into finished fractal images

This article was originally published in Medium

Most people think a Mandelbrot renderer “draws the Mandelbrot set.”

It doesn’t — at least not directly.

The famous formula is simple:

zₙ₊₁ = zₙ² + c

For each point c in the complex plane, the renderer repeatedly applies that formula and watches what happens. Does the orbit stay bounded? Does it escape? If it escapes, how quickly?

That process gives us data.

But it does not give us an image.

A finished fractal image requires a second layer of engineering: turning numerical escape behavior into smooth color, visual structure, lighting, and exportable pixels. That part is often treated as an implementation detail, but in practice, it is where much of the visual identity of a fractal renderer is created.

In Mandelbrot Metal, the rendering pipeline is not just about evaluating the Mandelbrot equation quickly. It is about transforming raw mathematical behavior into a stable, reproducible, high-resolution visual result.

The formula defines the world.

The rendering pipeline decides what we can see inside it.

1. The equation only answers one question

At the core of the Mandelbrot set is a deceptively simple test.

For each point c, start with:

z = 0

Then repeatedly compute:

z = z² + c

If the value of z grows beyond a chosen bailout radius, the point is considered to have escaped. If it does not escape within the selected maximum number of iterations, the renderer treats it as inside, or at least not proven to be outside at that iteration depth.

In very simplified terms, each pixel asks:

Where am I in the complex plane?
How many iterations did I survive?
Did I escape?

A basic Mandelbrot renderer can assign a color based directly on that escape iteration count.

For example:

escaped at 20 iterations  → blue
escaped at 80 iterations  → orange
escaped at 300 iterations → white
did not escape            → black

That is enough to produce a recognizable Mandelbrot image.

But it is not enough to produce a good one.

2. Raw iteration counts create bands

If color is mapped directly from integer iteration counts, the result is usually banded.

Every point that escapes at iteration 50 receives one color. Every point that escapes at iteration 51 receives another. The image becomes a set of discrete contour bands.

Sometimes that banded look is useful. It reveals the iteration structure clearly. It can be educational. It can even be aesthetically interesting.

But it is also a very coarse representation of what is really happening.

Two neighboring pixels may both escape at iteration 312, but one may have barely crossed the bailout threshold while the other may have accelerated far beyond it. A simple integer iteration count treats them as identical.

That throws away information.

For smooth rendering, the goal is not merely to know the iteration number where escape occurred. The goal is to estimate a continuous escape value — a smoother signal that captures more of the behavior of the orbit.

That distinction is one of the first places where a fractal renderer stops being just a mathematical loop and starts becoming an image pipeline.

3. Smooth coloring turns escape into a continuous signal

A smoother Mandelbrot image usually comes from computing a fractional escape value rather than using the integer iteration count alone.

Instead of saying:

This point escaped at iteration 312.

…the renderer tries to express something closer to:

This point escaped at approximately 312.47.

That fractional part matters. It lets color transition smoothly from one region to the next instead of jumping abruptly at integer boundaries.

The exact formula varies by renderer, but the idea is the same: use the magnitude of the final escaped value to estimate how far between iteration bands the point really belongs.

The result is a scalar value — a continuous measurement derived from the escape behavior.

That scalar is not yet a color. It is more like a signal.

The renderer still has to decide how that signal should become visible.

4. Palettes are not decoration

In fractal rendering, a palette is often described as “color.”

That is true, but incomplete.

A palette is not just paint applied after the image is computed. It is a transfer function. It maps mathematical structure to visible contrast.

The same Mandelbrot location can look flat, dramatic, delicate, metallic, atmospheric, or chaotic depending on how the escape signal is mapped into color.

A palette decides:

Which regions separate clearly?
Which gradients feel smooth?
Which structures are emphasized?
Which details disappear?
Where does the eye go first?

That makes palette design part of the renderer’s expressive and technical behavior.

In Mandelbrot Metal, palettes are not treated as arbitrary afterthoughts. They are part of the rendering system. The app uses palette lookup tables so that color mapping can be fast, stable, and repeatable.

The important point is this:

A Mandelbrot image is not only the result of the equation.

It is the result of the equation plus the color transfer function applied to its escape behavior.

Change the palette, and you change what the image reveals.

5. The LUT path: fast, stable, reproducible color

A lookup table, or LUT, is a compact way to turn a normalized value into a color.

At render time, the pipeline can be thought of like this:

escape metric → normalized scalar → palette lookup → pixel color

Instead of recalculating complex gradient logic independently for every pixel, the renderer samples from a prepared palette table. That makes color mapping efficient and consistent.

This matters for performance, but it also matters for determinism.

If a user saves a bookmark, returns to the same coordinates, uses the same palette, and applies the same rendering settings, the image should come back the same way. For a fractal explorer, reproducibility is not a luxury feature. It is fundamental.

Bookmarks only make sense if the renderer can return to the same visual state.

High-resolution export only makes sense if the export path preserves the intended image.

Palette editing only makes sense if the result is stable and predictable.

That is why the color path is not merely a UI feature. It is part of the engine.

6. Lighting is another transformation of the data

Mandelbrot images are mathematically two-dimensional, but they often contain structures that feel almost geological: ridges, valleys, filaments, islands, spirals, and shelves of detail.

A renderer can use the escape data to infer local structure and apply lighting-like effects. This is the basis for a “3D Look” style.

That does not mean the Mandelbrot set has become a physical 3D object. It means the renderer is deriving a surface-like impression from the underlying data.

Conceptually:

escape behavior → local variation → inferred normal → lighting model

The result can add depth cues: highlights, shadows, specular accents, and a stronger sense of relief.

This is another example of the larger theme. The formula alone does not produce the finished image. The renderer interprets the formula’s output through additional stages.

Flat color and shaded color may come from the same coordinates and the same iteration data, but they communicate the structure differently.

That difference is part mathematics, part graphics engineering, and part visual design.

7. HDR, Display-P3, and export are part of the pipeline, too

It is tempting to think the renderer’s job ends once every pixel has a color.

It does not.

A modern graphics pipeline still has to consider the display and export path.

On Apple hardware, this can include wide color, HDR-aware presentation, and high-resolution image generation. These details matter because the image a user sees on screen should relate predictably to the image they export.

A simplified final pipeline looks like this:

computed color → color space handling → display presentation → image export

For casual rendering, this may sound like a small detail. For serious visual work, it is not.

Fractal images often depend on subtle gradients. Small color shifts can change the mood of the image. Banding can ruin a sky-like transition. Poor export handling can flatten the result.

The math may be exact, but the final image still depends on the quality of the color and output pipeline.

8. Deep zoom makes the pipeline more demanding

At ordinary zoom levels, many renderers can produce attractive Mandelbrot images.

Extreme zoom changes the problem.

As magnification increases, numerical precision becomes more difficult. Small differences in coordinates matter. Iteration counts rise. Performance becomes more fragile. The renderer may need different precision strategies, different compute paths, and more careful scheduling.

But the image pipeline still has to hold together.

The palette should remain stable.

The smoothing should remain coherent.

The lighting should still derive from meaningful data.

The export path should not diverge from the interactive view.

This is one of the reasons Mandelbrot rendering is such an interesting engineering problem. It is not one problem. It is a stack of problems:

1. numerical precision
2. iteration performance
3. parallel computation
4. palette mapping
5. visual smoothing
6. lighting
7. display
8. export
9. reproducibility

A weakness in any one layer can show up in the final image.

9. Determinism runs through the whole system

One of the most important requirements in Mandelbrot Metal is that views are reproducible.

If a user finds a location, saves it, returns to it, changes palettes, exports it, or shares it, the renderer should behave predictably.

That requires deterministic thinking throughout the pipeline.

• Coordinates matter.
• Precision mode matters.
• Iteration settings matter.
• Palette state matters.
• Lighting settings matter.
• Export resolution matters.

A Mandelbrot bookmark is more than a camera position. It is a rendering recipe.

The same mathematical location can produce different visual results if the rendering parameters change. That is not a problem — it is part of the creative power of fractal rendering — but it means the app has to treat those parameters seriously.

A reproducible fractal renderer is not just saving where you were.

It is saving how the image was made.

10. The full rendering pipeline

A useful way to think about my app, Mandelbrot Metal, is as a pipeline:

complex coordinates
        ↓
precision path
        ↓
Mandelbrot iteration
        ↓
escape data
        ↓
smooth escape metric
        ↓
palette lookup
        ↓
lighting / 3D Look
        ↓
display color
        ↓
high-resolution export

Each stage transforms the result of the previous one.

The equation is essential, but it is not the whole renderer.

The iteration loop produces escape behavior.

The smoothing stage turns that behavior into a continuous signal.

The palette maps that signal into color.

The lighting stage extracts visual depth.

The display and export path turn the result into an image the user can view, save, and share.

That is where the finished fractal comes from.

Not from the formula alone, but from the entire chain of interpretation.

Learn more about Mandelbrot Metal’s rendering pipeline.

Conclusion: the formula defines the world

The Mandelbrot equation is one of the most compact definitions of infinite visual complexity ever discovered.

But a beautiful Mandelbrot image is not produced by the equation alone.

It takes numerical precision, parallel computation, smoothing, palette design, lighting, color management, and export logic to turn that equation into a finished image.

That is the hidden work of a fractal renderer.

The formula defines the world.

The rendering pipeline decides what we can see inside it.

Until next time,

Michael