Loom

a pattern language for drawing

cps 0.60 decay 1.5

cycle 0 staticvoid.studio

edit the pattern · ⌘⏎ to run

mini-notation (inside "…")

"a b c d"

sequence — splits the cycle evenly

"a [b c]"

subdivide a step

"<a b c>"

one per cycle (alternate)

"a*3" "a/2"

speed up / slow down a step

"a!3" "a@3 b"

replicate · weight (a takes ¾)

"a(3,8)" "a(3,8,2)"

euclid (pulses, steps, rotation)

"a , b"

stack in parallel · ~ = rest

"a | b | c"

random choice each cycle

"{a b c}%4"

polymeter — n steps/cycle

sources

shape("circle*8")

emit glyphs (alias s)

n("0 1 2")

numbered dots · run(8) = 0…7

bg("#101820")

set the canvas background — stack it in

shapes: dot circle ring arc square box tri pent hex star plus line cross

controls (chain onto a source)

.color("#ff5d73" | "red" | 0..1) .color(palette("#a","#b","#c").at(x))

interpolate a palette by x (number · pattern · osc)

.size(0.06)

radius, fraction of min(w,h)

.x(0..1) .y(0..1)

centre point (default screen centre)

.radius(0..0.5) .angle(turns)

polar offset from the centre — combine with x/y to orbit a point. angle defaults to onset phase; .angle(saw.range(0,5)) winds a spiral

.grid(cols, rows)

lay events into a grid by onset

.rotate(turns) .spin(turns/s)

Z spin · 1 = full turn

.rotateX(turns) .rotateY(turns)

3D tilt (foreshorten)

.fill(1|0) .stroke(1|0) .vertex(1|0)

draw modes — independent & patternable. .fill(0).vertex() = dots only

.weight(0..0.1)

stroke / line / vertex-dot size

.cap("round"|"butt"|"square")

line ends

.join("round"|"miter"|"bevel")

corners

.open(0..1)

arc/ring gap (use shape arc)

.alpha(0..1) .opacity(0..1) .pan(0..1) .jitter(0..0.1) .attack(s) .decay(s)

fade-in / fade-out (s alias .life)

.blend("source-over"|"screen"|"lighter"|"multiply")

transforms

.fast(n) .slow(n) .rev() .every(n, p => …) .iter(n) .palindrome() .jux(p => p.rev())

split a transformed copy left/right

.off(t, p => …)

echo, shifted by t cycles

.degrade() .sometimes(p=>…) .often(…) .rarely(…) stack(…) cat(…) seq(…) fastcat(…) group(pat).pixelate(n)

render a layer to its own buffer + apply an effect (pixelate so far)

signals & maths (0..1 unless ranged)

sine cosine saw isaw tri square rand perlin fbm brown gauss

noise: white · smooth · fractal · red · bell

choose("a","b") irand(8)

random pick / integer per onset

osc(rate, "sine").range(lo, hi)

live LFO — keeps moving over a glyph's life (vs signals, frozen at spawn). shapes: sine saw tri square rand perlin fbm

osc(…).spread(n)

per-glyph phase offset = n × onset phase — spreads the wave around a ring/grid instead of every glyph in lockstep

osc(2).rate(osc(0.1).range(1,4))

any osc param (rate · phase · range) can itself be an osc → cross-modulation (FM · PM · AM)

.x(osc(0.2, "perlin").range(0, 1))

← a wandering dot

.range(lo, hi)

remap a 0..1 signal — lo/hi may be numbers, patterns, or oscs

.add(x) .sub(x) .mul(x) .div(x)

x may be a number or a pattern

.x( saw.add(sine.range(0, 0.1)) )

← wobble a ramp by a sine

palettes (named ramps)

palette("sunset").at(saw.range(0,1))

sunset · ember · ice · neon · forest · candy · mono · rainbow · aurora