Strudel · MilkDrop · GLSL · AI agents

Useless Knowledge, Concrete Hypnosis, and the AI Rave Machine

May 2026

For years I carried around a tiny constellation of supposedly useless knowledge: Strudel, a code-based real-time DAW for live coding music; MilkDrop, the nostalgic WinAmp visualizer that taught a whole generation what music could look like; and GLSL shaders, little programs that can turn math into liquid neon architecture.

None of that knowledge had an obvious job. It sat there like strange pocket lint from different eras of the internet. Then AI agents became capable enough to take a human prompt, a vibe, a pile of half-remembered references, and turn it into a working browser instrument.

The trick was not knowing one useful thing. The trick was letting three useless things recognize each other.

So this happened: Strudel generates a slow industrial techno ritual, full of flanged metal, rumble, arps, fake-outs, and drops. A MilkDrop-inspired WebGL shader listens to the analyzer data and answers back. Bass pressure folds the tunnel. Hats throw sparks into the edges. The arpeggiator pulls color through the feedback buffer until the browser starts behaving like a small illegal rave.

And the beautiful part is not that the AI "made it alone." It did not. The human taste mattered. The useless knowledge mattered. The prompt mattered. The agent just became the missing bridge between all these fragments, fast enough to let curiosity stay hot while the thing was still forming.

That, to me, is the interesting promise of AI-assisted creation: not replacing the weird human archive, but finally giving it hands. The trivia, the childhood software nostalgia, the shader tabs, the musical instincts, the "wouldn't it be sick if..." impulses. Suddenly they can be assembled into something other people can open, hear, and watch.

Try the artifact

Launch the generated rave

Open the Strudel MilkDrop Studio, start the visualizer, then use the code drawer if you want to paste the full Triptris Concrete Hypnosis performance below. Keep the volume sensible: distortion plus delay feedback gets spicy.

Open Strudel MilkDrop Studio More experiments

Here is the Strudel source at the center of the ritual. It is less a song than a little procedural machine room: patterns, effects, sections, tension, release, and enough hypnotic repetition to make the shader feel alive.

Full Strudel source: Triptris Concrete Hypnosis

// ✦ TRIPTRIS CONCRETE HYPNOSIS ✦
// Slow industrial techno, trippy phase/flange movement, arps, fake-outs, big drops.
// Paste into Strudel, Ctrl+Enter.
// Keep the volume sensible: distortion + delay feedback can get spicy.

setcpm(122/4)


// ───────────────────────── GLOBAL “FLANGER-ISH” CHAINS ─────────────────────────
// Strudel has documented phaser/delay rather than a named flanger.
// These chains make metallic, slow-sweeping, comb-ish movement.

const flange = pat => pat
  .phaser("<.07 .11 .17 .23>/8")
  .phaserdepth("<.85 .95 .7 1>/8")
  .phasercenter(sine.range(280, 1900).slow(16))
  .phasersweep(sine.range(700, 3900).slow(12))
  .delay(.19)
  .delaytime("<.018 .024 .013 .031>/4")
  .delayfeedback("<.34 .48 .42 .56>/8")
  .juxBy(.42, rev)

const deepFlange = pat => pat
  .phaser("<.025 .04 .065>/12")
  .phaserdepth(.9)
  .phasercenter(sine.range(160, 900).slow(24))
  .phasersweep(sine.range(500, 2600).slow(18))
  .delay(.12)
  .delaytime("<.028 .019 .034 .022>/8")
  .delayfeedback(.38)
  .juxBy(.28, rev)


// ───────────────────────── OOMPH / RUMBLE ─────────────────────────

const kick = s("bd*4")
  .bank("RolandTR909")
  .n("1")
  .gain(1.32)
  .decay(.48)
  .distort("3.4:.53")
  .duckorbit("3:4:5:6:7:8:9")
  .duckattack(".22:.28:.2:.24:.18:.14:.2")
  .duckdepth(".92:.78:.72:.68:.55:.5:.62")
  .orbit(1)

const lowGhost = s("~ bd ~ [~ bd]")
  .bank("RolandTR909")
  .n("2")
  .gain(.13)
  .decay(.13)
  .distort("2:.35")
  .orbit(1)

const rumble = s("bd ~ ~ ~")
  .bank("RolandTR909")
  .speed(.42)
  .decay(2.8)
  .room(.82)
  .delay(.42)
  .delaytime(.375)
  .delayfeedback(.68)
  .lpf(115)
  .distort("1.8:.34")
  .gain(.36)
  .orbit(3)

const sub = n("0 ~ 0 ~ <0 -2> ~ 3 ~")
  .scale("E1:minor")
  .s("sine")
  .legato(.85)
  .lpf(85)
  .distort("1.2:.18")
  .gain(.5)
  .orbit(4)

const tightDropKickLayer = s("bd*4")
  .bank("RolandTR909")
  .n("1")
  .gain(.28)
  .decay(.07)
  .distort("6:.25")
  .orbit(1)


