Strata

1 · Wat het is, in één alinea

Een seed van 32 bits bepaalt een genoom: toonsoort, modus, tempo, luslengtes, ritmecel, CA-regel, FM-timbres, en welke parameters op welk vlak liggen. Vanuit dat genoom draait een klok die generatoren aanstuurt; elke acht maten muteert precies één gen. De gebruiker heeft vier vlakken die per generatie een andere parameter kunnen sturen — behalve de vlakken die hij heeft vastgezet. Alles is deterministisch: seed plus actielog reconstrueert de sessie noot voor noot.

2 · Architectuur als kolom

Van bedrock naar oppervlak. Elke laag kent alleen de laag eronder. Geen laag mag omhoog reiken — dat is de regel die het systeem testbaar houdt.

3 · Het besturingsmodel

Dit is de kern van het ontwerp en het punt waarop Strata verschilt van elke andere generatieve app: het vlak is het instrument, niet de parameter. Er zijn altijd vier slots. Een slot houdt een handle vast. Bij elke generatie mag het systeem een slot herbinden aan een andere handle uit de pool. Wat de gebruiker vasthoudt, blijft.

De drie objecten

Handle = {
  id, label, sub,          // 'dichtheid', 'noten / stap'
  get(g), set(g, v),       // leest/schrijft genoom, altijd 0..1
  curve: 'lin'|'exp'|'step', steps?: n,
  affinity: ['continu','bipolair'],   // welke gebaren passen
  weight: 1.0              // fitness, groeit door vasthouden
}

Slot = { index: 0..3, handle, value, latched, range, touchedAt }

Intent = { slot, kind, amount?, axis? }
  kind ∈ tap | doubletap | hold | drag | flick | pinch | tilt | shake

Gebaar → intentie → effect

Herbinden bij generatie

rebind(slots, pool, rng):
  kandidaten = slots.filter(s => !s.latched
                             && now - s.touchedAt > 45_000)   // niet net aangeraakt
  if kandidaten.length === 0 or rng() > 0.35: return       // 35% kans per generatie
  slot = pick(kandidaten)
  vrij = pool.filter(h => !slots.some(s => s.handle.id === h.id))
  nieuw = weightedPick(vrij, h => h.weight)               // fitness stuurt de keuze
  // crossfade: oude handle houdt 2 maten zijn waarde vast,
  // nieuwe handle start op zijn huidige genoomwaarde => geen sprong
  slot.handle = nieuw; slot.value = nieuw.get(genome)
  log('rebind', slot.index, oud.id, nieuw.id)

Handle-pool bij oplevering F2

Tien handles, vier slots: op elk moment is 60% van het systeem autonoom. Dat is het punt — je stuurt bij, je bestuurt niet.

4 · Evolutie

Twee snelheden. De trage snelheid is hoorbaar als beweging, de snelle als leven.

Mutatietabel

Fitness

hold  op slot s  →  s.handle.weight *= 1.35   // dit wil ik houden
flick op slot s  →  s.handle.weight *= 0.75   // weg ermee
elke generatie   →  weight = 1 + (weight-1)*0.98   // vergeet langzaam

weight bepaalt: (a) kans dat de handle wordt gekozen bij rebind,
                (b) kans dat het gen eronder muteert (hoog gewicht = met rust laten)

Geen expliciete "vind je dit mooi"-knop. De bediening zelf ís het fitnesssignaal — vasthouden is goedkeuren, weggooien is afkeuren.

5 · Het strata-log

Elke generatie schrijft één regel. Dat log is tegelijk archief, debugger en reproductie-instructie. Bij 74 bpm duurt een generatie 26 seconden, dus een uur levert ongeveer 140 regels op: circa 4 kB, plus de gebruikersacties.

{ s: "e5212af7",        // seed, hex
  t0: 1757462400,        // starttijd unix
  g: [                   // per generatie: [maat, mutatiecode, waarde]
    [8,  'er', +1], [16, 'mk', 3], [24, 'tn', 'L'], [32, 'ek', -1], ...
  ],
  u: [                   // gebruikersacties: [maat.tick, slot, intent, waarde]
    [12.3, 0, 'd', 0.62], [19.0, 2, 'h', 1], [27.5, 1, 'f', 0.11], ...
  ] }

6 · Audiograaf

                                    ┌─ reverb (procedurele IR, 2.2 s) ─┐
voice ──▶ filter ──▶ gain ──▶ pan ──┼─ delay (3/16, fb 0.35) ─────────┼──▶ bus ──▶ comp ──▶ out
  (wegwerp, max 24)                 └─ dry ───────────────────────────┘        │
                                                                        analyser ──▶ viz

7 · Bestandsstructuur

