Mandelbrot Set Fractal in Python

The Mandelbrot set is one of the most famous objects in mathematics. It's also one of the most surprising — an entire universe of infinite, self-similar detail emerges from a formula so simple you can write it on a sticky note: z = z² + c.

What The Mandelbrot Set Actually Is

Pick any complex number c. Then run this loop:

z = 0
repeat:
    z = z*z + c

One of two things will happen:

If you check every point in the complex plane and color the "in" points black, you get the iconic Mandelbrot silhouette: a heart-shaped main body with a circle bulb stuck to the left, surrounded by progressively smaller copies of itself.

The colorful halo around it isn't part of the set — it's a visualization of how fast each outside point escaped. Points that escape after 2 iterations get one color, points that take 200 iterations get another. That escape speed is what creates the fractal's shimmering, infinitely detailed boundary.

The One Mathematical Shortcut You Need

There's a beautiful theorem hiding here: if `|z|` ever exceeds 2, the sequence is guaranteed to escape to infinity. So you don't have to wait forever to know a point is outside the set — the moment |z| > 2, you can stop iterating and record the count. This is what max_iter is for: a budget. If a point hasn't escaped within that budget, we treat it as "in" the set.

Why You Vectorize With NumPy

The naive way to render this is a triple loop: for each pixel row, for each column, run the iteration loop. For a 600×600 image with 200 iterations, that's 72 million Python-level operations — agonizingly slow.

The NumPy version in the snippet does the same math, but on the entire grid at once. Z = Z**2 + C updates 360,000 complex numbers in a single CPU-friendly operation. The result is hundreds of times faster.

A few details that make the vectorized version work:

Choosing `max_iter` — The Trade-off

Low max_iter is fast but loses detail near the boundary — points that would escape eventually get incorrectly classified as "in the set". High max_iter reveals more of the fractal's intricate edge but costs proportionally more computation.

A practical rule:

Where To Zoom

The boundary of the set is where the magic lives. A few famous neighborhoods worth visiting:

The deeper you zoom, the more bizarre the structures get. The set is provably self-similar at every scale — there is no "bottom" to reach.

Color Palettes Matter

The escape-iteration map is just integers. The visual character comes entirely from the colormap:

For a really polished look, use smooth coloring: iter + 1 - log(log(|z|)) / log(2) instead of integer iteration counts. It eliminates the visible "banding" in the colors.

Julia Sets — The Same Idea, Inside Out

The Mandelbrot set lives in parameter space — each pixel is a different value of c. Julia sets live in dynamical space — c is fixed, and each pixel is a different starting z.

Every c in the complex plane has its own Julia set. Pick c from inside the Mandelbrot set and the Julia set is a connected blob. Pick c from outside and it shatters into a Cantor-like dust. The boundary points of the Mandelbrot set produce the most beautiful Julia sets — fractal swirls, lightning, and dragons.

A few c values that produce iconic Julia sets:

Things To Try Next

Run the snippet above and you'll see the full set in moments, dive into a region of detail that didn't even exist at the previous zoom level, and watch four Julia sets emerge from the same algorithm just by changing one constant.