// ───────────────────────── METAL / HATS / MACHINE ROOM ─────────────────────────

const hats = stack(
  s("hh ~ ~ hh")
    .bank("RolandTR909")
    .gain(".17 .08 .13 .1")
    .hpf(5600)
    .pan("<.43 .57>")
    .orbit(8),

  s("~ oh ~ oh")
    .bank("RolandTR909")
    .gain(.19)
    .end(.18)
    .hpf(5200)
    .room(.22)
    .orbit(8)
)

const metal = stack(
  flange(
    s("~ rim ~ [rim ~]")
      .bank("RolandTR909")
      .speed("<.5 .75 .5 1>/2")
      .gain(.32)
      .hpf(1500)
      .crush("<9 7 6 8>")
      .room(.46)
      .orbit(5)
  ),

  flange(
    s("~ ~ cp ~")
      .bank("RolandTR909")
      .gain(.38)
      .decay(.16)
      .hpf(780)
      .room(.74)
      .orbit(2)
  ),

  s("~ sd ~ ~")
    .bank("RolandTR909")
    .gain(.2)
    .decay(.07)
    .hpf(950)
    .distort("2.4:.35")
    .room(.28)
    .orbit(2)
)

const rideGhost = flange(
  s("~ ~ rd ~")
    .bank("RolandTR909")
    .gain(.14)
    .hpf(3600)
    .crush(10)
    .room(.4)
    .orbit(8)
)


// ───────────────────────── COLD SYNTH PRESSURE ─────────────────────────

const drone = deepFlange(
  note("<e1 e1 d1 e1>/8")
    .s("sawtooth")
    .attack(.45)
    .release(4.2)
    .lpf(sine.range(120, 460).slow(16))
    .lpq(11)
    .distort("2.2:.3")
    .room(.78)
    .gain(.28)
    .orbit(4)
)

const pressureStab = flange(
  note("<e2 ~ ~ [g2 e2]>/2")
    .s("<square sawtooth>")
    .attack(.008)
    .release(.45)
    .lpf("<440 620 390 760>")
    .lpq(9)
    .distort("2.7:.36")
    .room(.62)
    .gain(.34)
    .orbit(5)
)

const acidPulse = flange(
  n("<0 ~ 7 ~ 3 ~ 5 ~>/2")
    .scale("E2:minor")
    .s("sawtooth")
    .attack(.002)
    .decay(.085)
    .sustain(0)
    .release(.055)
    .lpf(sine.range(260, 1250).slow(12))
    .lpq("<7 11 9 13>")
    .distort("2.1:.38")
    .gain(.24)
    .orbit(6)
)


// ───────────────────────── ARPEGGIATOR HYPNOSIS ─────────────────────────

const chordArp = flange(
  chord("<Em9 C^9 D6 Bm7>/4")
    .dict('ireal')
    .voicing()
    .arp("0 [2 1] [3 0] 2 <1 3> [0 2] ~ [3 1]")
    .s("sawtooth")
    .attack(.005)
    .release(.2)
    .lpf(sine.range(420, 2300).slow(8))
    .lpq(10)
    .distort("1.5:.34")
    .gain(.23)
    .orbit(6)
)

const liquidArp = flange(
  n("0 7 12 7 3 10 12 15 12 7 3 0 5 12 10 7")
    .scale("E3:minor")
    .s("triangle")
    .attack(.001)
    .decay(.045)
    .sustain(0)
    .release(.07)
    .lpf(sine.range(800, 4200).slow(16))
    .gain("<.05 .09 .04 .12>*2")
    .pan(sine.slow(6))
    .mask("<0 1 1 1>/4")
    .orbit(7)
)

const glassNeedles = flange(
  n("<12 19 24 19 15 12 10 7>/2")
    .scale("E4:minor")
    .s("sine")
    .attack(.001)
    .decay(.035)
    .sustain(0)
    .release(.045)
    .penv("<7 -5 12 -12>")
    .pdecay(.05)
    .gain(.08)
    .pan("<0 1 .25 .75>")
    .mask("<0 0 1 1 0 1 0 1>/8")
    .orbit(9)
)


// ───────────────────────── AIR / RISERS / DROP CUES ─────────────────────────

const concreteAir = s("white*4")
  .decay("<.04 .08 .03 .12>")
  .sustain(0)
  .hpf(4200)
  .crush("<12 9 7 10>")
  .room(.85)
  .gain(".035 .055 .025 .065")
  .pan("<0 .3 .7 1>")
  .orbit(8)

const riser = flange(
  note("<e2 b2 e3 b3>*4")
    .s("sawtooth")
    .attack("<.02 .01>")
    .release(.18)
    .penv("<0 7 12 19>*2")
    .pdecay(.55)
    .lpf(sine.range(300, 9000).slow(8))
    .room(.82)
    .gain(.13)
    .orbit(9)
)

const snareRoll = s("<~ ~ ~ [sd*4] ~ ~ [sd*8] [sd*16]>")
  .bank("RolandTR909")
  .gain("<.08 .12 .18 .34>")
  .hpf(1000)
  .room(.65)
  .crush("<12 10 8 7>")
  .orbit(2)

