FRACTA

A lightweight domain-specific language to define, render, and explore fractals.

1. Overview

Fracta is a line-oriented plaintext DSL that expresses fractal geometry through four computational engines: L-systems (string-rewriting turtle graphics), PIXEL (escape-time complex-plane iteration), IFS (Iterated Function Systems via affine transforms), and REACTION_DIFFUSION (Gray-Scott continuous reaction-diffusion simulation). Scripts are deterministic — except for the stochastic seed in REACTION_DIFFUSION — and portable across any conforming interpreter.

A minimal Fracta program selects an engine, sets parameters, and issues RENDER:

ENGINE L_SYSTEM
AXIOM F--F--F
RULE F -> F+F--F+F
ANGLE 60
ITER 4
RENDER

2. Lexical Rules

• Case sensitivity: Directives (ENGINE, AXIOM, RULE, …) must be UPPERCASE. Rule symbols are case-sensitive.
• Line-oriented: One directive per line. No multi-line directives.
• Whitespace: Leading/trailing spaces are stripped. Internal spaces are delimiter padding.
• Comments: Lines beginning with # are ignored. Inline # is also a comment delimiter.

3. Engines

Select the rendering engine with the ENGINE directive at the top of your script.

ENGINE L_SYSTEM
AXIOM FX
RULE X -> X+YF+
RULE Y -> -FX-Y
ANGLE 90
ITER 12
RENDER

ENGINE PIXEL
FORMULA z**2 + c
X_RANGE -2.0 0.5
Y_RANGE -1.25 1.25
RES 600
ITER 100
COLORMAP magma
RENDER

ENGINE IFS
ITER 80000
RULE 0.01  0.0   0.0   0.0   0.16  0.0  0.0
RULE 0.85  0.85  0.04 -0.04  0.85  0.0  1.6
RULE 0.07  0.2  -0.26  0.23  0.22  0.0  1.6
RULE 0.07 -0.15  0.28  0.26  0.24  0.0  0.44
RENDER

ENGINE REACTION_DIFFUSION
RES 128
STEPS 3000
FEED 0.035
KILL 0.065
COLORMAP inferno
RENDER

4. Directive Reference

5. Turtle Graphics Alphabet (L_SYSTEM)

The turtle starts at (0, 0) heading 90° (straight up). Angles follow the standard radial (anticlockwise-positive) convention.

6. ANGLE — Degrees vs Radians

By default ANGLE accepts degrees:

ANGLE 60       # 60 degrees

Append r to supply radians directly:

ANGLE 1.0472r  # π/3 ≈ 60°
ANGLE 3.14159r # π = 180°

Both formats follow the counterclockwise-positive convention: + increases θ, - decreases it.

7. Formal Grammar (EBNF)

<fracta_script> ::= { <statement> <newline> } ( <render_cmd> | <render_grid_cmd> )
<statement>     ::= <comment> | <engine_def> | <axiom_def> | <rule_def>
                  | <angle_def> | <iter_def> | <param_def>

<engine_def>    ::= "ENGINE " ( "L_SYSTEM" | "PIXEL" | "IFS" | "REACTION_DIFFUSION" )
<axiom_def>     ::= "AXIOM " <string_payload>
<rule_def>      ::= "RULE " <char_token> " -> " <string_payload>
<angle_def>     ::= "ANGLE " <float_val> [ "r" ]
<iter_def>      ::= "ITER " <int_val>
<param_def>     ::= <upper_ident> " " <value_string>
<render_cmd>    ::= "RENDER"
<render_grid_cmd> ::= "RENDER_AS_GRID"

<float_val>     ::= [0-9]+ [ "." [0-9]+ ]
<int_val>       ::= [0-9]+
<comment>       ::= "#" { <any_char> }

8. Runtime Pipeline

