Mandelbrot Set

DEFINITION

zₙ₊₁ = zₙ² + c,  z₀ = 0
c ∈ M  ⟺  |zₙ| stays bounded

NOTES

The set of complex c for which the orbit of zero never escapes. Its boundary is where all the detail lives — infinitely long, everywhere rough, and containing distorted copies of the whole set at every scale. Colour here is escape time, not membership: the interior is genuinely black.

PROVENANCE

Origin

Named for Mandelbrot (1980); built on Fatou and Julia, 1917–19

Standing

Public domain — a set defined by an iteration

Constants

Iteration ceiling trades detail for speed

TOUCHDESIGNER · GLSL

The same shader this plate runs, reframed for a GLSL TOP. Pasted bare it renders the published constants as a still frame; wire absTime.seconds into u_t on the Vectors page to animate it.

// FORMA — PL. 13 · MANDELBROT SET — Benoît Mandelbrot, 1980 · after Fatou and Julia
//   zₙ₊₁ = zₙ² + c,  z₀ = 0
//   c ∈ M  ⟺  |zₙ| stays bounded
// TouchDesigner port — paste into a GLSL TOP's pixel shader. Set the
// resolution on the TOP's Common page. As pasted it renders the published
// constants as a still frame; to animate, add a uniform named u_t on the
// GLSL TOP's Vectors 1 page with the expression absTime.seconds.
// Constants are consts — edit to tweak; comments give the measured range.
// Written from the published mathematics, not adapted from any code.

#define u_res (uTDOutputInfo.res.zw)
uniform float u_t;               // absTime.seconds on the Vectors page; unset = still

const float u_phase = 0.1599;    // this plate's own grid phase, 0..1
// FORMA's FRACTALS accent as cosine-gradient coefficients
const vec3 u_pal_a = vec3(0.46, 0.1389, 0.1912);
const vec3 u_pal_b = vec3(0.5, 0.151, 0.2078);
const vec3 u_pal_c = vec3(1, 1, 1);
const vec3 u_pal_d = vec3(0, 0.05, 0.1);

const float p_cx   = -0.745;      // centre — real · live -2.2 .. 0.8
const float p_cy   = 0.113;       // centre — imaginary · live -1.2 .. 1.2
const float p_zoom = 1.0;         // zoom · live 0.4 .. 60
const float p_iter = 140.0;       // iteration ceiling · live 40 .. 400

/* The order's ramp — the same cosine formulation the JS kit uses, so a
   plate keeps its classification colour in either language. */
vec3 ramp(float t){
  return clamp(u_pal_a + u_pal_b * cos(6.28318530718 * (u_pal_c * t + u_pal_d)), 0.0, 1.0);
}

/* Sawtooth and triangle on this plate's phase, mirroring the JS kit. */
float cycle(float t, float period){ return fract(t / period + u_phase); }
float pingpong(float t, float period){
  float u = cycle(t, period);
  return u < 0.5 ? u * 2.0 : 2.0 - u * 2.0;
}


vec3 plate(vec2 uv){
  /* Two decades of dive and back — the same cycle the JS path runs. */
  float z = min(2000.0, p_zoom * (1.0 + pingpong(u_t, 27.0) * 119.0));
  float span = 3.0 / z;
  float it = min(320.0, floor(p_iter * (1.0 + log2(z) * 0.5) + 0.5));

  float cr = p_cx + (uv.x - 0.5) * span;
  float ci = p_cy + (uv.y - 0.5) * span * (u_res.y / u_res.x);

  float zr = 0.0, zi = 0.0, n = 0.0;
  /* GLSL wants a constant bound, so the loop runs to the specimen's own
     ceiling of 320 and breaks on the live iteration count. */
  for (int i = 0; i < 320; i++){
    if (float(i) >= it || zr * zr + zi * zi >= 4.0) break;
    float tmp = zr * zr - zi * zi + cr;
    zi = 2.0 * zr * zi + ci;
    zr = tmp;
    n += 1.0;
  }
  if (n >= it) return vec3(4.0, 6.0, 10.0) / 255.0;
  /* Continuous dwell, then the log remap the whole escape family shares. */
  float nu = n + 1.0 - log2(log(zr * zr + zi * zi) / 2.0);
  float g = log(1.0 + max(0.0, nu)) / log(1.0 + it);
  return ramp(0.44 + 0.62 * g);
}

