Fractal Explorer

A simple rule. Repeated.

Start with a number. Apply the same rule again and again.

z → z² + c

Some numbers stay bounded. Others run away. The boundary between those two behaviours is where things become strange.

A simple rule, once per pixel

The picture you will see is not a saved image. Nothing in it was drawn by hand. The screen is a grid of pixels, and every pixel runs the same tiny calculation on its own.

A pixel is a location on a number plane: an X and a Y. For that one point the program repeats:

z → z² + c

It feeds the answer back in, again and again. Then it paints that pixel according to what happened, and moves on to the next pixel. The fractal is simply all of those private answers sitting next to each other.

One pixel, one calculation, one colour. The picture is what you get when every pixel does that.

X and Y: how a pixel gets its number

The picture is a window onto a flat plane of numbers. Each pixel is named by two coordinates:

That pair is the pixel’s number. Written in one piece it looks like X + Y i. The i only marks “this is the up and down part.” The calculation uses both together.

In the explorer, Center X and Center Y are the coordinates of the middle pixel. Dragging slides the window so a different (X, Y) sits in the centre. Zooming shrinks the window: neighbouring pixels then have X and Y values that are closer together, and each one still runs the same rule on its own pair.

What happens at one pixel

The list of numbers that one pixel produces is called an orbit. Some orbits wander but stay nearby. Others grow without limit. Those escape.

For one pixel: start at z, then z → z² + c, then again, then again.

Neighbours on the screen are neighbours on the number plane, so they often behave alike. At the boundary a tiny shift in position changes the answer. That boundary is the fractal.

Mandelbrot and Julia

The rule is the same for every pixel. What changes is what the pixel’s position means.

The Mandelbrot set is a map of parameters; a Julia set is what one parameter produces.

Who found these sets

The Julia sets are older. The question was not how to draw a picture. It was what happens in the long run if you keep applying the same rule to a complex number. That is the same kind of question as asking whether Newton’s method will settle on a root, or wander. In 1918 the French Academy of Sciences offered a prize for work on iteration. Gaston Julia’s memoir won it. Pierre Fatou was proving the same landscape at the same time, independently.

What they found is a split of the plane. For a fixed rule (a fixed c), some starting points are stable: nearby starts stay nearby, and the orbit settles into a calm pattern, or escapes in an orderly way. Those regions are now called the Fatou set. The remaining points form a boundary where the behaviour is unstable. A tiny change of starting point can send the orbit somewhere completely different. That boundary is the Julia set. Applying the rule maps the Julia set to itself. It is the skeleton of the dynamics, not a decoration around them.

They also found that, for the quadratic rule used here, the Julia set has only two large-scale shapes. Either it is one connected piece, or it shatters into dust: a cloud of separate points with no area. Which of those happens is decided by a single test orbit, the orbit that starts at 0. If that orbit stays bounded, the Julia set stays in one piece. If it escapes, the set breaks apart. That is why the Mandelbrot set, much later, is a map of the orbit of 0. Julia and Fatou already knew that this one orbit controls the whole picture. They could not see the map of all c at once.

The work was pure mathematics. It was not built as a tool for engineering or art. It sat for decades as a difficult, little-illustrated chapter of analysis. The pictures in this explorer are the sets they described, calculated pixel by pixel, which they never had the means to draw. The arithmetic had to be done by hand.

The word fractal came later. Benoit Mandelbrot introduced it in 1975 for shapes that stay rough no matter how closely you look. In 1980, using computers at IBM, he plotted the values of c for which the orbit of 0 never escapes. The black continent that appeared is the Mandelbrot set. Adrien Douady and John Hubbard gave it his name, and showed how it organises the Julia sets: each point on the Mandelbrot picture picks out one Julia set, connected if the point is inside, dust if it is outside.

So the explorer is a 1918 classification that only became a picture once a machine could run the rule for every pixel.

See the connection

Click a pixel on the Mandelbrot set. That pixel’s number becomes the c shared by every pixel of the Julia set.

Explore

What you are looking at is that calculation, once for every pixel. Drag to pan and you slide which numbers those pixels stand for. Scroll or pinch to zoom and each pixel covers a smaller patch of the plane, then runs the same rule on that finer point.

Drag the picture to pan. Double-click to zoom in. Arrow keys pan; + and − zoom; R restores the last preset you loaded. The picture stays in view while you use the controls on the right.

Drag the picture to pan. Pinch, or use + and −, to zoom. The picture stays at the top while you scroll the controls.

Palette and color shift change how the picture looks. Changing c, or the view, changes the mathematics.

Try this

The strange part

The surprising thing is not that the equation produces complicated shapes. It is that you do not have to put the complexity into the equation.

The rule stays simple. The complexity comes from repetition. Zoom into the boundary and new structures appear: spirals, filaments, tendrils, and miniature copies of the larger form. The image is not a stored pattern. It is being calculated again for every pixel.

Those views are the same rule, started from a different window.

The complexity isn’t hidden in the picture. It’s in the process that produces it.

The limit

This explorer uses ordinary GPU floating-point arithmetic. Eventually the numbers become too coarse to tell neighbouring pixels apart. Further magnification would show numerical artefacts rather than genuinely new structure. When the status line says the precision limit is near, that is the machine, not the set.

Experiment

Iterations. How many times each pixel is allowed to repeat the rule before we decide it has not escaped. Too few, and thin filaments vanish. More repeats reveal more of the true boundary.

Escape radius. How large a pixel’s number must become before we count it as gone. Once it is larger than this, it will only get larger.

Julia c. The one parameter that a Julia set holds fixed. Sliding it, or picking it from the Mandelbrot set, chooses a different world.

Palette and color shift. How escape behaviour is painted, and where the gradient starts. Neither changes which pixels belong to the set.

Coloring. How iteration becomes colour: smooth, bands, contrast, or glow. Again, appearance, not membership.

A preset only writes numbers into that shared state. After you land on Seahorse you can still change iterations, palette, or switch to Julia. Changing anything marks the view as Custom · based on Seahorse. Reset, or clicking Seahorse again, restores that starting point.

Behind the math

Each pixel is mapped to a complex number. X is the real part (left and right). Y is the imaginary part (up and down). Together they are written x + yi, with i² = −1. That pixel, and only that pixel, then iterates z → z² + c. Addition is componentwise. Multiplication turns the plane: (a + bi)(c + di) = (ac − bd) + (ad + bc)i.

The modulus |z| is the distance from 0, √(x² + y²). An orbit is declared to have escaped when |z| exceeds a chosen radius R (the escape radius). For the quadratic map, once |z| > max(R, 2) the remaining terms grow without bound, so the test is decisive.

On the Mandelbrot set, pixel (x, y) is the parameter c. The orbit starts at z = 0. The pixel is in the set if that orbit stays bounded. On a Julia set, c is fixed for the whole picture and pixel (x, y) is the starting z.

The dark interior is “still bounded after N iterations.” Colour outside uses how large N was when the point escaped. Smooth and contrast coloring adjust that count by a logarithmic term, log(log(|z|) / log(R)) / log(2), so neighbouring pixels do not jump in whole iteration bands. Glow is a softer heuristic, not a distance estimator.

The picture is drawn in a fragment shader: every pixel runs the same loop independently on the GPU. That is why the explorer can move in real time, and why zoom cannot go forever. The coordinates are ordinary 32-bit floats.