Precision, perturbation, and why deep zooms are harder than they look
One of the first questions people ask when they see Mandelbrot Metal in action is deceptively simple:
“How is this still smooth at that depth?”
If you’ve ever tried to build a Mandelbrot renderer yourself, you already know the problem. You zoom in. Things look fine. You zoom further. Suddenly, the image breaks apart, flickers, slows to a crawl, or just turns into numerical noise.
The usual answer is “use more precision.”
The real answer is: precision alone is not enough.
This article explains why deep zoom fractals are fundamentally difficult, what actually goes wrong under the hood, and how Mandelbrot Metal stays fast and stable at depths where naïve approaches collapse.
The naïve approach: just increase precision
At a glance, the Mandelbrot iteration is simple:
So the instinctive fix for deep zoom problems is straightforward:
- Switch from single precision to double
- Switch from double to extended precision (e.g., double-double precision)
- Maybe even use arbitrary precision everywhere
Unfortunately, this doesn’t scale.
As you zoom deeper, two things happen simultaneously:
- Coordinates become extremely small
- Iterates become extremely sensitive to rounding error
Even at moderate depths, catastrophic cancellation dominates the computation. Two large values subtract to produce a tiny result, and most of the meaningful bits simply vanish. You’re left with mathematically valid numbers that no longer describe the orbit you think they do.
Worse still, GPUs are optimized for throughput rather than high-precision arithmetic. Asking a GPU to do arbitrary-precision math everywhere is like asking a race car to tow a freight train.
Why GPUs struggle with deep zooms
Modern GPUs are extraordinarily fast — but only when the math fits their model.
They excel at:
- Massive parallelism
- Predictable control flow
- Fixed-precision arithmetic
They struggle with:
- Long dependency chains
- Arbitrary precision
- Branch-heavy numerical correction
A naïve deep-zoom renderer pushes GPUs into their weakest regime: lots of expensive math, little coherence, and increasing numerical instability.
So if the GPU can’t do everything, and the CPU is too slow to do everything, what’s the solution?
Precision is not a number — it’s a system
This is the key idea behind Mandelbrot Metal:
Precision is not a toggle. It’s an architecture.
Instead of trying to compute every pixel independently at extreme precision, Mandelbrot Metal splits the problem into stable and unstable parts.
The trick is to recognize something subtle but powerful:
Nearby pixels follow nearly identical orbits — until they don’t.
That observation opens the door to perturbation rendering.
Perturbation theory: one expensive orbit, many cheap ones
Rather than computing every orbit from scratch, Mandelbrot Metal does the following:
1. Compute one high-precision reference orbit
- Using extended precision on the CPU
- Carefully tracked and numerically stable
2. Compute nearby pixels as small perturbations
- Using fast, low-precision math on the GPU
- Tracking deviations from the reference orbit
Mathematically, this works because the Mandelbrot iteration is locally smooth. As long as nearby points remain close to the reference orbit, their behavior can be computed as a small delta rather than recomputed from scratch.
When a pixel’s perturbation grows too large, Mandelbrot Metal:
- Detects the breakdown
- Re-anchors the reference orbit
- Continues seamlessly
This hybrid approach gives you the best of both worlds:
- Stability of high precision
- Speed of massively parallel GPU execution
Why does this scale so well?
The performance win isn’t incremental — it’s exponential.
Without perturbation:
- Cost per pixel increases with depth
- Frame rate collapses rapidly
With perturbation:
- Cost per pixel stays almost constant
- Deeper zooms barely change performance
Most frames reuse the same reference orbit. Most pixels stay well within the perturbation regime. The GPU does what it’s good at, and the CPU only steps in when absolutely necessary.
Determinism matters more than you think
One subtle but crucial design goal of Mandelbrot Metal is determinism.
Given the same bookmark:
- You get the same image
- With the same color mapping
- At the same resolution
- Every time
This is not a given in GPU-heavy systems. Floating-point nondeterminism, thread scheduling, and precision shortcuts can all introduce subtle visual differences between runs.
For artists, educators, and print workflows, that’s unacceptable.
Mandelbrot Metal deliberately constrains the pipeline so that:
- Precision transitions are controlled
- Perturbation thresholds are explicit
- Numerical drift is never allowed to accumulate silently
This makes deep zooms not just fast — but trustworthy.
Why this matters for artists, not just engineers
All of this math exists for one reason: creative freedom.
When the engine is stable:
- You can explore without fear of artifacts
- You can zoom deeper without performance anxiety
- You can trust that what you see is the real structure and not numerical noise
Fast feedback loops change how people explore fractals. Instead of cautiously stepping inward, you can flow — following structures as they reveal themselves.
That’s when the Mandelbrot set stops being a formula and starts becoming a landscape.
Final thought
Deep zoom fractals are hard, not because the math is so complicated.
They’re hard because numerical truth is fragile.
Mandelbrot Metal stays fast at extreme depths not by brute force, but by respecting that fragility — and designing an engine that works with the mathematics instead of fighting it.
Fractal of the Week:
"Purple'ish Cardioid 3D" — created in Mandelbrot Metal."
A highly detailed cardioid with bulbs at medium-deep zoom with a 3D lighting effect.
Center: x=-0.207791 y=0.829482i Scale: 723,442,040x (7.234e8x) Iterations: 5,100 Contrast: 2.59 Quality: SSAA×4 • 3D Palette: Macaw [UW] Color: P3 • LUT 1,024
👉 Get downloadable bookmarks you can import into Mandelbrot Metal on the Community Portal.