Write Fractals with FRM

FractalPark tokenizes, parses, validates, and compiles a deliberate FRM subset. The table separates constructs that work directly, constructs with documented FractalPark semantics, and constructs the current workflow cannot preserve.

A FractalPark FRM formula has one named declaration and three explicit sections. Together they define the state transition for every pixel.

The section names are structural, not comments: omitting or misspelling one produces a diagnostic.

The language stays intentionally small: expressions describe complex arithmetic, statements update orbit state, and control flow selects among updates.

Declaration and sections

Wrap one named formula in braces, then write init:, loop:, and bailout: in that order.

Values and variables

Use real numbers such as 0.15, complex pairs such as (0.05, -0.02), built-in orbit values, or your own assigned variables.

Expressions

Arithmetic, powers, comparisons, logical operators, unary operators, |z| magnitude syntax, and tested complex functions can be combined.

Control flow

Use if, elseif, else, and endif when an orbit update depends on a condition. Blocks must be balanced.

Built-ins

Core names include z, c, pixel, zPrev, p1–p5, pi, e, maxit, ismand, fn1–fn4, and the functions covered by compiler tests.

Comments and directives

Semicolon comments document source. Recognized @ directives configure FractalPark native behavior; unknown directives are not silently ignored.

FractalPark does not paste FRM text into a shader. It passes source through a staged compiler so syntax, meaning, generated code, and diagnostics stay connected.

1. 1

   FRM source

   The exact text from the editor, paste, or local file is the authoritative input.

2. 2

   Lexer tokens

   The lexer recognizes names, numbers, operators, section markers, comments, and directives while retaining source locations.

3. 3

   Parsed AST

   The parser builds a structured formula tree and reports malformed declarations, expressions, and control-flow blocks.

4. 4

   Validation and canonical form

   The validator checks names, types, sections, and supported semantics before a canonical formula is created.

5. 5

   GLSL and source map

   Code generation emits shader functions and records mappings from generated GLSL back to FRM source.

6. 6

   Formula plugin

   A successful compile becomes the same formula-plugin contract used by the renderer and shader assembly system.

These examples advance from the smallest quadratic formula to parameters and stateful feedback. Each source block is taken directly from the shared example registry and compiled during tests.

StarterBrot {
init:
  z = 0
loop:
  z = z^2 + c
bailout:
  |z| < 4
}

ParameterDrift {
init:
  z = 0
loop:
  z = z^2 + c + p1 * 0.15 + p2 * (0.05, -0.02)
bailout:
  cabs(z) < 8
}

OrbitEcho {
init:
  z = pixel
loop:
  z = sqr(z) + zPrev * (0.30, -0.12) + pixel * (0.85, 0.0)
bailout:
  |z| < 48
}

The FRM Editor opens these same compile-checked examples by stable ID. Formula source stays in the current tab until you save it to your cloud library, and is never embedded in the URL.

Compilation stops at the earliest unsafe stage and reports source-oriented messages. A rejected construct is never rewritten into something that merely looks similar.

When fixing an error, start with the first reported message: later diagnostics can be consequences of the same missing token or invalid expression.

A formula you write is private until you choose otherwise. There are three ways it can travel — each explicit, none silent.

• Private by default

  Formulas live in your cloud library, visible only to you. Artworks you save carry a copy of the formula source inside the draft, so they always open the way you left them.

• Download the .frm file

  Your formula is plain text. Download it from My Formulas any time and keep your own copy — no export request, no waiting.

• Publish an artwork, share the source

  Publishing an artwork that uses your formula makes the formula source public under the MIT License: anyone may read, copy, and build on it. The community page shows the formula name from its metadata and offers the source as a download. This cannot be undone for that publication.

The full MIT License text lives at opensource.org.