BOLT

What Is Bolt?

Bolt simulates diffusion-limited aggregation (DLA) — the physical process by which a fractal grows from pure randomness. A single seed particle sits at the center of a 300×300 grid. Twenty Brownian walkers are released from a circle just outside the existing cluster. Each walker does a genuine random walk — at every step it moves one cell in a randomly chosen direction. The moment any walker steps adjacent to the cluster, it freezes there and becomes part of it. A new walker is immediately released to take its place.

The color encodes the order of arrival. The very first particles to stick — near the center — glow in warm gold. As the cluster grows outward, the color transitions through amber, orange-red, and deep crimson, then crosses into purple, electric blue, and finally bright teal at the outermost tips. Reading the color is reading the history: you can see which branch grew first, and which tips are still growing now.

The glowing amber dots are the active walkers doing their random walks. When one of them touches the cluster, it freezes and its color locks in. The simulation runs until the cluster reaches the edge of the grid — roughly five thousand frozen particles, arranged into a structure the universe apparently likes: the same one it uses for lightning.

The Algorithm

The DLA algorithm was described by Witten and Sander in 1981 in a paper on particle aggregation. The rule is three lines:

1. Place a seed particle at the center of the grid.
2. Release a new particle from a random point on a circle
   just outside the current cluster.
3. The particle does a random walk (one step per tick,
   four equally likely directions). The moment it is
   adjacent to any frozen cell, it freezes in place.
   Go to step 2.

The result is a fractal cluster with a Hausdorff (fractal) dimension of approximately 1.71 in two dimensions — meaning it fills more space than a line (D=1) but less than a plane (D=2). The branching arises naturally from the random walk statistics: the tips of the cluster are more exposed to incoming particles, so they grow faster than the hollows between branches. This creates the characteristic lightning-like branching with deep fjords of empty space between arms.

Fractal dimension: D_f ≈ 1.71   (Hausdorff dimension, 2D DLA)

Cluster mass N vs. radius R:   N ~ R^{D_f}
                                N ~ R^{1.71}

// Live estimate on the HUD:
D_f(t) = log(N(t)) / log(R(t))
// Converges toward 1.71 as the cluster grows.
// Early values are noisy — the limit is what counts.

Why the Tips Grow Faster

The physics behind DLA is a screening instability. An incoming random walker reaches the outer tips of the cluster more often than the inner hollows, for the same reason a coastal headland receives more waves than a sheltered cove. The tips protrude outward and are statistically more likely to intercept a diffusing particle before it wanders inward.

Once a tip starts growing, it protrudes further, intercepts still more particles, and grows faster — a positive feedback that amplifies small initial fluctuations into large branching structures. The hollows between branches are progressively shielded by the growing tips and receive almost no particles.

This screening instability is why DLA is so visually striking: the earliest stochastic fluctuations (which branch tilts slightly further outward by chance) become locked in and amplified. No two DLA clusters are identical — each is a unique frozen record of its own Brownian noise.

Where This Appears in Nature

DLA or DLA-like growth appears across an enormous range of natural phenomena, always where diffusion governs how a substance reaches a growing boundary:

Lightning channels       — electrons diffuse toward the ground,
                          ionizing the air along the path of least resistance.
                          Each branch is one DLA arm.

Snowflakes               — water vapor diffuses to the growing ice crystal.
                          The six arms are DLA branches constrained to hexagonal symmetry.

Coral and sea sponges    — nutrients diffuse from the surrounding water to the
                          growing polyps. The branching morphology follows DLA statistics.

Mineral dendrites        — manganese or iron oxide diffuses through rock pores
                          and precipitates in branching DLA patterns on rock surfaces.
                          Often mistaken for fossil ferns.

Electrodeposition        — in a zinc sulfate solution with two electrodes, zinc ions
                          diffuse from the solution and plate out at the cathode in real-
                          time DLA fractal growth — the same pattern, visible in minutes.

Viscous fingering        — oil displaced by water in a porous medium forms DLA-like
                          fingers (Saffman-Taylor instability, close cousin to DLA).

In each case the fractal dimension D_f ≈ 1.71 is measured experimentally, matching the simulation. The fractal is a geometric signature of the diffusion equation governing growth — an infinite-dimensional PDE whose solutions at a moving boundary condense into a single real number: 1.71.

Implementation

The simulation runs on a 300×300 typed-array grid in pure JavaScript with zero libraries. The key performance choice is maintaining 20 simultaneous walkers, each taking 8 steps per animation frame. This gives ~9600 random walk steps per frame — enough to keep the cluster growing visibly at 60fps without spending more than ~2ms per frame on physics.

Grid:       Uint8Array(300×300)    — 0=empty, 1=cluster
ArrivalOrd: Uint16Array(300×300)   — arrival order per frozen cell
Walkers:    Int16Array(20)×2       — x and y per active walker
Palette:    Uint8Array(4800)×3     — precomputed RGB for each arrival order

Per frame:
  • 20 walkers × 8 steps = 160 random walk steps
  • Each step: 1 random direction, 1 grid read, 4 adjacency checks
  • On stick: update grid, arrivalOrd, clusterRadius, imgBuf, spawn new walker
  • 1× putImageData (300×300 → 540×540 CSS upscale, pixelated)
  • 20× fillRect(1,1) for walker dots

Color mapping:
  Precomputed palette: 8 keyframes interpolated for all 4800 arrival orders.
  gold → amber → red → crimson → purple → blue → teal → teal
  Encodes the TIME dimension of the fractal — color = when, not where.

The cluster is stored as a pre-built RGBA ImageData buffer that is updated incrementally (O(1) per stuck particle). The full 300×300 buffer is uploaded to the GPU once per frame via putImageData and CSS-scaled to 540px with image-rendering: pixelated, giving sharp 1.8× upscaled pixels with no blurring.

Reading the Fractal Dimension

The HUD shows a live estimate of D_f = log(N)/log(R), where N is the number of frozen particles and R is the maximum radius of the cluster. This ratio converges toward the true fractal dimension as the cluster grows.

Early in the run the estimate is noisy — a cluster of 50 particles on a random branching may give D_f anywhere from 1.2 to 2.0. As N grows into the thousands the estimate settles toward 1.71, the theoretically predicted and experimentally confirmed value. You can watch it converge in the upper right of the stats bar.

Theoretical:  D_f = 1.71   (Witten & Sander, 1981; 2D DLA universality class)
At N=100:     D_f ≈ 1.4–1.9  (noisy)
At N=1000:    D_f ≈ 1.55–1.75
At N=4000:    D_f ≈ 1.65–1.78  (converging)

Fractal dimension is not a property of any single run —
it is the average over the universality class of all DLA clusters.
Your cluster's exact value will differ slightly each reset.