The Formula
The Phoenix fractal iterates z[n+1] = z[n]² + c + p·z[n-1]. That extra term - p·z[n-1] - is what makes it different from a standard Julia set. The iteration doesn't just depend on the current value; it also looks back one step. This gives the system a kind of memory.
The fractal was discovered by Shigehiro Ushiki in the 1990s. It's less well-known than the Mandelbrot or Julia sets, partly because the extra parameter makes it harder to navigate - there are more knobs to turn, and the results change fast when you turn them.
Why the Memory Matters
In a standard Julia set, each iteration only cares about where it is right now. The Phoenix fractal remembers where it was. This produces shapes with a layered quality - feathery, wing-like structures that earned it the name.
It also makes the fractal extremely sensitive to its parameters. Small changes to c or p can completely reshape the output. A connected, detailed structure can dissolve into dust with a tiny adjustment. This sensitivity is what makes the morphing animations work so well - the fractal responds visibly to every parameter shift.
Mathematically, this connects to delay differential equations, where a system's future depends on its past states. The same kind of feedback appears in population models, control systems, and neural circuits.
Exploring It
Continuously shifts parameters, letting the fractal reshape itself in real time. The sensitivity means even gentle changes produce visible transformations.
Uses the original Phoenix equations with a more traditional morphing path through parameter space.
Manual control over all parameters. Keyboard or touch - adjust c and p yourself to see how the fractal responds.
Rendering Notes
The Phoenix fractal needs to store two previous iteration values (z[n] and z[n-1]) instead of one, which doubles the per-pixel memory compared to a Julia set. On the GPU this is trivial - just an extra vec2 in the shader.
The bigger challenge is precision. Because the fractal is so parameter-sensitive, small floating-point errors during rapid morphing can cause visible jumping or flickering. The visualizer uses higher-precision arithmetic paths where needed to keep things stable.