strata/
├─ index.html            // shell, manifest-link, één script-entry
├─ sw.js                 // service worker: offline cache
├─ manifest.webmanifest
├─ core/
│  ├─ rng.js             mulberry32, sub(seed,salt), fnv1a
│  ├─ genome.js          fromSeed(s), mutate(g,rng), serialize/parse
│  ├─ clock.js           Worker-tik, lookahead, onTick(from,to)
│  └─ worker-clock.js
├─ gen/
│  ├─ euclid.js          bjorklund(k,n), rotate
│  ├─ markov.js          matrix(n,rng), next(m,i,rng), reroll(m,i)
│  ├─ ca.js              step(cells,rule)
│  ├─ phase.js           coprime loops, advance
│  └─ walk.js            perlin1d(seed), octaves
├─ harmony/
│  ├─ scale.js           MODES, degToMidi(g,deg,oct)
│  ├─ tonnetz.js         P, L, R, distanceFromHome
│  └─ krumhansl.js       PROFILES, weight(pc,key,tension)
├─ synth/
│  ├─ graph.js           buildGraph(ac) → {bus,verb,delay,analyser}
│  ├─ voices.js          pool, alloc, steal
│  ├─ fm.js  ks.js  noise.js  grain.js
│  └─ space.js           procedurele IR
├─ mod/
│  ├─ drift.js           apply(genome, t)
│  └─ evolve.js          tick(genome, rng, fitness) → mutation
├─ ctl/
│  ├─ gestures.js        pointer → Intent (geen kennis van muziek)
│  ├─ handles.js         POOL: Handle[]
│  ├─ slots.js           Slot[4], apply(intent), rebind()
│  └─ fitness.js
├─ io/
│  ├─ persist.js         localStorage: seed, gen, slots, log
│  ├─ strata.js          log schrijven/lezen, permalink
│  ├─ render.js          OfflineAudioContext → WAV
│  └─ bridge.js          WebSocket → NEXUS (OSC-vorm)
└─ ui/
   ├─ app.js  pads.js  viz.js  hud.js

Geen framework, geen bundler in F1–F3. ES-modules native; Safari doet dat prima. Een bundler komt pas als het worklet-bestand erbij komt (F4).

8 · iOS-schil

9 · Fasering

10 · Waar dit misgaat

1. Grijze soep. Eindeloze evolutie zonder anker convergeert naar textuur zonder karakter. Het thuis-anker en de mutatie-beperkingen zijn de tegenmaatregel — als het na F2 alsnog vervlakt, is de volgende stap terugkerende secties (A/B met een 64-maats vorm), niet meer mutatiesoorten.
2. Bediening die niets doet. Vier knoppen op tien parameters betekent dat je zes parameters nooit aanraakt. Het gebarenlog uit het harnas moet dat aantonen vóór F2; blijkt het dat je maar twee gebaren gebruikt, dan snoeien we de pool in plaats van hem uit te breiden.
3. Determinisme lekt. Eén vergeten Math.random() of één floating-point-verschil tussen toestellen breekt reproductie. De ESLint-regel dekt het eerste; het tweede is in de praktijk geen probleem zolang alle DSP-parameters via de graaf lopen en niet via handmatige sample-berekening.
4. AirPods. 150–250 ms latentie maakt tikken-op-de-beat onbruikbaar. Strata is geen instrument dat je bespeelt op de tel — het is een systeem dat je bijstuurt. Dat is een ontwerpbesluit, geen tekortkoming: geen enkele handle is tijdkritisch.
5. Scope. F4 (granulair archief) en F7 (NEXUS-brug) zijn de twee fases die het meest verleiden en het minst opleveren zolang F2 niet af is. Ze staan bewust achteraan.

11 · Wat alleen jij nog kunt

Alles wat mechaniek is, is gebouwd en gemeten. Wat overblijft, vraagt oren, een toestel of een laptop.

1. Luisteren. Klinkt het als iets? Elke klankbeslissing hierboven is zonder oren genomen.
2. Probe op iPhone en AirPods in het Perpetuum Harnas — latentie.
3. 20 minuten spelen, Log en Sessie opslaan. Dan kan ik de handle-pool snoeien op wat je echt gebruikt in plaats van te gokken.
4. Eigen opnames laden via "Sample laden" — de korrellaag op jouw archief.
5. NEXUS aanzetten en de brug op het echte adres testen.
6. Bank doorlopen — hoofdstuk H eerst, dat zijn de stukken.

12 · Strata als module

Drie artifacts en een repo zijn geen onderdeel; een contract wel. Dit is wat Strata naar buiten toe is, zodat het als één blok in de rest van het systeem past.

Waar het inplugt

Wat het nu nog niet één onderdeel maakt: drie losse artifact-adressen en een PWA die nergens gehost is. De repo lost dat op.