SolSoul Mathematical Renderer Catalog

All SolSoul built-in renderers generate beauty from pure mathematics. This catalog documents the mathematical foundations, visual characteristics, and on-chain implementation of each renderer.

---

Renderer Philosophy

SolSoul maintains a strict boundary:

• ✅ Mathematical / Algorithmic: Beauty emerges from mathematical structures (fractals, chaos, fields, waves, lattices, noise)
• ❌ Illustrative / Thematic: Human-designed imagery with stylistic narratives (characters, scenes, themed objects)

This boundary ensures that every Soul is a discovery from mathematical space, not a selection from a pre-drawn gallery.

---

0x0000_0000 — Fractal Structure

Mathematical Basis: Iterated Function System (IFS)

IFS fractals are generated by repeatedly applying affine transformations to an initial point set. The classic Barnsley fern uses four transforms; SolSoul's renderer uses 3-5 transforms selected deterministically from the seed.

x' = a·x + b·y + e
y' = c·x + d·y + f

Where (a, b, c, d, e, f) are coefficients drawn from a deterministic pool seeded by the transaction hash.

Visual Characteristics

• Self-similar branching structures
• Organic, fern-like or tree-like silhouettes
• Infinite detail at all zoom levels
• Warm earth tones or cool ice palettes (deterministic from seed)

On-chain Implementation

• 10,000 iterations per generation
• Fixed-point arithmetic with SCALE = 10^12
• Color palette: 8 colors selected from 16-color deterministic palette
• Output: SVG <path> elements (~800-1200 points)

---

0x0000_0001 — Vector Field

Mathematical Basis: Flow Fields

A vector field assigns a direction vector to every point in 2D space. SolSoul uses Perlin-noise-derived curl fields:

v(x, y) = (−∂ψ/∂y, ∂ψ/∂x)

Where ψ is a scalar potential function computed from value noise octaves.

Particles are advected through the field using Euler integration, leaving streamlines that reveal the field's structure.

Visual Characteristics

• Flowing, river-like streamlines
• Vortex centers and saddle points
• Smooth gradients between streamlines
• Deterministic color mapping by streamline velocity

On-chain Implementation

• 64×64 noise grid computed from seed
• 200 particles, 500 steps each
• RK4 integration for smooth curves
• Output: SVG <path> streamlines with varying opacity

---

0x0000_0002 — Crystal Lattice

Mathematical Basis: Crystallographic Groups

Generates 2D wallpaper patterns from the 17 wallpaper groups (plane symmetry groups). The renderer selects a symmetry group and motif from the seed:

• p1: Translation only
• p2: 180° rotation
• pm: Reflection
• p4m: 90° rotation + reflection (square lattice)
• p6m: 60° rotation + reflection (hexagonal lattice)

Visual Characteristics

• Repeating geometric tessellations
• Kaleidoscopic symmetry
• Islamic art / Escher-like patterns
• Metallic or crystalline color schemes

On-chain Implementation

• Fundamental domain computed from group generators
• Motif: 3-7 line segments with deterministic endpoints
• Tiling: 4×4 fundamental domain repeats
• Output: SVG <path> elements with symmetry-transformed motifs

---

0x0000_0003 — Strange Attractor

Mathematical Basis: Chaotic Dynamical Systems

Strange attractors are sets of points in phase space that trajectories converge to, despite never repeating. SolSoul implements three attractor families:

Lorenz Attractor:

dx/dt = σ(y − x)
dy/dt = x(ρ − z) − y
dz/dt = xy − βz

Rössler Attractor:

dx/dt = −y − z
dy/dt = x + ay
dz/dt = b + z(x − c)

Aizawa Attractor:

dx/dt = (z − b)x − dy
dy/dt = (z − b)y + dx
dz/dt = c + az − z³/3 − (x² + y²)(1 + ez) + fz·x³

Parameters (σ, ρ, β, a, b, c, d, e, f) are seeded from the transaction hash.

Visual Characteristics

• Butterfly-wing or spiral-shell forms
• Never-repeating yet bounded trajectories
• Dense, cloud-like point distributions
• Dramatic depth from 3D projection

On-chain Implementation

• 50,000 integration steps per attractor
• 4th-order Runge-Kutta (RK4) for accuracy
• 3D→2D projection with deterministic camera angle
• Output: SVG <circle> point cloud (~5,000 visible points)

---

0x0000_0004 — Harmonic Wave

Mathematical Basis: Fourier Synthesis

Superposition of sinusoidal waves with harmonically related frequencies:

f(x, t) = Σ Aₙ · sin(2π·n·f₀·x + φₙ)

Where:

• f₀: Fundamental frequency (seeded)
• Aₙ: Amplitude of nth harmonic (seeded, decaying as 1/n)
• φₙ: Phase offset (seeded)
• n: Harmonic number (1-8)

For 2D Souls, two perpendicular wave systems interfere:

z(x, y) = f(x) + g(y) + h(x + y) · interference_term

Visual Characteristics

• Smooth, undulating wave patterns
• Moiré interference effects
• Rhythmic, musical visual quality
• Gradient fills between wave crests and troughs

On-chain Implementation

• 8 harmonics with deterministic amplitudes/phases
• 512 sample points along each axis
• Contour line extraction for SVG paths
• Output: SVG <path> contour lines with gradient fills

---

0x0000_0005 — Pixel Fractal

Mathematical Basis: IFS + Pixelation

Combines IFS fractal mathematics with intentional pixelation. The fractal is rendered at 32×32 resolution, then each "pixel" becomes an SVG <rect>:

for each pixel (i, j):
    density = ifs_density_at(i, j)
    color = palette[density % 16]
    emit <rect x="i*16" y="j*16" width="16" height="16" fill="color"/>

Visual Characteristics

• Retro 8-bit aesthetic
• Blocky, pixelated fractal forms
• Limited color palette (16 colors)
• Nostalgic digital art feel

On-chain Implementation

• 32×32 density grid from 5,000 IFS iterations
• 16-color deterministic palette
• Each pixel rendered as 16×16 SVG rect
• Output: 1,024 <rect> elements (~3KB SVG)

---

0x0000_0006 — Pixel Art

Mathematical Basis: Value Noise + Cellular Automata

Two-stage generation:

1. Base noise: 8×8 value noise grid with bilinear interpolation
2. Cellular refinement: 1-2 steps of deterministic cellular automata rules

// Value noise
v(x, y) = interpolate(seed_hash[x/4][y/4], seed_hash[x/4+1][y/4], ...)

// Cellular automata (conway-like)
new_cell = rule(old_cell, neighbor_sum)

Visual Characteristics

• 8-bit game aesthetic
• Cloud formations, building silhouettes, abstract landscapes
• Deterministic "scenes" from noise patterns
• 16-color 8-bit palette

On-chain Implementation

• 8×8 base grid → 32×32 interpolated grid
• Conway-like rules with deterministic birth/survival thresholds
• Cloud/building overlay detection from noise gradients
• Output: 1,024 <rect> elements with color mapping

---

Comparative Summary

---

Future Renderers (Research)

These mathematical art forms are candidates for future built-in or community renderers:

---

Document version: 2026-05-04