General

This page provides a bit of information about escape-time fractals (like the Mandelbrot) - at least how I perceive them - and how they are rendered as orbit fractals.
For general information about the Buddhabrot fractal, see also: https://en.wikipedia.org/wiki/Buddhabrot
A basic understanding about complex numbers (https://en.wikipedia.org/wiki/Complex_number) is also useful. (They are basically numbers made from two components.)

Escape time fractal
An escape time fractal is defined by a function f_n(C).
This formula is usually defined in a recursive way, e. g. the Mandelbrot formula is
f₀(C) = 0
f_n+1(C) = f_n(C)² + C
One orbit is defined by a C (in the range from -2-2i to +2+2i) and consists of many points (f₁(C), f₂(C), f₃(C),...)
When the magnitude of a f_n(C) becomes greater than 2, it is said to have bailed out. (This is called the bailout test.)
Some orbits bail out, some do never.
If a orbit bails out, the number of iterations it takes before bailing out is called the orbit length.

Usually, these escape fractals are rendered in the following way:
1. The C is set to the pixel coordinate.
2. f_n(C) is computed iteratively for an increasing n, until it bails out or n > the maximum number of iterations
3. The pixel is colored according to the highest n computed for that pixel.

Instead, when rendering the Buddhabrot (or other fractals using this method), we draw the full orbits:
1. A random C is chosen.
2. The orbit for that C is computed.
3. If the orbit bails out, every f_n(C) is drawn as a point in the image.

Also, formulas are often written using Z instead of f(C).

Writing formulas for Buddhabrot Max / Mag
(For all available functions and constants, see FormulaHelp.txt in the Formulas folder.)
Also see the .max files for example formulas.

So a formula is defined by three thing:
1. It's initilization (e. g. Z₀ = 0 for the Mandelbrot)
2. The iteration (e. g. Z_n+1 = Z_n² + C for the Mandelbrot)
3. The bailout test (e. g. |Z_n| > 2 for the Mandelbrot)

The formula would translate like this to the simple formula language:

_INIT_

_LOOP_
Z[n+1] = Z[n]^2 + C;

_BAIL_
absSq(Z[n+1]) > 4;

Every statement is finished with a ";".

The INIT block contains the initialization. There's nothing here, because Z_n is implicitly initilized to 0.

LOOP contains the iteration. There are three Zs that you can use:
Z[n+1]: The Z computed in this iteration. It's the only one that can be assigned.
Z[n]: The previous Z.
Z[0]: Cannot be assigned, is always 0 or the perturbation.

BAIL contains the bailout condition.
absSq(x) computes the squared magnitude of x, which is faster than the regular magnitude (abs(x)).
It is compared to 4, because that's the square of 2.

---

Another example: The Manowar Formula
It is given by Z_n+1 = Z_n² + Z_n-1 + C
However it is not possible to access arbitrary Z_i, so we have to use a separate variable to store Z_n-1.

_INIT_
complex z1;
z1 = Z[0];

 _LOOP_ 
Z[n+1] = Z[n]^2 + z1 + C;
z1 = Z[n];

_BAIL_
absSq(Z[n+1]) > 4;

Here, we declare a new variable called z1 in the INIT block. Then we assign it to be the same value as Z₀.
You always have to declare all variables before using any of them.

In LOOP, we can then use this variable. We first read from it, then we store the Z_n in it, so it will contain Z_n-1 in the next iteration.

---

So, writing formulas is actually pretty straightforward, it's pretty much experimentation and seeing what looks nice.