┌─────────────────────────────────────┐
│ 1. Lexical Scanner                  │
│    Lines → directives → param map  │
└────────────────┬────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────┐
│ 2. Production Expansion (L_SYSTEM)  │
│    Axiom → apply rules × ITER       │
└────────────────┬────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────┐
│ 3. Render                           │
│    Turtle trajectory / PIXEL grid / │
│    IFS random walk /                │
│    Gray-Scott RD → matplotlib       │
└─────────────────────────────────────┘

State vector during phase 3: S = ⟨x, y, θ, Stack⟩ where θ is initialized to 90° and Stack is a LIFO of (x, y, θ) triples. Unmatched ] tokens raise a runtime error.

9. Examples

Koch Snowflake

ENGINE L_SYSTEM
AXIOM F--F--F
RULE F -> F+F--F+F
ANGLE 60
ITER 4
RENDER

Fractal Plant

ENGINE L_SYSTEM
AXIOM X
RULE X -> F+[[X]-X]-F[-FX]+X
RULE F -> FF
ANGLE 25
ITER 5
RENDER

Heighway Dragon

ENGINE L_SYSTEM
AXIOM FX
RULE X -> X+YF+
RULE Y -> -FX-Y
ANGLE 90
ITER 12
RENDER

Mandelbrot Set

ENGINE PIXEL
FORMULA z**2 + c
X_RANGE -2.0 0.5
Y_RANGE -1.25 1.25
RES 600
ITER 100
COLORMAP magma
RENDER

Julia Set (c = −0.7 + 0.27i)

ENGINE PIXEL
FORMULA z**2 + c
C_VAL -0.7+0.27j
X_RANGE -1.5 1.5
Y_RANGE -1.5 1.5
RES 500
ITER 80
COLORMAP twilight_shifted
RENDER

Barnsley Fern (IFS)

ENGINE IFS
ITER 80000
RULE 0.01  0.0   0.0   0.0   0.16  0.0  0.0
RULE 0.85  0.85  0.04 -0.04  0.85  0.0  1.6
RULE 0.07  0.2  -0.26  0.23  0.22  0.0  1.6
RULE 0.07 -0.15  0.28  0.26  0.24  0.0  0.44
RENDER

10. Reaction-Diffusion Pattern Guide

The Gray-Scott model produces qualitatively different Turing patterns depending on the (FEED, KILL) pair. Small changes in these values can flip the simulation from spots to stripes to coral mazes.

Gray-Scott — Turing Spots

ENGINE REACTION_DIFFUSION
RES 128
STEPS 3000
FEED 0.035
KILL 0.065
DU 0.16
DV 0.08
COLORMAP inferno
RENDER

Gray-Scott — Coral Maze

ENGINE REACTION_DIFFUSION
RES 128
STEPS 3000
FEED 0.055
KILL 0.062
DU 0.16
DV 0.08
COLORMAP RdYlBu
RENDER

Gray-Scott — Zebrafish Stripes

ENGINE REACTION_DIFFUSION
RES 128
STEPS 3500
FEED 0.022
KILL 0.051
DU 0.16
DV 0.08
COLORMAP viridis
RENDER

11. The .fct File Format

Fracta scripts are saved as plain UTF-8 text files with the .fct extension. A .fct file contains exactly one Fracta program — one ENGINE block ending with RENDER or RENDER_AS_GRID.

Specification

• Encoding: UTF-8, Unix or Windows line endings (LF or CRLF)
• Extension: .fct (short for fracta)
• MIME type: text/x-fracta
• Structure: Sequence of directives, one per line, terminated by RENDER
• Comments: Lines beginning with # are ignored
• No binary sections: All content is printable ASCII / UTF-8 text

Canonical Layout

# Optional header comment — name, author, date
ENGINE <engine>
# Parameters
<KEY> <value>
RULE <...>
RENDER

Differences from .ufm (UltraFractal)

Use ufm_to_fracta.py (or the Import UFM button in the playground) to convert UltraFractal .ufm escape-time formulas to .fct scripts. Unsupported UF features (multi-statement loops, custom bailout, user parameters, coloring algorithms) are reported as warnings.