You can't handle the Buddhabrot!

Exploring the little-known sibling of the world's most famous fractal.

In today’s episode, let’s talk about fractals, floating point numbers, and why that one guy on Wikipedia is wrong.

First things first: if you’re unfamiliar with the term, fractals are a loosely-defined class of geometric shapes with a complex, endlessly-repeating structure that’s visible no matter how much you zoom in. A rudimentary example is the Koch curve, which can be constructed by repeatedly dividing every straight line into three equal parts, and then adding a fourth segment to form a “spike”. Keep doing this forever and presto — a fractal:

The beginnings of a Koch curve. Infinitely more steps to go.

In addition to being constructed on purpose, fractal patterns keep showing up in the solutions to a number of useful functions, usually near where the function is exhibiting high rates of separation — that is, rapid divergence of results in response to infinitesimal differences in input values. The study of such systems is of considerable scientific interest: they are deterministic yet hard to predict if you don’t have a perfect knowledge of the system’s state. They are a boon to cryptographers and the bane of weather forecasts.

As for the fractals themselves, they come with some interesting theoretical underpinnings too — but for the most part, they function as visual curiosities. The most famous example is the Mandelbrot set, named after Benoit Mandelbrot and first portrayed on this printout from 1978:

An early sighting of the Mandelbrot fractal.

The core construct of the Mandelbrot set is the following iterated formula:

\(z_{n+1} = z_n^2 + c\)

Both variables — z and c — are complex numbers. The value of c corresponds to pixel coordinates; for the purpose of the computation, they’re usually scaled to -2 … 1.5 in the horizontal direction and -1.5 … 1.5 vertically. The value of z₀ is initialized to zero.

Complex numbers are a bit icky, but they’re just a trick to combine two Cartesian coordinates — (x, y) — into a single number. It’s akin to inventing a magic value of 🐱, which is not a number, with the rule that any🐱-attached terms in an expression can’t be commingled with the catless stuff:

\((1 + 2🐱) + (3 + 10🐱) = 4 + 12🐱\)

The catless stuff is called the real part. The cat domain is called the imaginary part.

We can convert the formula to real terms before moving forward. Let’s replace z_n and c with a sum of normal Cartesian coordinates — z_n = (x_n, y_n) and c = (u, v) — that are separated by the magic-bean value of 🐱… sorry, i = √-1:

\(\begin{array}{} z_n = x_n + iy_n \\ c = u + iv \\ \textrm{...after substitution:} \\ x_{n+1} + iy_{n+1} = (x_n + iy_n)^2 + (u + iv) \end{array}\)

The right-hand side of the equation can be expanded by following the normal rules for the square of a sum, but this brings us to the way in which the i = √-1 system differs from the🐱-based one: squaring √-1 yields a real number (-1).

\(\begin{array}{} (x_n + iy_n)^2 + (u + iv) \\ = x_n^2 + 2ix_n y_n + (iy_n)^2 + u + iv \\ = x_n^2 + 2ix_n y_n - y_n^2 + u + iv \end{array}\)

Anyway, the final step is to separate the real and imaginary (🐱-coupled) parts into two real-number-only coordinates:

\(\begin{array}{c} x_{n+1} + iy_{n+1} = (x_n^2 - y_n^2 + u) + i( 2 x_n y_n + v) \\ \\ \begin{array}{r l} \textrm{Real part (x axis): } & x_{n+1} = x_n^2 - y_n^2 + u \\ \textrm{Imaginary part (y axis): } & y_{n+1} = 2 x_n y_n + v \end{array} \end{array} \)

Now that we have a less scary formula, we can compute the Mandelbrot set by calculating about 1,000 steps of the (x_n, y_n) sequence for every screen coordinate (u, v); and then marking the (u, v) pixel as a part of the fractal if the (x_n, y_n) coordinates never escaped some modest radius (r ≥ 2) around the center of the coordinate system.

To add some flair, we can also color the pixels outside the perimeter based on their “escape velocity” — that is, how quickly they bailed out:

Mandelbrot set with escape velocity shading, by author.

The resulting Mandelbrot set is pretty but also fairly bland: all the fractal features are clustered along the perimeter and there is a huge void in the middle. Luckily, there is another remarkable way to visualize this set — or rather, the fate of the pixels that don’t get sucked into the black hole.

Follow it… if you can

As it turns out, it’s not just the boundary of the Mandelbrot set that’s mind-bogglingly complex: the same goes for the successive (x_n, y_n) coordinates produced for c = (u, v) parameters near the set’s edge. The iterated values follow elaborate, long-winded paths through space; their ethereal trails can be visualized using a density plot reminiscent of the Mandelbrot fractal itself. At low iteration counts, this similarity is quite pronounced:

Nascent Buddhabrot: 20 iterations, 32x32 oversampling. By author.

That said, when iterated over longer timescales, the new set develops a character of its own:

Composite 100k (R) + 100 (G, B) iterations, 32x32 oversample. By author.

Compared to the famed Mandelbrot set, this visualization — known as the Buddhabrot — is quite obscure. It is also notoriously difficult to compute; for example, two prominent renderings on Wikipedia are quite a bit off.

The main issue is the trajectories’ extreme sensitivity to starting conditions, exacerbated by the need to iterate the system for longer than necessary for most other plots. To illustrate the pitfalls, let’s consider the seemingly trivial task of translating integer screen coordinates to normalized floating-point (u, v) values, with the zero axis running through the middle of the plot. The most intuitive solution is the following formula:

\(\begin{array}{c} u = x_{screen} / x_{max} - 0.5 \\ v = y_{screen} / y_{max} - 0.5 \end{array}\)

Alas, that division is a trap: we all know that the results can be inexact, but it’s less obvious that this loss of precision might not be symmetrical in respect to our newly-chosen zero point. Here’s a real example of the unexpected bias for x_max = 3,000:

\(\begin{array}{r l} \textrm{Pixel 1,499}: & u = -0.0003333\underline{3897590} \\ \textrm{Pixel 1,500}: & u= \ \ \ 0 \\ \textrm{Pixel 1,501}: & u = +0.0003333\underline{0917358} \end{array}\)

This small error, compounded across hundreds of thousands of iterations, is enough to break the plot’s symmetry. I’d wager this is the most likely explanation of the issues with the following Wikipedia image:

Wikipedia’s Buddhabrot (left) and a map of broken-symmetry pixels (right).

Another problem present in that Wikipedia rendering and many other online examples are sharply-delineated curved lines, halos, and circles in the plot. They’re not an intrinsic feature of the set: instead, they’re density discontinuities caused by the discrete stepover of (u, v) values, probably worsened by floating-point math. The patterns are pretty, but they’re just a computational artifact that changes in response to variations in sample rate:

Artifacts galore: 2x2 oversampling, 1 million iterations. By author.

Indeed, with sufficient oversampling, these artifacts fade into the background:

Clean render: 32x32 oversampling, 1 million iterations. By author.

If you’d like to experiment with this or similar fractals, I have a very concise implementation here. I used this code to generate all the images in this article, except for the Koch curve and the printout from the 1978 book.

Peace out,

Mandelbrot’s heart, by author. High-res version here.

👉 I also have a second article about the nature of the Mandelbrot set itself. For a thematic overview of articles on this blog, click here.

---

I write well-researched, original articles about geek culture, algorithms, and more. If you like the content, please subscribe. It’s increasingly difficult to stay in touch with readers via social media; my typical post on X is shown to less than 5% of my followers and gets a ~0.2% clickthrough rate.