const dropImpact = stack(
  s("bd:3")
    .bank("RolandTR909")
    .speed(.45)
    .decay(2.4)
    .gain(.7)
    .distort("3.5:.42")
    .lpf(240)
    .room(.85)
    .mask("<1 0 0 0 0 0 0 0>/8")
    .orbit(1),

  s("cr")
    .bank("RolandTR909")
    .speed(.35)
    .gain(.34)
    .room(1)
    .hpf(2500)
    .mask("<1 0 0 0>/4")
    .orbit(8)
)


// ───────────────────────── SECTION MACROS ─────────────────────────

const foundation = stack(
  kick,
  lowGhost,
  rumble,
  sub
)

const machineRoom = stack(
  foundation,
  hats,
  metal,
  drone,
  concreteAir
)

const buildA = stack(
  kick.gain(.52).mask("<1 1 1 0>/4"),
  rumble.gain(.24),
  sub.gain(.32),
  hats,
  metal,
  drone,
  pressureStab.gain(.22),
  chordArp.gain(.18),
  liquidArp.gain(.18),
  snareRoll,
  riser.gain(.48),
  concreteAir.gain(.55)
)

const vacuumDrop = stack(
  // No main kick here: just suction, air, and the last metallic cough.
  rumble.gain(.16).lpf(90),
  drone.gain(.36).lpf(300),
  riser.gain(.72).hpf(850),
  chordArp.gain(.33).hpf(900),
  liquidArp.gain(.24).hpf(1300),
  concreteAir.gain(.9),

  s("~ ~ ~ [bd bd]")
    .bank("RolandTR909")
    .gain(.16)
    .decay(.06)
    .distort("7:.2")
    .orbit(1),

  s("~ ~ ~ cr")
    .bank("RolandTR909")
    .speed(.25)
    .gain(.28)
    .room(1)
    .orbit(8)
)

const dropOne = stack(
  foundation,
  hats,
  metal,
  rideGhost,
  drone,
  pressureStab,
  acidPulse,
  chordArp,
  concreteAir,
  dropImpact
)

const strippedTunnel = stack(
  rumble.gain(.36),
  sub.gain(.28),
  drone.gain(.42),
  pressureStab.gain(.2).slow(2),
  acidPulse.gain(.16),
  chordArp.gain(.15).hpf(700),
  concreteAir.gain(.45),

  flange(
    s("~ ~ cp ~")
      .bank("RolandTR909")
      .gain(.18)
      .room(.95)
      .delay(.32)
      .delaytime(.75)
      .delayfeedback(.48)
      .orbit(2)
  )
)

const buildB = stack(
  kick.gain(.38).mask("<1 1 0 0>/4"),
  rumble.gain(.22),
  sub.gain(.28),
  hats.gain(.7),
  metal,
  rideGhost,
  pressureStab.gain(.36),
  acidPulse.gain(.28),
  chordArp.gain(.34),
  liquidArp.gain(.28),
  glassNeedles.gain(.7),
  snareRoll.gain(1.25),
  riser.gain(.85),
  concreteAir.gain(.8)
)

const fakeDrop = stack(
  // Four bars of “where did the floor go?”
  drone.gain(.55).lpf(240),
  riser.gain(.5).hpf(1500),
  liquidArp.gain(.35).hpf(1700),
  glassNeedles.gain(.55),
  concreteAir.gain(1.1),

  s("~ ~ ~ [rim rim]")
    .bank("RolandTR909")
    .gain(.2)
    .hpf(2300)
    .crush(6)
    .room(.8)
    .orbit(5)
)

const megaDrop = stack(
  dropOne,
  tightDropKickLayer,
  liquidArp,
  glassNeedles,
  acidPulse.gain(.34),
  chordArp.gain(.3),

  flange(
    s("~ rim ~ [~ rim]")
      .bank("RolandTR909")
      .speed(.5)
      .gain(.19)
      .hpf(2300)
      .crush(6)
      .room(.68)
      .orbit(5)
  ),

  s("~ ~ ~ [sd*8]")
    .bank("RolandTR909")
    .gain(.16)
    .hpf(1200)
    .room(.6)
    .lastOf(8, x => x.fast(2))
    .orbit(2)
)


// ───────────────────────── FULL ARRANGEMENT ─────────────────────────

arrange(
  [12, stack(rumble, drone, concreteAir)],
  [16, machineRoom],
  [8, buildA],
  [4, vacuumDrop],
  [32, dropOne],

  [16, strippedTunnel],
  [8, buildB],
  [4, fakeDrop],
  [40, megaDrop]
)
  .compressor("-20:16:10:.006:.09")
  .postgain(.68)

This is the kind of thing I want trippy.ch to keep becoming: a place where curiosity, code, sound, shaders, games, and AI collaboration are allowed to meet without first proving they are practical. Sometimes useless knowledge is just knowledge that has not found its dance floor yet.