sonic-forge 0.1.0__tar.gz

sonic_forge-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Audio (generated on demand)
+*.wav
+*.aiff
+*.mp3
+*.ogg
+
+# Models (downloaded on first use)
+*.onnx
+*.bin
+*.safetensors
+kokoro-models/
+chattts-assets/
+
+# Python
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+
+# Node
+node_modules/
+
+# OS
+.DS_Store

sonic_forge-0.1.0/MANIFEST.md

@@ -0,0 +1,14 @@
+# MATERIALS-BAY: sonic-forge
+
+**Created:** 2026-03-11 15:12
+**Source labs:** pattern-engine, chuck-music, strudel-node, bytebeat-dj.sh, sound-demo-tour.sh, bytebeat-rating.md, sound-rating.md
+
+## Contents
+
+- **pattern-engine/** — from `LABS/pattern-engine/`
+- **chuck-music/** — from `LABS/chuck-music/`
+- **strudel-node/** — from `LABS/strudel-node/`
+- **bytebeat-dj.sh/** — from `LABS/bytebeat-dj.sh/`
+- **sound-demo-tour.sh/** — from `LABS/sound-demo-tour.sh/`
+- **bytebeat-rating.md/** — from `LABS/bytebeat-rating.md/`
+- **sound-rating.md/** — from `LABS/sound-rating.md/`

sonic_forge-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: sonic-forge
+Version: 0.1.0
+Summary: Bytebeat music DSL + multi-engine TTS voice system — beamed from starforge
+Requires-Python: >=3.10
+Requires-Dist: pyyaml
+Requires-Dist: typer
+Provides-Extra: all
+Requires-Dist: f5-tts-mlx; extra == 'all'
+Requires-Dist: kokoro-onnx; extra == 'all'
+Requires-Dist: numpy; extra == 'all'
+Requires-Dist: onnxruntime; extra == 'all'
+Requires-Dist: soundfile; extra == 'all'
+Provides-Extra: kokoro
+Requires-Dist: kokoro-onnx; extra == 'kokoro'
+Requires-Dist: numpy; extra == 'kokoro'
+Requires-Dist: onnxruntime; extra == 'kokoro'
+Requires-Dist: soundfile; extra == 'kokoro'
+Provides-Extra: robot
+Requires-Dist: numpy; extra == 'robot'
+Requires-Dist: soundfile; extra == 'robot'
+Provides-Extra: tts
+Requires-Dist: f5-tts-mlx; extra == 'tts'
+Requires-Dist: kokoro-onnx; extra == 'tts'
+Requires-Dist: numpy; extra == 'tts'
+Requires-Dist: onnxruntime; extra == 'tts'
+Requires-Dist: soundfile; extra == 'tts'

sonic_forge-0.1.0/bytebeat-dj.sh

@@ -0,0 +1,256 @@
+#!/bin/bash
+# Bytebeat DJ — interactive player with speed, volume, and track controls
+# Writes Python to temp file so curses gets proper terminal access
+
+VENV_PYTHON="/Users/t/clients/starship/starforge/venv/bin/python"
+
+# Clean up any stale temp files, then create fresh one
+rm -f /tmp/bytebeat_dj_*.py
+TMPSCRIPT="/tmp/bytebeat_dj_$$.py"
+
+cat > "$TMPSCRIPT" << 'PYEOF'
+import wave, curses, subprocess, os, sys, time, threading
+
+TRACKS = [
+    ("classic",    "t*(t>>8|t>>9)&46&t>>8^(t&t>>13|t>>6)",
+     lambda t: (t*(((t>>12)|(t>>8)))&(46&(t>>8)))^((t&(t>>13))|(t>>6))),
+    ("melody",     "t*((t>>9)|(t>>13))&16",
+     lambda t: t*((t>>9)|(t>>13))&16),
+    ("bass",       "t&(t>>8)",
+     lambda t: t&(t>>8)),
+    ("rhythm",     "(t*(t>>5|t>>8))>>(t>>16)",
+     lambda t: (t*((t>>5)|(t>>8)))>>(t>>16) if (t>>16) < 32 else 0),
+    ("chaos",      "(t*5&t>>7)|(t*3&t>>10)",
+     lambda t: (t*5&(t>>7))|(t*3&(t>>10))),
+    ("crowd",      "(t<<1)^((t<<1)+(t>>7)&t>>12)|t>>7",
+     lambda t: ((t<<1)^((t<<1)+(t>>7)&t>>12))|t>>(4-(1^7&(t>>19)))|t>>7),
+    ("sierpinski", "t&t>>8",
+     lambda t: t&t>>8),
+    ("42melody",   "t*(42&t>>10)",
+     lambda t: (t*(42&t>>10))&255),
+    ("glitch",     "t*((t>>12|t>>8)&63&t>>4)",
+     lambda t: t*((t>>12|t>>8)&63&t>>4)),
+    ("cathedral",  "(t>>6|t|t>>(t>>16))*10+((t>>11)&7)",
+     lambda t: (t>>6|t|t>>(t>>16))*10+((t>>11)&7)),
+    ("gameboy",    "t*9&t>>4|t*5&t>>7|t*3&t>>10",
+     lambda t: (t*9&t>>4|t*5&t>>7|t*3&t>>10)-1),
+    ("underwater", "(t*(t>>5|t>>8))>>(t>>16)",
+     lambda t: (t*(t>>5|t>>8))>>(t>>16)),
+    ("alien",      "t*(((t>>9)^((t>>9)-1)^1)%13)",
+     lambda t: t*(((t>>9)^((t>>9)-1)^1)%13)),
+]
+
+SPEEDS = [
+    (2000,  "0.25x"), (3000,  "0.38x"), (4000,  "0.5x"),
+    (5000,  "0.63x"), (6000,  "0.75x"), (7000,  "0.88x"),
+    (8000,  "1.0x"),  (9000,  "1.13x"), (10000, "1.25x"),
+    (12000, "1.5x"),  (14000, "1.75x"), (16000, "2.0x"),
+    (20000, "2.5x"),  (24000, "3.0x"),  (32000, "4.0x"),
+]
+
+current_track = 0
+speed_idx = 6
+volume = 0.5
+afplay_proc = None
+generating = False
+WAV_PATH = "/tmp/bytebeat_dj.wav"
+DURATION = 600  # 10 minutes — bytebeat is infinite math, let it ride
+
+def generate_wav(track_idx, rate):
+    global generating
+    generating = True
+    name, _, func = TRACKS[track_idx]
+    samples = rate * DURATION
+    with wave.open(WAV_PATH, 'w') as f:
+        f.setnchannels(1)
+        f.setsampwidth(1)
+        f.setframerate(rate)
+        buf = bytearray(samples)
+        for t in range(samples):
+            try:
+                buf[t] = func(t) & 255
+            except:
+                buf[t] = 128
+        f.writeframes(bytes(buf))
+    generating = False
+
+def kill_player():
+    global afplay_proc
+    if afplay_proc and afplay_proc.poll() is None:
+        afplay_proc.terminate()
+        try:
+            afplay_proc.wait(timeout=1)
+        except:
+            afplay_proc.kill()
+    afplay_proc = None
+
+def start_playback():
+    global afplay_proc
+    kill_player()
+    generate_wav(current_track, SPEEDS[speed_idx][0])
+    afplay_proc = subprocess.Popen(
+        ["afplay", "-v", str(volume), WAV_PATH],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+
+def adjust_volume():
+    """Restart playback with new volume (no regeneration needed)."""
+    global afplay_proc
+    kill_player()
+    if os.path.exists(WAV_PATH):
+        afplay_proc = subprocess.Popen(
+            ["afplay", "-v", str(volume), WAV_PATH],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+
+def main(stdscr):
+    global current_track, speed_idx, volume, afplay_proc
+
+    curses.curs_set(0)
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(1, curses.COLOR_YELLOW, -1)
+    curses.init_pair(2, curses.COLOR_CYAN, -1)
+    curses.init_pair(3, curses.COLOR_GREEN, -1)
+    curses.init_pair(4, curses.COLOR_RED, -1)
+    curses.init_pair(5, curses.COLOR_MAGENTA, -1)
+    curses.init_pair(6, curses.COLOR_WHITE, -1)
+
+    stdscr.nodelay(True)
+    stdscr.keypad(True)
+
+    start_playback()
+
+    while True:
+        stdscr.erase()
+        h, w = stdscr.getmaxyx()
+        name, formula_str, _ = TRACKS[current_track]
+        rate, slabel = SPEEDS[speed_idx]
+
+        # Title
+        title = " BYTEBEAT DJ "
+        cx = max(0, (w - len(title)) // 2)
+        try:
+            stdscr.addstr(1, cx, title, curses.A_BOLD | curses.color_pair(1))
+        except curses.error:
+            pass
+
+        def safe_add(y, x, text, attr=0):
+            try:
+                if y < h - 1 and x < w:
+                    stdscr.addstr(y, x, text[:w-x-1], attr)
+            except curses.error:
+                pass
+
+        y = 3
+        safe_add(y, 2, f"Track {current_track+1}/{len(TRACKS)}", curses.color_pair(2))
+        y += 1
+        safe_add(y, 4, name, curses.A_BOLD | curses.color_pair(3))
+        y += 1
+        fdisp = formula_str if len(formula_str) < w - 8 else formula_str[:w-11] + "..."
+        safe_add(y, 4, fdisp, curses.color_pair(6))
+
+        # Speed bar
+        y += 2
+        bar_w = min(30, w - 25)
+        if bar_w > 5:
+            safe_add(y, 2, "Speed:", curses.color_pair(5))
+            pos = int((speed_idx / max(1, len(SPEEDS)-1)) * bar_w)
+            bar = "[" + "=" * pos + "O" + "-" * (bar_w - pos) + "]"
+            safe_add(y, 9, bar, curses.color_pair(5))
+            safe_add(y, 10 + bar_w, f" {slabel} ({rate}Hz)", curses.color_pair(6))
+
+        # Volume bar
+        y += 1
+        if bar_w > 5:
+            safe_add(y, 2, "Vol:  ", curses.color_pair(4))
+            vol_pos = int(min(1.0, volume) * bar_w)
+            vol_bar = "[" + "=" * vol_pos + "O" + "-" * (bar_w - vol_pos) + "]"
+            safe_add(y, 9, vol_bar, curses.color_pair(4))
+            safe_add(y, 10 + bar_w, f" {int(volume*100)}%", curses.color_pair(6))
+
+        # Status
+        y += 2
+        playing = afplay_proc and afplay_proc.poll() is None
+        if generating:
+            safe_add(y, 4, "generating...", curses.color_pair(1))
+        elif playing:
+            tick = int(time.time() * 4) % 4
+            frames = ["♪ ♫  ", " ♪ ♫ ", "  ♪ ♫", " ♫ ♪ "]
+            safe_add(y, 4, f"{frames[tick]} PLAYING", curses.color_pair(3))
+        else:
+            safe_add(y, 4, "stopped — SPACE to play", curses.color_pair(4))
+
+        # Track list
+        y += 2
+        safe_add(y, 2, "Tracks:", curses.color_pair(2))
+        y += 1
+        for i, (tname, _, _) in enumerate(TRACKS):
+            if y >= h - 4:
+                break
+            marker = " >> " if i == current_track else "    "
+            attr = curses.A_BOLD | curses.color_pair(3) if i == current_track else curses.color_pair(6)
+            safe_add(y, 2, f"{marker}{i+1:2d}. {tname}", attr)
+            y += 1
+
+        # Controls
+        if h > 3:
+            safe_add(h-2, 2, "< > track   ^ v speed   +/- vol   SPACE restart   1-9 jump   q quit", curses.color_pair(6))
+
+        stdscr.refresh()
+
+        # Input — drain all pending keys, act on last meaningful one
+        key = -1
+        while True:
+            k = stdscr.getch()
+            if k == -1:
+                break
+            key = k
+
+        if key == -1:
+            time.sleep(0.05)
+            # Auto-loop if track ended
+            if not generating and afplay_proc and afplay_proc.poll() is not None:
+                start_playback()
+            continue
+
+        if key == ord('q') or key == ord('Q'):
+            kill_player()
+            break
+        elif key == curses.KEY_RIGHT or key == ord('l'):
+            current_track = (current_track + 1) % len(TRACKS)
+            start_playback()
+        elif key == curses.KEY_LEFT or key == ord('h'):
+            current_track = (current_track - 1) % len(TRACKS)
+            start_playback()
+        elif key == curses.KEY_UP or key == ord('k'):
+            if speed_idx < len(SPEEDS) - 1:
+                speed_idx += 1
+                start_playback()
+        elif key == curses.KEY_DOWN or key == ord('j'):
+            if speed_idx > 0:
+                speed_idx -= 1
+                start_playback()
+        elif key == ord('+') or key == ord('='):
+            volume = min(2.0, round(volume + 0.1, 1))
+            adjust_volume()
+        elif key == ord('-') or key == ord('_'):
+            volume = max(0.0, round(volume - 0.1, 1))
+            adjust_volume()
+        elif key == ord(' '):
+            start_playback()
+        elif ord('1') <= key <= ord('9'):
+            idx = key - ord('1')
+            if idx < len(TRACKS):
+                current_track = idx
+                start_playback()
+        elif key == ord('0'):
+            if len(TRACKS) > 9:
+                current_track = 9
+                start_playback()
+
+curses.wrapper(main)
+PYEOF
+
+exec "$VENV_PYTHON" "$TMPSCRIPT"
+rm -f "$TMPSCRIPT"

sonic_forge-0.1.0/bytebeat-rating.md

@@ -0,0 +1,7 @@
+# Bytebeat Rating — Mathematical Music Tour
+
+Each formula generates audio from pure math: `f(t)` where t is a sample counter.
+The output byte (0-255) IS the audio waveform. No instruments, no samples — just math.
+
+| # | Name | Formula | Like? | Volume (1-10) | Notes |
+|---|------|---------|-------|---------------|-------|

sonic_forge-0.1.0/chuck-music/cathedral-drift.ck

@@ -0,0 +1,123 @@
+// Starforge Cathedral Drift — deep reverb pads that slowly transform
+// Inspired by your love of the "cathedral" bytebeat formula
+// Run: chuck LABS/chuck-music/cathedral-drift.ck
+
+Gain master => NRev reverb => dac;
+0.15 => reverb.mix;  // heavy reverb for cathedral feel
+0.3 => master.gain;
+
+// === DRONE: low fundamental that shifts ===
+fun void drone() {
+    SawOsc saw1 => LPF filt => Gain droneGain => master;
+    SawOsc saw2 => filt;
+    0.06 => droneGain.gain;
+    300.0 => filt.freq;
+    4.0 => filt.Q;
+
+    [36, 38, 41, 43, 34, 31] @=> int roots[]; // deep roots
+    0 => int idx;
+
+    while (true) {
+        Std.mtof(roots[idx]) => float targetFreq;
+        saw1.freq() => float startFreq;
+        if (startFreq < 10.0) targetFreq => startFreq;
+
+        // Glacial glide to new note
+        for (0 => int i; i < 200; i++) {
+            startFreq + (targetFreq - startFreq) * (i / 200.0) => saw1.freq;
+            (startFreq + (targetFreq - startFreq) * (i / 200.0)) * 1.005 => saw2.freq;
+            25::ms => now;
+        }
+
+        // Hold
+        Math.random2(3000, 8000)::ms => now;
+
+        (idx + Math.random2(1, 3)) % roots.size() => idx;
+    }
+}
+
+// === BELLS: sine harmonics that ring and fade ===
+fun void bell(float freq, float vol, dur length) {
+    SinOsc s1 => Gain g => master;
+    SinOsc s2 => g;
+    SinOsc s3 => g;
+    freq => s1.freq;
+    freq * 2.756 => s2.freq;  // inharmonic partial (bell-like)
+    freq * 5.404 => s3.freq;  // higher inharmonic
+    vol => g.gain;
+
+    // Exponential decay
+    length / 50 => dur step;
+    for (0 => int i; i < 50; i++) {
+        vol * Math.pow(0.92, i $ float) => g.gain;
+        step => now;
+    }
+    0.0 => g.gain;
+}
+
+fun void bells() {
+    [60, 63, 67, 70, 72, 75, 79, 84] @=> int notes[];
+
+    while (true) {
+        // Sparse — sometimes play, sometimes rest
+        if (Math.random2f(0.0, 1.0) < 0.35) {
+            Math.random2(0, notes.size()-1) => int idx;
+            spork ~ bell(Std.mtof(notes[idx]),
+                        Math.random2f(0.02, 0.05),
+                        Math.random2(2000, 5000)::ms);
+        }
+        Math.random2(800, 3000)::ms => now;
+    }
+}
+
+// === MORE BELLS: second bell layer with different tuning ===
+fun void bellsLow() {
+    // Lower register bells with longer decay
+    [48, 51, 53, 55, 58, 60] @=> int notes[];
+
+    while (true) {
+        if (Math.random2f(0.0, 1.0) < 0.25) {
+            Math.random2(0, notes.size()-1) => int idx;
+            spork ~ bell(Std.mtof(notes[idx]),
+                        Math.random2f(0.015, 0.035),
+                        Math.random2(3000, 7000)::ms);
+        }
+        Math.random2(1500, 5000)::ms => now;
+    }
+}
+
+// === SUB PULSE: very deep, slow ===
+fun void subPulse() {
+    SinOsc sub => Gain subGain => master;
+    0.0 => subGain.gain;
+
+    [29, 31, 34, 36] @=> int notes[]; // very low
+    0 => int idx;
+
+    while (true) {
+        Std.mtof(notes[idx]) => sub.freq;
+
+        // Slow fade in/out
+        for (0 => int i; i < 60; i++) {
+            0.1 * Math.sin(Math.PI * i / 60.0) => subGain.gain;
+            50::ms => now;
+        }
+        0.0 => subGain.gain;
+
+        Math.random2(2000, 6000)::ms => now;
+        (idx + 1) % notes.size() => idx;
+    }
+}
+
+// === LAUNCH ===
+<<< "  Starforge Cathedral Drift", "" >>>;
+<<< "  Deep reverb ambient — slow transformation", "" >>>;
+<<< "  Ctrl-C to stop", "" >>>;
+<<< "" >>>;
+
+spork ~ drone();
+spork ~ bells();
+spork ~ bellsLow();
+spork ~ subPulse();
+
+while (true) 1::second => now;

sonic_forge-0.1.0/chuck-music/coding-ambient.ck

@@ -0,0 +1,186 @@
+// Starforge Coding Ambient — evolving generative music for terminal coding
+// Run: chuck LABS/chuck-music/coding-ambient.ck
+// Ctrl-C to stop
+
+// === MASTER OUTPUT ===
+Gain master => NRev reverb => dac;
+0.08 => reverb.mix;
+0.35 => master.gain;
+
+// === PAD: slow evolving chords ===
+fun void pad() {
+    // Pentatonic minor scale degrees (dark, spacey)
+    [48, 51, 53, 55, 58, 60, 63, 65, 67, 70] @=> int notes[];
+
+    // Two detuned oscillators for thickness
+    TriOsc p1 => LPF filt1 => Gain padGain => master;
+    TriOsc p2 => LPF filt2 => padGain;
+    0.12 => padGain.gain;
+    800.0 => filt1.freq;
+    750.0 => filt2.freq;
+    3.0 => filt1.Q;
+    3.0 => filt2.Q;
+
+    while (true) {
+        // Pick two notes for a chord
+        Math.random2(0, notes.size()-1) => int idx1;
+        (idx1 + Math.random2(2, 4)) % notes.size() => int idx2;
+
+        Std.mtof(notes[idx1]) => p1.freq;
+        Std.mtof(notes[idx2]) * 1.003 => p2.freq; // slight detune
+
+        // Slow filter sweep
+        Math.random2f(400.0, 1200.0) => float targetFreq;
+        filt1.freq() => float startFreq;
+        for (0 => int i; i < 100; i++) {
+            startFreq + (targetFreq - startFreq) * (i / 100.0) => filt1.freq;
+            startFreq + (targetFreq - startFreq) * (i / 100.0) * 0.95 => filt2.freq;
+            40::ms => now;
+        }
+        Math.random2(2000, 5000)::ms => now;
+    }
+}
+
+// === PULSE: rhythmic element, euclidean-inspired ===
+fun int[] bjorklund(int k, int n) {
+    // Euclidean rhythm generator
+    int result[n];
+    if (k >= n) {
+        for (0 => int i; i < n; i++) 1 => result[i];
+        return result;
+    }
+    if (k == 0) {
+        for (0 => int i; i < n; i++) 0 => result[i];
+        return result;
+    }
+
+    int pattern[n];
+    float bucket;
+    0.0 => bucket;
+    k $ float / n => float slope;
+    for (0 => int i; i < n; i++) {
+        bucket + slope => bucket;
+        if (bucket >= 1.0) {
+            1 => pattern[i];
+            bucket - 1.0 => bucket;
+        } else {
+            0 => pattern[i];
+        }
+    }
+    return pattern;
+}
+
+fun void pulse() {
+    SqrOsc sq => LPF filt => Gain pulseGain => master;
+    0.06 => pulseGain.gain;
+    2000.0 => filt.freq;
+    2.0 => filt.Q;
+
+    // Evolving euclidean parameters
+    3 => int k;
+    8 => int n;
+
+    [36, 38, 41, 43, 46] @=> int bassNotes[]; // low pentatonic
+    0 => int noteIdx;
+
+    0 => int cycleCount;
+
+    while (true) {
+        bjorklund(k, n) @=> int rhythm[];
+
+        for (0 => int i; i < rhythm.size(); i++) {
+            if (rhythm[i]) {
+                Std.mtof(bassNotes[noteIdx]) => sq.freq;
+                0.06 => pulseGain.gain;
+
+                // Quick decay
+                for (0 => int d; d < 10; d++) {
+                    pulseGain.gain() * 0.85 => pulseGain.gain;
+                    15::ms => now;
+                }
+            } else {
+                0.0 => pulseGain.gain;
+                150::ms => now;
+            }
+        }
+
+        cycleCount++;
+        // Evolve every 4 cycles
+        if (cycleCount % 4 == 0) {
+            Math.random2(2, 5) => k;
+            Math.random2(7, 13) => n;
+            (noteIdx + Math.random2(1, 3)) % bassNotes.size() => noteIdx;
+        }
+    }
+}
+
+// === HIHAT: gentle tick pattern ===
+fun void hihat() {
+    Noise noise => BPF bp => Gain hhGain => master;
+    8000.0 => bp.freq;
+    4.0 => bp.Q;
+    0.0 => hhGain.gain;
+
+    while (true) {
+        // Random density: sometimes busy, sometimes sparse
+        Math.random2(2, 6) => int density;
+
+        for (0 => int i; i < 16; i++) {
+            if (Math.random2(0, 8) < density) {
+                Math.random2f(0.02, 0.06) => hhGain.gain;
+                5::ms => now;
+                0.0 => hhGain.gain;
+                Math.random2(80, 200)::ms => now;
+            } else {
+                Math.random2(100, 250)::ms => now;
+            }
+        }
+    }
+}
+
+// === MELODY: sparse, floating notes ===
+fun void melody() {
+    SinOsc mel => LPF filt => Gain melGain => master;
+    0.0 => melGain.gain;
+    3000.0 => filt.freq;
+
+    [60, 63, 65, 67, 70, 72, 75, 77] @=> int notes[]; // high pentatonic
+
+    while (true) {
+        // 40% chance of playing a note
+        if (Math.random2f(0.0, 1.0) < 0.4) {
+            Math.random2(0, notes.size()-1) => int idx;
+            Std.mtof(notes[idx]) => mel.freq;
+
+            // Gentle attack
+            for (0 => int a; a < 20; a++) {
+                (a / 20.0) * Math.random2f(0.04, 0.08) => melGain.gain;
+                8::ms => now;
+            }
+            // Hold
+            Math.random2(200, 600)::ms => now;
+            // Gentle release
+            melGain.gain() => float vol;
+            for (0 => int r; r < 30; r++) {
+                vol * (1.0 - r / 30.0) => melGain.gain;
+                10::ms => now;
+            }
+            0.0 => melGain.gain;
+        }
+
+        Math.random2(500, 2000)::ms => now;
+    }
+}
+
+// === LAUNCH ALL SHREDS ===
+<<< "  Starforge Coding Ambient", "" >>>;
+<<< "  Ctrl-C to stop", "" >>>;
+<<< "" >>>;
+
+spork ~ pad();
+spork ~ pulse();
+spork ~ hihat();
+spork ~ melody();
+
+// Keep main shred alive
+while (true) 1::second => now;