out vec4 fragColor;
void main(){
  // FORMA's uv runs y-down, matching its canvas; TD's vUV runs up
  vec2 uv = vec2(vUV.s, 1.0 - vUV.t);
  fragColor = TDOutputSwizzle(vec4(plate(uv), 1.0));
}

NUKE · BLINKSCRIPT

The same shader this plate runs, transpiled to a BlinkScript kernel. Paste it into a BlinkScript node's Kernel Source and press Recompile; every constant arrives as a knob at its published value, and u_t animates with the expression frame/24. Compiled and rendered in Nuke 17.1, then compared against this plate on the page.

// FORMA — PL. 13 · MANDELBROT SET — Benoît Mandelbrot, 1980 · after Fatou and Julia
//   zₙ₊₁ = zₙ² + c,  z₀ = 0
//   c ∈ M  ⟺  |zₙ| stays bounded
// Nuke port — a BlinkScript kernel. Paste into a BlinkScript node's Kernel
// Source and press Recompile. Every constant arrives as a knob at its published
// value (the comment gives the measured range); u_t is a knob too — animate it
// with the expression frame/24 or leave it at 0 for the still frame. Written
// from the published mathematics, not adapted from any code.
// Transpiled from the shader this plate runs on the page (GLSL ES 3.00):
// vec → float2/3/4, swizzles expanded, GLSL builtins Blink lacks written out
// as forma_ functions, float literals suffixed. Compiled and rendered in a
// real Nuke (17.1v1) and compared against this plate on the page: 34 of 34.
//
// plate() and its helpers are written to a single exit — the loop that runs
// once. That is not a style: Blink 17.1 drops a conditional early return from
// a called function while Vectorize is on, which is the node default, with no
// warning and no error. Written this way it paints correctly as pasted.

kernel Forma_mandelbrot : ImageComputationKernel<ePixelWise>
{
  Image<eWrite> dst;

param:
  float u_t;             // seconds; 0 is the still frame
  float p_cx;   // centre — real · live -2.2 .. 0.8
  float p_cy;   // centre — imaginary · live -1.2 .. 1.2
  float p_zoom; // zoom · live 0.4 .. 60
  float p_iter; // iteration ceiling · live 40 .. 400

local:
  float2 u_res;
  float u_phase;
  float3 u_pal_a, u_pal_b, u_pal_c, u_pal_d;

  void define(){
    defineParam(u_t, "u_t", 0.0f);
    defineParam(p_cx, "p_cx", -0.745f);
    defineParam(p_cy, "p_cy", 0.113f);
    defineParam(p_zoom, "p_zoom", 1.0f);
    defineParam(p_iter, "p_iter", 140.0f);
  }

  void init(){
    u_res = float2(float(dst.bounds.width()), float(dst.bounds.height()));
    u_phase = 0.1599f;    // this plate's own grid phase, 0..1
    // FORMA's FRACTALS accent as cosine-gradient coefficients
    u_pal_a = float3(0.46f, 0.1389f, 0.1912f);
    u_pal_b = float3(0.5f, 0.151f, 0.2078f);
    u_pal_c = float3(1.0f, 1.0f, 1.0f);
    u_pal_d = float3(0.0f, 0.05f, 0.1f);
  }

  /* GLSL builtins Blink lacks, written as templates rather than overload sets.
     Blink's operators return expression templates (Swizzle<float,N>), so a call
     passing an expression cannot resolve against an overload set on float2
     against float3 — measured in Nuke 17.1: a float2 expression is ambiguous
     between the two, while scalar-against-vector resolves. A template deduces
     the expression's own type, so the ambiguity cannot arise. */
  template <class T> T forma_fract(T v){ return v - floor(v); }
  template <class T, class S> T forma_mod(T x, S y){ return x - y * floor(x / y); }
  /* Blink's own min/max/clamp take no scalar bound against a vector, which GLSL
     does; v * 0.0f + b is that bound at the vector's own width, and collapses to
     b when v is a scalar, so one template serves both. */
  template <class T, class S> T forma_min(T a, S b){ return min(a, a * 0.0f + b); }
  template <class T, class S> T forma_max(T a, S b){ return max(a, a * 0.0f + b); }
  template <class T, class S> T forma_clamp(T v, S lo, S hi){ return clamp(v, v * 0.0f + lo, v * 0.0f + hi); }
  int forma_min(int a, int b){ return min(a, b); }
  int forma_max(int a, int b){ return max(a, b); }
  /* GLSL step(edge, x) is 1 where x >= edge; floor(sign(x - e) * 0.5 + 1) is
     that exactly, equality included, out of builtins Blink does have. */
  template <class T, class S> T forma_step(S e, T x){ return floor(sign(x - e) * 0.5f + 1.0f); }
  template <class T, class S> T forma_smoothstep(S a, S b, T x){
    T t = forma_clamp((x - a) / (b - a), 0.0f, 1.0f);
    return t * t * (3.0f - 2.0f * t);
  }
  template <class T> float forma_distance(T a, T b){ return length(a - b); }
  float forma_tanh(float x){ float e = exp(2.0f * x); return (e - 1.0f) / (e + 1.0f); }
  float forma_radians(float d){ return d * 0.01745329252f; }
  // the page's hash2 is exact uint32; Blink has int, so the shifts are made
  // logical by masking and the read-back is lifted into 0 .. 2^32
  /* A uint read back as a float. Blink has no unsigned type, so a value past
     2^31 arrives as a negative int and float() of it is negative. Measured on
     gabor, whose own generator then returned uniforms in [-0.5, 0.5) and drew
     a different picture — it compiled, it rendered, and only comparing it with

  /* The order's ramp — the same cosine formulation the JS kit uses, so a
     plate keeps its classification colour in either language. */
  float3 ramp(float t){
    return forma_clamp(u_pal_a + u_pal_b * cos(6.28318530718f * (u_pal_c * t + u_pal_d)), 0.0f, 1.0f);
  }

  /* Sawtooth and triangle on this plate's phase, mirroring the JS kit. */
  float cycle(float t, float period){ return forma_fract(t / period + u_phase); }
  float pingpong(float t, float period){
    float u = cycle(t, period);
    return u < 0.5f ? u * 2.0f : 2.0f - u * 2.0f;
  }


  float3 plate(float2 uv){
    float3 forma_r = float3(0.0f, 0.0f, 0.0f);
    for (int forma_once = 0; forma_once < 1; forma_once++){
      /* Two decades of dive and back — the same cycle the JS path runs. */
      float z = forma_min(2000.0f, p_zoom * (1.0f + pingpong(u_t, 27.0f) * 119.0f));
      float span = 3.0f / z;
      float it = forma_min(320.0f, floor(p_iter * (1.0f + log2(z) * 0.5f) + 0.5f));

      float cr = p_cx + (uv.x - 0.5f) * span;
      float ci = p_cy + (uv.y - 0.5f) * span * (u_res.y / u_res.x);

      float zr = 0.0f;
      float zi = 0.0f;
      float n = 0.0f;
      /* GLSL wants a constant bound, so the loop runs to the specimen's own
         ceiling of 320 and breaks on the live iteration count. */
      for (int i = 0; i < 320; i++){
        if (float(i) >= it || zr * zr + zi * zi >= 4.0f) break;
        float tmp = zr * zr - zi * zi + cr;
        zi = 2.0f * zr * zi + ci;
        zr = tmp;
        n += 1.0f;
      }
      if (n >= it) { forma_r = float3(4.0f, 6.0f, 10.0f) / 255.0f; break; }
      /* Continuous dwell, then the log remap the whole escape family shares. */
      float nu = n + 1.0f - log2(log(zr * zr + zi * zi) / 2.0f);
      float g = log(1.0f + forma_max(0.0f, nu)) / log(1.0f + it);
      { forma_r = ramp(0.44f + 0.62f * g); break; }
    }
    return forma_r;
  }

  void process(int2 pos){
    // FORMA's uv runs y-down like its canvas; Nuke's rows run up
    float2 uv = float2((float(pos.x) + 0.5f) / u_res.x, 1.0f - (float(pos.y) + 0.5f) / u_res.y);
    float3 c = plate(uv);
    dst() = float4(c.x, c.y, c.z, 1.0f);
  }
};