@swiftbrowser/native 0.19.0 → 0.23.0

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSPCore/Machine.swift

@@ -17,21 +17,121 @@ import Foundation
 /// else a free one, else the oldest released, else the oldest; a lane's gate
 /// is up from its note on to its note off, or under the sustain pedal until
 /// the pedal lifts, and it sounds while the gate is up and then while any
-/// `adsr` in the program has not finished its release.
+/// `adsr` in the program has not finished its release. A `mono` or `legato`
+/// program is one voice playing the newest of the notes held (up to 16
+/// remembered): releasing it goes back to the one before, and `mono` starts
+/// its envelopes over at every change of note, `legato` only when no note
+/// was held.
+///
+/// The transport: `tempo` beats a minute (120 until set) and `beat`, which
+/// advances every frame from 0 (or where `seek` puts it), sounding or not.
+/// An event given a beat waits for it (up to 1024 at once) and applies on
+/// the frame nearest it, the block split there, so a sequencer that
+/// schedules ahead plays in time; one whose beat has passed applies at the
+/// next block. All notes off and all sound off drop what waits.
+///
+/// Memory is sized in `init` and never after: the wavetables (built from
+/// their harmonics with the JavaScript machine's inverse FFT, 2048 samples a
+/// frame at ten band-limited levels), a ring buffer per voice for each
+/// `delay`, the shapes' points and the samples' audio.
+///
+/// With a `master` stage, the voices' sum goes through it once a frame, in
+/// lane 0, whether or not a voice sounds; its state and its builtins' are
+/// reset only in `init` and on `reset`.
+///
+/// Block processing: a block runs in chunks of 16 frames, each instruction over every frame of the chunk for every
+/// sounding lane, but for a stream's serial part (feedback through state, which it schedules when it loads the
+/// program), which runs frame by frame within the chunk. Unlike the JavaScript machine's, a register holds a frame's lanes side by side,
+/// then the next frame's, so the loops over lanes stay vector loops; the results are the same.
 public final class DSPMachine: @unchecked Sendable {
     public let program: DSPProgram
     public let sampleRate: Float
 
     private static let lanes = 16
+    /// Frames a chunk has: each instruction runs over a chunk's frames together (block processing).
+    private static let frames = 16
+    /// The registers, each `width` values: a chunk's frames one after another, each its lanes (as many as the
+    /// program has voices) side by side, so an instruction runs over lanes as a SIMD vector and a builtin's state
+    /// follows its lanes; a state register's value is its lane's at the first frame.
     private let registers: UnsafeMutablePointer<Float>
+    private let width: Int
     private let state: UnsafeMutablePointer<Float>
     private let stateCount: Int
     private let noise: UnsafeMutablePointer<UInt32>
     private let noiseCount: Int
+    /// The streams as they run: what reads a gated region's result reading what the region gives it, `sample` and
+    /// `master` without the regions that are off, and scheduled (their parts that run frame by frame, in instructions).
     private let blockCode: UnsafeMutablePointer<Int32>
     private let blockCount: Int
+    /// How many of `blockCode`'s instructions run (those the streams were last made with).
+    private var blockRunning: Int
     private let sampleCode: UnsafeMutablePointer<Int32>
-    private let sampleCount: Int
+    private var sampleCount: Int
+    private let masterCode: UnsafeMutablePointer<Int32>
+    private var masterCount: Int
+    private var sampleSerial: Range<Int> = 0..<0
+    private var masterSerial: Range<Int> = 0..<0
+    /// The streams as the program has them, each instruction's region, each region's parameter, parent and results
+    /// (register, then what it reads as on and off, as offsets), whether each is on (2 before the program loads), and
+    /// per register what a result reads as now (-1 for a register that is none).
+    private let fullBlock: UnsafeMutablePointer<Int32>
+    private let fullSample: UnsafeMutablePointer<Int32>
+    private let fullSampleCount: Int
+    private let fullMaster: UnsafeMutablePointer<Int32>
+    private let fullMasterCount: Int
+    private let sampleGates: [Int32]?
+    private let masterGates: [Int32]?
+    private let groupParameters: [Int]
+    private let groupParents: [Int]
+    private let groupOutputs: [[(register: Int, on: Int32, off: Int32)]]
+    private var groupOn: [UInt8]
+    /// What runs: per instruction of the block, sample and master streams as the program has them, whether something
+    /// the outputs need reads it, now and when the streams were last made; per register, whether it is read, now and
+    /// then; whether the streams have been made; and each instruction's builtin (-1 for none). An instruction that comes
+    /// to run again starts over (its builtin, the state it writes), as one in a region coming on does.
+    private let aliveNow: [UnsafeMutablePointer<UInt8>]
+    private let aliveBefore: [UnsafeMutablePointer<UInt8>]
+    private let readNow: UnsafeMutablePointer<UInt8>
+    private let readBefore: UnsafeMutablePointer<UInt8>
+    private var made = false
+    private let streamInstances: [[Int32]]
+    private let streamCounts: [Int]
+    private let renameTable: UnsafeMutablePointer<Int32>
+    /// Scratch for making a stream again: its instructions before they are scheduled, a byte an instruction (touches
+    /// state, computed from it, needed by it) and a byte a register (tainted, needed).
+    private let staging: UnsafeMutablePointer<Int32>
+    private let instructionMarks: UnsafeMutablePointer<UInt8>
+    private let registerMarks: UnsafeMutablePointer<UInt8>
+    /// Choices: each one's parameter, register and options (as offsets); the option each reads as now (the last
+    /// choices with no cycle), the ones last asked for (so choices refused for a cycle are not tried every block),
+    /// and the ones asked for this block.
+    private let choiceParameters: [Int]
+    private let choiceRegisters: [Int]
+    private let choiceOptions: [[Int32]]
+    private let choiceScales: [Double]
+    private var choiceUsed: [Int]
+    private var choiceAsked: [Int]
+    private var choiceNow: [Int]
+    /// The voicing's parameters (nil: the program's own), and the voices and mode last played with (-1 before the
+    /// first block), so a turn lets go of what no longer plays.
+    private let voicesParameter: Int?
+    private let modeParameter: Int?
+    private var voicedLimit = -1
+    private var voicedMode = 0
+    /// Scratch for ordering a stream when choices change (made only when there are choices): the ordered sample and
+    /// master streams; per register its writer (not state) or the first of its writers (state, then linked by
+    /// instruction) and where its readers start in `readers`; per instruction how many it waits on; and a heap.
+    private let orderedSample: UnsafeMutablePointer<Int32>
+    private let orderedMaster: UnsafeMutablePointer<Int32>
+    private let writerOf: UnsafeMutablePointer<Int32>
+    private let stateWriterFirst: UnsafeMutablePointer<Int32>
+    private let stateWriterNext: UnsafeMutablePointer<Int32>
+    private let readerStarts: UnsafeMutablePointer<Int32>
+    private let readers: UnsafeMutablePointer<Int32>
+    private let waiting: UnsafeMutablePointer<Int32>
+    private let heap: UnsafeMutablePointer<Int32>
+    /// Per instance: whether the master stage runs it.
+    private let instanceMaster: [Bool]
     /// Each instance's builtin and where its state starts (in floats, lanes included; a noise instance's in `noise`).
     private let instanceKinds: [DSPBuiltin]
     private let instanceOffsets: [Int]
@@ -42,6 +142,60 @@ public final class DSPMachine: @unchecked Sendable {
     private let parameterIndices: [String: Int]
     private let targets: UnsafeMutablePointer<Float>
     private var snapped = true
+    /// Whether a parameter was set since the last block: only then can a region, a choice or the voicing turn.
+    private var retargeted = false
+    /// Each wavetable's samples (level, 2048 samples, each its frames side by side), how many floats, and its frames;
+    /// each its own, so one is replaced (`replaceTable`) by swapping it whole. (`Slots`, not arrays replaced in place,
+    /// which Swift would check for exclusive access at every read as it renders.)
+    private let tablePointers: Slots<UnsafeMutablePointer<Float>>
+    private let tableSizes: Slots<Int>
+    private let tableFrames: Slots<Int>
+    private let tableCount: Int
+    /// Envelopes' curves: the registers (as offsets) their attack, decay and release exponents are read from, three a
+    /// curve; an `adsr` names its curve in slot 11.
+    private let curveRegisters: [Int]
+    /// The delays' samples: each instance's buffer per lane, a power of two long; by instance, where it starts and its length.
+    private let delaySamples: UnsafeMutablePointer<Float>
+    private let delaySampleCount: Int
+    private let delayBases: [Int]
+    private let delayLengths: [Int]
+    /// Each shape's points and how many; each sample's audio, its length, its frames a frame at this rate, and its
+    /// spray (20 ms) in frames. Each its own, so one is replaced by swapping it whole.
+    private let shapePointers: Slots<UnsafeMutablePointer<Float>>
+    private let shapeLengths: Slots<Int>
+    private let samplePointers: Slots<UnsafeMutablePointer<Float>>
+    private let sampleLengths: Slots<Int>
+    private let sampleRatios: Slots<Float>
+    private let sampleSprays: Slots<UInt32>
+    /// `modsum`'s route lists, each with room for `DSPProgram.routesMax` registers (so one is replaced in place), as
+    /// register offsets (× `width`): a source's, then its amount's, pair after pair; list i starts at
+    /// `i × routesMax` and is `routeCounts[i]` long.
+    private let routeRegisters: UnsafeMutablePointer<Int>
+    /// Whether each route's register is state (one value a lane, not one a frame).
+    private let routeState: UnsafeMutablePointer<Bool>
+    private let routeCounts: UnsafeMutablePointer<Int>
+    private let routeCount: Int
+    /// Whether a route list was replaced since the last block: the streams are made again.
+    private var rerouted = false
+    /// Per register: whether it is a parameter, state, or one a machine renames (a choice's, a region's result).
+    private let parameterMask: UnsafeMutablePointer<UInt8>
+    private let stateMask: UnsafeMutablePointer<UInt8>
+    private let renamedMask: UnsafeMutablePointer<UInt8>
+    /// Folding: each register's value where it is a constant (NaN where not), an offset holding 0 (-1 for none), the
+    /// registers nothing may fold away (outputs, state, curves, the master stage's inputs) and those a route list names
+    /// now, and the registers folded when the streams were last made (their renaming undone before the next).
+    private let constantValues: UnsafeMutablePointer<Float>
+    /// Each parameter's range, by its register (NaN elsewhere): a clamp it is inside folds away.
+    private let parameterLowest: UnsafeMutablePointer<Float>
+    private let parameterHighest: UnsafeMutablePointer<Float>
+    private let zeroOffset: Int32
+    private let pinnedMask: UnsafeMutablePointer<UInt8>
+    private let routedMask: UnsafeMutablePointer<UInt8>
+    private let folded: UnsafeMutablePointer<Int32>
+    private var foldedCount = 0
+    /// Re-rating: per register whether it may change from frame to frame, and the sample stream's instructions kept.
+    private let changing: UnsafeMutablePointer<UInt8>
+    private let keptSample: UnsafeMutablePointer<Int32>
 
     private let laneNote: UnsafeMutablePointer<Int32>
     private let laneGate: UnsafeMutablePointer<Float>
@@ -50,31 +204,60 @@ public final class DSPMachine: @unchecked Sendable {
     private let laneActive: UnsafeMutablePointer<Float>
     private let laneAge: UnsafeMutablePointer<Double>
     private let trigger: UnsafeMutablePointer<Float>
+    /// The master stage's trigger: counts the notes (as the voice a mono program's starts over at).
+    private let masterTrigger: UnsafeMutablePointer<Float>
+    /// The lane of the newest note, for a master stage that reads it (-1 before the first).
+    private var newestLane = -1
     private var age: Double = 0
     private var pedal = false
     private var bend: Double = 0
+    private var tempo: Double = 120
+    private var beat: Double = 0
+    /// A mono program's held notes, oldest first.
+    private let stack: UnsafeMutablePointer<Int32>
+    private var stackCount = 0
+    /// Events waiting for their beat, soonest first: the beat, then the kind (note on, note off, controller,
+    /// bend) and two values.
+    private static let queueCapacity = 1024
+    private let queueBeat: UnsafeMutablePointer<Double>
+    private let queueEvent: UnsafeMutablePointer<Int32>
+    private var queueCount = 0
 
     public init(program: DSPProgram, sampleRate: Double) {
         let L = Self.lanes
         self.program = program
         self.sampleRate = Float(sampleRate)
-        registers = .allocate(capacity: program.registers * L)
-        registers.initialize(repeating: 0, count: program.registers * L)
+        let W = program.voices * Self.frames
+        width = W
+        registers = .allocate(capacity: program.registers * W)
+        registers.initialize(repeating: 0, count: program.registers * W)
+        let stateRegisters = Set(program.state.map(\.register))
+        var isMaster = [Bool](repeating: false, count: program.instances.count)
+        if let master = program.master {
+            var pc = 0
+            while pc < master.code.count {
+                let op = DSPOpcode(rawValue: master.code[pc])!
+                if op.builtin != nil { isMaster[Int(master.code[pc + 2 + op.arity])] = true }
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+        }
+        instanceMaster = isMaster
         var kinds: [DSPBuiltin] = []
         var offsets: [Int] = []
         var envelopes: [Int] = []
         var filters: [Int] = []
         var words = 0
         var noises = 0
-        for builtin in program.instances {
+        for (i, builtin) in program.instances.enumerated() {
             kinds.append(builtin)
             if builtin == .noise {
                 offsets.append(noises * L)
                 noises += 1
             } else {
                 offsets.append(words * L)
-                if builtin == .adsr { envelopes.append(words * L) }
-                if builtin == .lowpass || builtin == .highpass || builtin == .bandpass { filters.append(words * L) }
+                if builtin == .adsr && !isMaster[i] { envelopes.append(words * L) }
+                // The filters' integrators, a one-pole's, a DC blocker's and a comb's loop.
+                if [.lowpass, .highpass, .bandpass, .onepole, .dcblock, .comb].contains(builtin) { filters.append(words * L) }
                 words += builtin.words
             }
         }
@@ -88,19 +271,195 @@ public final class DSPMachine: @unchecked Sendable {
         noiseCount = max(1, noises) * L
         noise = .allocate(capacity: noiseCount)
         noise.initialize(repeating: 1, count: noiseCount)
-        (blockCode, blockCount) = Self.decode(program.block, offsets: offsets)
-        (sampleCode, sampleCount) = Self.decode(program.sample, offsets: offsets)
+        let tables = program.tables.isEmpty ? [(Self.zeros(DSPProgram.tableLevels * DSPProgram.tableFrame), DSPProgram.tableLevels * DSPProgram.tableFrame)] : program.tables.map { Self.levels(frames: $0.frames, cosines: $0.cosines) }
+        tablePointers = Slots(tables.map(\.0))
+        tableSizes = Slots(tables.map(\.1))
+        tableFrames = Slots(program.tables.isEmpty ? [1] : program.tables.map(\.frames.count))
+        tableCount = program.tables.count
+        shapePointers = Slots(program.shapes.isEmpty ? [Self.zeros(2)] : program.shapes.map { Self.copy($0.points) })
+        shapeLengths = Slots(program.shapes.isEmpty ? [2] : program.shapes.map(\.points.count))
+        samplePointers = Slots(program.samples.isEmpty ? [Self.zeros(2)] : program.samples.map { Self.copy($0.data) })
+        sampleLengths = Slots(program.samples.isEmpty ? [2] : program.samples.map(\.data.count))
+        sampleRatios = Slots(program.samples.isEmpty ? [1] : program.samples.map { Float($0.rate / Double(Float(sampleRate))) })
+        let routesMax = DSPProgram.routesMax
+        routeCount = program.routes.count
+        routeCounts = .allocate(capacity: Swift.max(1, routeCount))
+        routeCounts.initialize(repeating: 0, count: Swift.max(1, routeCount))
+        for (i, list) in program.routes.enumerated() { routeCounts[i] = list.count }
+        routeRegisters = .allocate(capacity: Swift.max(1, routeCount * routesMax))
+        routeRegisters.initialize(repeating: 0, count: Swift.max(1, routeCount * routesMax))
+        routeState = .allocate(capacity: Swift.max(1, routeCount * routesMax))
+        routeState.initialize(repeating: false, count: Swift.max(1, routeCount * routesMax))
+        for (i, list) in program.routes.enumerated() {
+            for (k, r) in list.enumerated() {
+                routeRegisters[i * routesMax + k] = r * W
+                routeState[i * routesMax + k] = stateRegisters.contains(r)
+            }
+        }
+        let registerCount = program.registers
+        func mask() -> UnsafeMutablePointer<UInt8> {
+            let pointer = UnsafeMutablePointer<UInt8>.allocate(capacity: registerCount)
+            pointer.initialize(repeating: 0, count: registerCount)
+            return pointer
+        }
+        parameterMask = mask()
+        stateMask = mask()
+        renamedMask = mask()
+        pinnedMask = mask()
+        routedMask = mask()
+        changing = mask()
+        for p in program.parameters { parameterMask[p.register] = 1 }
+        for r in stateRegisters { stateMask[r] = 1 }
+        for c in program.choices { renamedMask[c.register] = 1 }
+        for g in program.groups { for o in g.outputs { renamedMask[o.register] = 1 } }
+        for r in [program.output, program.outputRight ?? program.output] + (program.master?.outputs ?? []) + (program.master?.inputs ?? []) { pinnedMask[r] = 1 }
+        for r in stateRegisters { pinnedMask[r] = 1 }
+        for c in program.curves { for r in [c.attack, c.decay, c.release] { pinnedMask[r] = 1 } }
+        for list in program.routes { for r in list { routedMask[r] = 1 } }
+        constantValues = .allocate(capacity: registerCount)
+        constantValues.initialize(repeating: .nan, count: registerCount)
+        parameterLowest = .allocate(capacity: registerCount)
+        parameterLowest.initialize(repeating: .nan, count: registerCount)
+        parameterHighest = .allocate(capacity: registerCount)
+        parameterHighest.initialize(repeating: .nan, count: registerCount)
+        for p in program.parameters {
+            parameterLowest[p.register] = p.min
+            parameterHighest[p.register] = p.max
+        }
+        var zero: Int32 = -1
         for constant in program.constants {
-            (registers + constant.register * L).update(repeating: constant.value, count: L)
+            constantValues[constant.register] = constant.value
+            if constant.value == 0 && zero < 0 { zero = Int32(constant.register * W) }
+        }
+        zeroOffset = zero
+        sampleSprays = Slots(program.samples.isEmpty ? [1] : program.samples.map { UInt32(Swift.max(1, ($0.rate * 0.02).rounded(.down))) })
+        // Each delay's buffer: its longest time (a constant register) at this sample rate, rounded up to a power of
+        // two, per voice (the master stage's, once).
+        let constantValues = Dictionary(program.constants.map { ($0.register, $0.value) }, uniquingKeysWith: { _, last in last })
+        var bases = [Int](repeating: 0, count: program.instances.count)
+        var lengths = [Int](repeating: 0, count: program.instances.count)
+        var delayTotal = 0
+        for code in [program.sample, program.master?.code ?? []] {
+            var pc = 0
+            while pc < code.count {
+                let op = DSPOpcode(rawValue: code[pc])!
+                if let longestAt = op.longest {
+                    let instance = Int(code[pc + 2 + op.arity])
+                    let longest = Double(Swift.min(Swift.max(constantValues[Int(code[pc + 1 + longestAt])] ?? 1, 0), 2))
+                    var length = 4
+                    while Double(length) < (longest * Double(Float(sampleRate))).rounded(.up) + 2 { length *= 2 }
+                    bases[instance] = delayTotal
+                    lengths[instance] = length
+                    delayTotal += length * (isMaster[instance] ? 1 : L)
+                }
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+        }
+        delayBases = bases
+        delayLengths = lengths
+        delaySampleCount = Swift.max(1, delayTotal)
+        delaySamples = .allocate(capacity: delaySampleCount)
+        delaySamples.initialize(repeating: 0, count: delaySampleCount)
+        curveRegisters = program.curves.flatMap { [$0.attack * W, $0.decay * W, $0.release * W] }
+        let curves = Dictionary(program.curves.enumerated().map { ($1.instance, $0 + 1) }, uniquingKeysWith: { _, last in last })
+        (fullBlock, blockCount) = Self.decode(program.block, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (fullSample, fullSampleCount) = Self.decode(program.sample, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (fullMaster, fullMasterCount) = Self.decode(program.master?.code ?? [], width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        // Each made again (renamed, compacted, scheduled) when the program has loaded, and when a region turns.
+        // The block stream's room takes the sample stream's too: what no longer changes frame by frame moves there.
+        blockCode = .allocate(capacity: max(12, (blockCount + fullSampleCount) * 12))
+        blockCode.initialize(repeating: 0, count: max(12, (blockCount + fullSampleCount) * 12))
+        blockCode.update(from: fullBlock, count: blockCount * 12)
+        keptSample = .allocate(capacity: max(12, fullSampleCount * 12))
+        folded = .allocate(capacity: max(1, blockCount + fullSampleCount + fullMasterCount))
+        blockRunning = blockCount
+        sampleCode = .allocate(capacity: max(12, fullSampleCount * 12))
+        sampleCode.update(from: fullSample, count: max(12, fullSampleCount * 12))
+        masterCode = .allocate(capacity: max(12, fullMasterCount * 12))
+        masterCode.update(from: fullMaster, count: max(12, fullMasterCount * 12))
+        (sampleCount, masterCount) = (fullSampleCount, fullMasterCount)
+        sampleGates = program.sampleGates
+        masterGates = program.masterGates
+        groupParameters = program.groups.map(\.parameter)
+        groupParents = program.groups.map(\.parent)
+        groupOutputs = program.groups.map { $0.outputs.map { (register: $0.register, on: Int32($0.on * W), off: Int32($0.off * W)) } }
+        groupOn = [UInt8](repeating: 2, count: program.groups.count)
+        streamInstances = [program.block, program.sample, program.master?.code ?? []].map { code in
+            var instances: [Int32] = []
+            var pc = 0
+            while pc < code.count, let op = DSPOpcode(rawValue: code[pc]) {
+                instances.append(op.builtin != nil ? code[pc + 2 + op.arity] : -1)
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+            return instances
+        }
+        streamCounts = [blockCount, fullSampleCount, fullMasterCount]
+        aliveNow = [blockCount, fullSampleCount, fullMasterCount].map { count in
+            let marks = UnsafeMutablePointer<UInt8>.allocate(capacity: Swift.max(1, count))
+            marks.initialize(repeating: 0, count: Swift.max(1, count))
+            return marks
+        }
+        aliveBefore = [blockCount, fullSampleCount, fullMasterCount].map { count in
+            let marks = UnsafeMutablePointer<UInt8>.allocate(capacity: Swift.max(1, count))
+            marks.initialize(repeating: 0, count: Swift.max(1, count))
+            return marks
+        }
+        readNow = .allocate(capacity: program.registers)
+        readNow.initialize(repeating: 0, count: program.registers)
+        readBefore = .allocate(capacity: program.registers)
+        readBefore.initialize(repeating: 0, count: program.registers)
+        renameTable = .allocate(capacity: program.registers)
+        renameTable.initialize(repeating: -1, count: program.registers)
+        let longest = max(1, blockCount, fullSampleCount, fullMasterCount)
+        staging = .allocate(capacity: longest * 12)
+        staging.initialize(repeating: 0, count: longest * 12)
+        instructionMarks = .allocate(capacity: longest)
+        instructionMarks.initialize(repeating: 0, count: longest)
+        registerMarks = .allocate(capacity: program.registers)
+        registerMarks.initialize(repeating: 0, count: program.registers)
+        choiceParameters = program.choices.map(\.parameter)
+        choiceRegisters = program.choices.map(\.register)
+        choiceOptions = program.choices.map { $0.options.map { Int32($0 * W) } }
+        choiceScales = program.choices.map(\.scale)
+        choiceUsed = [Int](repeating: -1, count: program.choices.count)
+        choiceAsked = choiceUsed
+        choiceNow = choiceUsed
+        voicesParameter = program.voicingVoices
+        modeParameter = program.voicingMode
+        // The most registers an instruction of the sample or master stream reads: its operands, and a modsum's routes.
+        let ordering = !program.choices.isEmpty || !program.routes.isEmpty
+        // A route list may be replaced by one as long as any may be.
+        let longestRoute = program.routes.isEmpty ? 0 : routesMax
+        func readsIn(_ code: UnsafeMutablePointer<Int32>, _ count: Int) -> Int {
+            (0..<count).reduce(0) { sum, i in
+                let op = DSPOpcode(rawValue: code[i * 12])!
+                return sum + op.arity + (op == .modsum ? longestRoute : 0)
+            }
         }
-        registers.update(repeating: Float(sampleRate), count: L)
+        let readCount = ordering ? Swift.max(readsIn(fullSample, fullSampleCount), readsIn(fullMaster, fullMasterCount)) : 0
+        let orderable = ordering ? longest : 1
+        orderedSample = .allocate(capacity: Swift.max(12, fullSampleCount * 12))
+        orderedMaster = .allocate(capacity: Swift.max(12, fullMasterCount * 12))
+        writerOf = .allocate(capacity: ordering ? program.registers : 1)
+        writerOf.initialize(repeating: -1, count: ordering ? program.registers : 1)
+        stateWriterFirst = .allocate(capacity: ordering ? program.registers : 1)
+        stateWriterFirst.initialize(repeating: -1, count: ordering ? program.registers : 1)
+        stateWriterNext = .allocate(capacity: orderable)
+        readerStarts = .allocate(capacity: ordering ? program.registers + 1 : 1)
+        readers = .allocate(capacity: Swift.max(1, readCount))
+        waiting = .allocate(capacity: orderable)
+        heap = .allocate(capacity: orderable)
+        for constant in program.constants {
+            (registers + constant.register * W).update(repeating: constant.value, count: W)
+        }
+        registers.update(repeating: Float(sampleRate), count: W)
         parameterRegisters = program.parameters.map(\.register)
         parameterRanges = program.parameters.map { ($0.min, $0.max) }
         parameterIndices = Dictionary(program.parameters.enumerated().map { ($1.name, $0) }, uniquingKeysWith: { first, _ in first })
         targets = .allocate(capacity: max(1, program.parameters.count))
         for (i, parameter) in program.parameters.enumerated() {
             targets[i] = parameter.defaultValue
-            (registers + parameter.register * L).update(repeating: parameter.defaultValue, count: L)
+            (registers + parameter.register * W).update(repeating: parameter.defaultValue, count: W)
         }
         laneNote = .allocate(capacity: L)
         laneNote.initialize(repeating: -1, count: L)
@@ -116,37 +475,684 @@ public final class DSPMachine: @unchecked Sendable {
         laneAge.initialize(repeating: 0, count: L)
         trigger = .allocate(capacity: L)
         trigger.initialize(repeating: 0, count: L)
+        masterTrigger = .allocate(capacity: 1)
+        masterTrigger.initialize(to: 1)
+        stack = .allocate(capacity: L)
+        stack.initialize(repeating: 0, count: L)
+        queueBeat = .allocate(capacity: Self.queueCapacity)
+        queueBeat.initialize(repeating: 0, count: Self.queueCapacity)
+        queueEvent = .allocate(capacity: Self.queueCapacity * 3)
+        queueEvent.initialize(repeating: 0, count: Self.queueCapacity * 3)
         for lane in 0..<L { resetLane(lane) }
+        resetMaster()
+        // The streams as they run: the regions its parameters turn on, scheduled.
+        turnRegions(loading: true)
+        revoice()
     }
 
     deinit {
-        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger] { pointer.deallocate() }
+        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger, masterTrigger] { pointer.deallocate() }
+        for slots in [shapePointers, samplePointers, tablePointers] {
+            for i in 0..<slots.count { slots[i].deallocate() }
+            slots.deallocate()
+        }
+        for slots in [tableSizes, tableFrames, shapeLengths, sampleLengths] { slots.deallocate() }
+        sampleRatios.deallocate()
+        sampleSprays.deallocate()
         noise.deallocate()
+        routeRegisters.deallocate()
+        routeCounts.deallocate()
+        routeState.deallocate()
+        for pointer in [parameterMask, stateMask, renamedMask, pinnedMask, routedMask, changing] { pointer.deallocate() }
+        constantValues.deallocate()
+        parameterLowest.deallocate()
+        parameterHighest.deallocate()
+        keptSample.deallocate()
+        folded.deallocate()
+        delaySamples.deallocate()
         blockCode.deallocate()
         sampleCode.deallocate()
+        masterCode.deallocate()
+        fullBlock.deallocate()
+        fullSample.deallocate()
+        fullMaster.deallocate()
+        renameTable.deallocate()
+        staging.deallocate()
+        instructionMarks.deallocate()
+        registerMarks.deallocate()
+        for pointer in aliveNow + aliveBefore + [readNow, readBefore] { pointer.deallocate() }
+        for pointer in [orderedSample, orderedMaster, writerOf, stateWriterFirst, stateWriterNext, readerStarts, readers, waiting, heap] { pointer.deallocate() }
         laneNote.deallocate()
+        stack.deallocate()
+        queueBeat.deallocate()
+        queueEvent.deallocate()
         laneHeld.deallocate()
         laneAge.deallocate()
     }
 
-    /// Instructions at a stride of 8 (op, destination, five operands, state offset), registers as offsets into the file.
-    private static func decode(_ code: [Int32], offsets: [Int]) -> (UnsafeMutablePointer<Int32>, Int) {
+    /// Instructions at a stride of 12 (op, destination, five operands, state offset, which of slots 1 … 6 are state
+    /// registers as bits, then a delay line's buffer: where it starts and its length, then an envelope's curve, 1 up,
+    /// 0 for none), registers as offsets into the file. With how many there are.
+    /// Gated regions and choices: a region is on while its parameter is set above 0.5 and the region around it is on;
+    /// a choice reads as the option its parameter names. When either changes (or the program loads), the streams are
+    /// made again: without the regions that are off, with what reads a region's result or a choice reading what it
+    /// gives, without what nothing the outputs need reads (an option not chosen), ordered so what a choice reads comes
+    /// first, and scheduled. Into buffers made when the program loaded: nothing is allocated.
+    private func turnRegions(loading: Bool, force: Bool = false) {
+        var changed = loading || force
+        for g in 0..<groupParameters.count {
+            let parent = groupParents[g]
+            let on: UInt8 = (parent < 0 || groupOn[parent] == 1) && targets[groupParameters[g]] > 0.5 ? 1 : 0
+            if on != groupOn[g] {
+                groupOn[g] = on
+                changed = true
+            }
+        }
+        for c in 0..<choiceParameters.count {
+            let value = Float((Double(targets[choiceParameters[c]]) * choiceScales[c]).rounded())
+            let last = choiceOptions[c].count - 1
+            choiceNow[c] = value.isNaN ? 0 : value <= 0 ? 0 : value >= Float(last) ? last : Int(value)
+            if choiceNow[c] != choiceAsked[c] { changed = true }
+        }
+        guard changed else { return }
+        for c in 0..<choiceNow.count { choiceAsked[c] = choiceNow[c] }
+        // The choices asked for; if they would make a cycle, the last that did not (with the regions as they are now);
+        // and on loading, if even those would, the program's own order.
+        if make(choiceNow, sort: true) {
+            for c in 0..<choiceNow.count { choiceUsed[c] = choiceNow[c] }
+        } else if loading || !make(choiceUsed, sort: true) {
+            _ = make(loading ? choiceNow : choiceUsed, sort: false)
+        }
+        if loading { for c in 0..<choiceNow.count { choiceUsed[c] = choiceNow[c] } }
+    }
+
+    /// The streams made again for the regions as they are and the choices `chosen`; false (nothing made) on a cycle.
+    private func make(_ chosen: [Int], sort: Bool) -> Bool {
+        // What was folded last time reads as itself again, until folded again below.
+        for i in 0..<foldedCount { renameTable[Int(folded[i])] = -1 }
+        foldedCount = 0
+        var results = choiceRegisters.count
+        for g in groupOutputs.indices {
+            for output in groupOutputs[g] { renameTable[output.register] = groupOn[g] == 1 ? output.on : output.off }
+            results += groupOutputs[g].count
+        }
+        for c in 0..<choiceRegisters.count { renameTable[choiceRegisters[c]] = choiceOptions[c][chosen[c]] }
+        // A result or a choice may read as another (nested regions, a choice of results): followed, at most once each.
+        let W = Int32(width)
+        func resolve(_ register: Int) {
+            var target = renameTable[register]
+            var steps = 0
+            while steps < results, renameTable[Int(target / W)] >= 0 {
+                target = renameTable[Int(target / W)]
+                steps += 1
+            }
+            renameTable[register] = target
+        }
+        for g in groupOutputs.indices { for output in groupOutputs[g] { resolve(output.register) } }
+        for register in choiceRegisters { resolve(register) }
+        fold()
+        liveness()
+        // Ordered where something may read what comes after it (a choice of a value made later, a route from a source
+        // made later); kept apart from `staging`, which the next stream is compacted into.
+        let ordering = sort && (!choiceRegisters.isEmpty || routeCount > 0)
+        let samples = compact(fullSample, fullSampleCount, aliveNow[1])
+        if ordering {
+            guard order(samples, into: orderedSample) else { return false }
+        } else {
+            orderedSample.update(from: staging, count: samples * 12)
+        }
+        let masters = compact(fullMaster, fullMasterCount, aliveNow[2])
+        if ordering {
+            guard order(masters, into: orderedMaster) else { return false }
+        } else {
+            orderedMaster.update(from: staging, count: masters * 12)
+        }
+        revive()
+        blockRunning = compact(fullBlock, blockCount, aliveNow[0])
+        blockCode.update(from: staging, count: blockRunning * 12)
+        // What in the sample stream no longer changes frame by frame runs once a block (as machine.ts moves it).
+        sampleCount = rerate(samples, from: orderedSample)
+        sampleSerial = reschedule(sampleCount, from: keptSample, into: sampleCode)
+        masterCount = masters
+        masterSerial = reschedule(masters, from: orderedMaster, into: masterCode)
+        return true
+    }
+
+    /// Folds what turned constant, before what runs is found (as machine.ts folds it): an instruction that comes to
+    /// one of its operands (x + 0, x × 1, a mix at 0 or 1, a select of a constant, a mov) or to 0 (x × 0, an empty
+    /// route list) is passed over, what reads it reading that instead. Never one whose register is an output, state, a
+    /// curve or in a route list.
+    private func fold() {
+        let W = Int32(width)
+        let zero = zeroOffset
+        func pass(_ code: UnsafeMutablePointer<Int32>, _ count: Int) {
+            for i in 0..<count {
+                let slot = code + i * 12
+                let d = Int(slot[1] / W)
+                if pinnedMask[d] != 0 || routedMask[d] != 0 { continue }
+                let op = slot[0]
+                let arity = DSPOpcode(rawValue: op)!.arity
+                func operand(_ k: Int) -> Int32 {
+                    guard k < arity else { return -1 }
+                    let t = renameTable[Int(slot[2 + k] / W)]
+                    return t >= 0 ? t : slot[2 + k]
+                }
+                let a = operand(0)
+                let b = operand(1)
+                let c = operand(2)
+                func value(_ offset: Int32) -> Float { offset >= 0 ? constantValues[Int(offset / W)] : .nan }
+                var to: Int32 = -1
+                switch op {
+                case 0: to = a
+                case 1: to = value(a) == 0 ? b : value(b) == 0 ? a : -1
+                case 2: to = value(b) == 0 ? a : -1
+                case 3: to = value(a) == 1 ? b : value(b) == 1 ? a : value(a) == 0 || value(b) == 0 ? zero : -1
+                case 58: to = value(a) == 0 || value(b) == 0 ? c : value(c) == 0 && value(a) == 1 ? b : value(c) == 0 && value(b) == 1 ? a : -1
+                case 59: to = value(c) == 0 ? zero : value(c) == 1 && value(a) == 0 ? b : value(c) == 1 && value(b) == 0 ? a : -1
+                case 30: to = a == b ? b : !value(a).isNaN ? (value(a) != 0 ? b : c) : -1
+                // A parameter clamped to a range its own is inside.
+                case 31: to = a >= 0 && value(b) <= parameterLowest[Int(a / W)] && parameterHighest[Int(a / W)] <= value(c) ? a : -1
+                case 32: to = value(c) == 0 || a == b ? a : value(c) == 1 ? b : -1
+                case 57:
+                    let index = Self.index(registers[Int(slot[2])], routeCount)
+                    to = index >= routeCount || routeCounts[index] == 0 ? zero : -1
+                default: break
+                }
+                if to < 0 || Int(to / W) == d { continue }
+                renameTable[d] = to
+                folded[foldedCount] = Int32(d)
+                foldedCount += 1
+            }
+        }
+        pass(fullBlock, blockCount)
+        pass(fullSample, fullSampleCount)
+        pass(fullMaster, fullMasterCount)
+    }
+
+    /// The `count` instructions of the sample stream at `source`, split (as machine.ts splits them): those that read
+    /// only what is set once a block (no state, nothing worked out frame by frame, not the beat) and are not builtins,
+    /// onto the end of `blockCode`; the rest into `keptSample`, in their order. How many stayed.
+    private func rerate(_ count: Int, from source: UnsafeMutablePointer<Int32>) -> Int {
+        let W = Int32(width)
+        changing[6] = 1
+        var kept = 0
+        for i in 0..<count {
+            let slot = source + i * 12
+            let d = Int(slot[1] / W)
+            var still = DSPOpcode(rawValue: slot[0])!.builtin == nil && stateMask[d] == 0
+            if still { forEachRead(slot) { r, state in if state || changing[r] != 0 { still = false } } }
+            if still {
+                (blockCode + blockRunning * 12).update(from: slot, count: 12)
+                blockRunning += 1
+            } else {
+                changing[d] = 1
+                (keptSample + kept * 12).update(from: slot, count: 12)
+                kept += 1
+            }
+        }
+        // The marks back to none, for the next time.
+        for i in 0..<kept { changing[Int(keptSample[i * 12 + 1] / W)] = 0 }
+        changing[6] = 0
+        return kept
+    }
+
+    /// Replaces route list `index` from the next block with `list`'s registers (a source's, then its amount's, pair
+    /// after pair, as floats), copied in place (as machine.ts `replaceRoutes`): the streams are made again. False where
+    /// there is no such list, or an amount is not a parameter, a register is past the program's or one renamed, or the
+    /// list is past `DSPProgram.routesMax`.
+    public func replaceRoutes(_ index: Int, registers list: DSPBuffer) -> Bool {
+        guard index >= 0, index < routeCount, list.count % 2 == 0, list.count <= DSPProgram.routesMax else { return false }
+        for k in 0..<list.count {
+            let x = list.pointer[k]
+            guard x >= 0, x < Float(program.registers), x == x.rounded(.down) else { return false }
+            let r = Int(x)
+            guard renamedMask[r] == 0, k % 2 == 0 || parameterMask[r] != 0 else { return false }
+        }
+        let start = index * DSPProgram.routesMax
+        for k in 0..<list.count {
+            let r = Int(list.pointer[k])
+            routeRegisters[start + k] = r * width
+            routeState[start + k] = stateMask[r] != 0
+        }
+        routeCounts[index] = list.count
+        routedMask.update(repeating: 0, count: program.registers)
+        for i in 0..<routeCount {
+            for k in 0..<routeCounts[i] { routedMask[routeRegisters[i * DSPProgram.routesMax + k] / width] = 1 }
+        }
+        rerouted = true
+        return true
+    }
+
+
+    /// The `count` instructions in `staging` into `out`, ordered so each comes after what writes what it reads (not
+    /// state), and a state register's readers before what writes it (they read the frame before's); program order
+    /// where neither says (as machine.ts orders). False on a cycle.
+    private func order(_ count: Int, into out: UnsafeMutablePointer<Int32>) -> Bool {
+        let W = Int32(width)
+        let registerCount = program.registers
+        for i in 0..<count {
+            let slot = staging + i * 12
+            let d = Int(slot[1] / W)
+            if (slot[8] >> 1) & 1 == 1 {
+                stateWriterNext[i] = stateWriterFirst[d]
+                stateWriterFirst[d] = Int32(i)
+            } else {
+                writerOf[d] = Int32(i)
+            }
+            waiting[i] = 0
+        }
+        // Each register's readers (reading it not as state), in program order: counted, summed to where each ends,
+        // then placed back to front so each ends where it starts.
+        readerStarts.update(repeating: 0, count: registerCount + 1)
+        for i in 0..<count { forEachRead(staging + i * 12) { r, state in if !state { readerStarts[r] += 1 } } }
+        var total: Int32 = 0
+        for r in 0..<registerCount {
+            total += readerStarts[r]
+            readerStarts[r] = total
+        }
+        readerStarts[registerCount] = total
+        for i in stride(from: count - 1, through: 0, by: -1) {
+            forEachRead(staging + i * 12) { r, state in
+                guard !state else { return }
+                readerStarts[r] -= 1
+                readers[Int(readerStarts[r])] = Int32(i)
+            }
+        }
+        for i in 0..<count {
+            forEachRead(staging + i * 12) { r, state in
+                if state {
+                    var w = stateWriterFirst[r]
+                    while w >= 0 {
+                        if Int(w) != i { waiting[Int(w)] += 1 }
+                        w = stateWriterNext[Int(w)]
+                    }
+                } else if writerOf[r] >= 0, Int(writerOf[r]) != i {
+                    waiting[i] += 1
+                }
+            }
+        }
+        // The ready instructions, least first (a binary heap), so program order holds where nothing else decides.
+        var size = 0
+        func push(_ i: Int32) {
+            var k = size
+            heap[k] = i
+            size += 1
+            while k > 0, heap[(k - 1) / 2] > heap[k] {
+                (heap[k], heap[(k - 1) / 2]) = (heap[(k - 1) / 2], heap[k])
+                k = (k - 1) / 2
+            }
+        }
+        func pop() -> Int {
+            let top = heap[0]
+            size -= 1
+            heap[0] = heap[size]
+            var k = 0
+            while true {
+                let l = 2 * k + 1
+                var m = k
+                if l < size, heap[l] < heap[m] { m = l }
+                if l + 1 < size, heap[l + 1] < heap[m] { m = l + 1 }
+                if m == k { break }
+                (heap[k], heap[m]) = (heap[m], heap[k])
+                k = m
+            }
+            return Int(top)
+        }
+        func done(_ j: Int) {
+            waiting[j] -= 1
+            if waiting[j] == 0 { push(Int32(j)) }
+        }
+        for i in 0..<count where waiting[i] == 0 { push(Int32(i)) }
+        var placed = 0
+        while size > 0 {
+            let i = pop()
+            let slot = staging + i * 12
+            (out + placed * 12).update(from: slot, count: 12)
+            placed += 1
+            forEachRead(slot) { r, state in
+                guard state else { return }
+                var w = stateWriterFirst[r]
+                while w >= 0 {
+                    if Int(w) != i { done(Int(w)) }
+                    w = stateWriterNext[Int(w)]
+                }
+            }
+            let d = Int(slot[1] / W)
+            if (slot[8] >> 1) & 1 == 0, Int(writerOf[d]) == i {
+                for k in Int(readerStarts[d])..<Int(readerStarts[d + 1]) where Int(readers[k]) != i { done(Int(readers[k])) }
+            }
+        }
+        // The tables back to none, for the next time.
+        for i in 0..<count {
+            let d = Int(staging[i * 12 + 1] / W)
+            writerOf[d] = -1
+            stateWriterFirst[d] = -1
+        }
+        return placed == count
+    }
+
+    /// An envelope's curve exponent as read: held to 1/16 … 16, 1 for NaN (as machine.ts reads it).
+    @inline(__always) private static func exponent(_ x: Float) -> Double {
+        x >= 0.0625 ? Double(x <= 16 ? x : 16) : x < 0.0625 ? 0.0625 : 1
+    }
+
+    /// Each register the instruction at `slot` reads (its operands, an envelope's curves, and a modsum's routes), and
+    /// whether it is state.
+    private func forEachRead(_ slot: UnsafeMutablePointer<Int32>, _ body: (Int, Bool) -> Void) {
+        let W = Int32(width)
+        let op = DSPOpcode(rawValue: slot[0])!
+        for k in 0..<op.arity { body(Int(slot[2 + k] / W), (slot[8] >> (2 + k)) & 1 == 1) }
+        if op == .adsr, slot[11] > 0 {
+            let curve = Int(slot[11]) - 1
+            for k in 0..<3 { body(curveRegisters[curve * 3 + k] / width, false) }
+        }
+        if op == .modsum {
+            let index = Self.index(registers[Int(slot[2])], routeCount)
+            if index < routeCount {
+                let start = index * DSPProgram.routesMax
+                for k in start..<(start + routeCounts[index]) { body(routeRegisters[k] / width, routeState[k]) }
+            }
+        }
+    }
+
+    /// What runs, into `aliveNow` and `readNow`, with what reads a result or a choice reading what `renameTable` says:
+    /// from the outputs back, each instruction outside a region that is off whose register something running reads,
+    /// and what it reads (a state register read, what writes it). Again until nothing more runs, since a choice or
+    /// state may read what comes after (as machine.ts finds it).
+    private func liveness() {
+        let W = Int32(width)
+        readNow.update(repeating: 0, count: program.registers)
+        readNow[program.output] = 1
+        if let right = program.outputRight { readNow[right] = 1 }
+        for r in program.master?.outputs ?? [] { readNow[r] = 1 }
+        for s in 0..<3 { aliveNow[s].update(repeating: 0, count: streamCounts[s]) }
+        /// One pass over a stream, back to front: whether anything more runs.
+        func sweep(_ code: UnsafeMutablePointer<Int32>, _ count: Int, _ gates: [Int32]?, _ marks: UnsafeMutablePointer<UInt8>) -> Bool {
+            var more = false
+            for i in stride(from: count - 1, through: 0, by: -1) {
+                let slot = code + i * 12
+                guard marks[i] == 0, readNow[Int(slot[1] / W)] != 0 else { continue }
+                if let gates, gates[i] >= 0, groupOn[Int(gates[i])] == 0 { continue }
+                marks[i] = 1
+                more = true
+                forEachRead(slot) { r, _ in
+                    let renamed = renameTable[r]
+                    readNow[renamed >= 0 ? Int(renamed / W) : r] = 1
+                }
+            }
+            return more
+        }
+        var more = true
+        while more {
+            more = sweep(fullMaster, fullMasterCount, masterGates, aliveNow[2])
+            more = sweep(fullSample, fullSampleCount, sampleGates, aliveNow[1]) || more
+            more = sweep(fullBlock, blockCount, nil, aliveNow[0]) || more
+        }
+    }
+
+    /// What comes to run again (it did not when the streams were last made) starts over: a builtin as when a voice
+    /// starts, a state register at its first value. Nothing does when the program loads. Then what runs now is what ran.
+    private func revive() {
+        let counts = streamCounts
+        if made {
+            for s in 0..<3 {
+                for i in 0..<counts[s] where aliveNow[s][i] != 0 && aliveBefore[s][i] == 0 && streamInstances[s][i] >= 0 {
+                    let instance = Int(streamInstances[s][i])
+                    if instanceMaster[instance] { resetInstance(instance, 0) } else { for l in 0..<program.voices { resetInstance(instance, l) } }
+                }
+            }
+            for entry in program.state where readNow[entry.register] != 0 && readBefore[entry.register] == 0 {
+                if entry.master { registers[entry.register * width] = entry.initial } else { for l in 0..<program.voices { registers[entry.register * width + l] = entry.initial } }
+            }
+        }
+        for s in 0..<3 { aliveBefore[s].update(from: aliveNow[s], count: counts[s]) }
+        readBefore.update(from: readNow, count: program.registers)
+        made = true
+    }
+
+    /// A stream's instructions that run (`alive`), their operands renamed, into `staging`: how many instructions.
+    private func compact(_ code: UnsafeMutablePointer<Int32>, _ count: Int, _ alive: UnsafeMutablePointer<UInt8>) -> Int {
+        let W = Int32(width)
+        var kept = 0
+        for i in 0..<count {
+            if alive[i] == 0 { continue }
+            let at = code + i * 12
+            let slot = staging + kept * 12
+            slot.update(from: at, count: 12)
+            for k in 0..<DSPOpcode(rawValue: at[0])!.arity {
+                let r = renameTable[Int(at[2 + k] / W)]
+                if r >= 0 { slot[2 + k] = r }
+            }
+            kept += 1
+        }
+        return kept
+    }
+
+    /// A stream's schedule over the `count` instructions at `source`, into `out`: those reading or writing state, and
+    /// those both computed from state and needed by it this frame, run frame by frame (the serial part, returned); what
+    /// they need comes before, what needs them after; program order kept within each part (as machine.ts schedules).
+    private func reschedule(_ count: Int, from source: UnsafeMutablePointer<Int32>, into out: UnsafeMutablePointer<Int32>) -> Range<Int> {
+        let W = Int32(width)
+        let touches: UInt8 = 1, downstream: UInt8 = 2, upstream: UInt8 = 4
+        let tainted: UInt8 = 1, needed: UInt8 = 2
+        for i in 0..<count {
+            let slot = source + i * 12
+            var marks: UInt8 = (slot[8] >> 1) & 1 == 1 ? touches : 0
+            var fromState = false
+            forEachRead(slot) { r, state in
+                if state { marks |= touches }
+                if registerMarks[r] & tainted != 0 { fromState = true }
+            }
+            if marks & touches != 0 || fromState {
+                marks |= downstream
+                if (slot[8] >> 1) & 1 == 0 { registerMarks[Int(slot[1] / W)] |= tainted }
+            }
+            instructionMarks[i] = marks
+        }
+        for i in stride(from: count - 1, through: 0, by: -1) {
+            let slot = source + i * 12
+            guard instructionMarks[i] & touches != 0 || registerMarks[Int(slot[1] / W)] & needed != 0 else { continue }
+            instructionMarks[i] |= upstream
+            forEachRead(slot) { r, state in if !state { registerMarks[r] |= needed } }
+        }
+        var kept = 0
+        var from = 0
+        var to = 0
+        for part in 0..<3 {
+            if part == 1 { from = kept }
+            if part == 2 { to = kept }
+            for i in 0..<count {
+                let marks = instructionMarks[i]
+                let serial = marks & touches != 0 || (marks & downstream != 0 && marks & upstream != 0)
+                guard (part == 0 && !serial && marks & downstream == 0) || (part == 1 && serial) || (part == 2 && !serial && marks & downstream != 0) else { continue }
+                (out + kept * 12).update(from: source + i * 12, count: 12)
+                kept += 1
+            }
+        }
+        // The marks back to none, for the next time.
+        for i in 0..<count {
+            let slot = source + i * 12
+            registerMarks[Int(slot[1] / W)] = 0
+            forEachRead(slot) { r, _ in registerMarks[r] = 0 }
+        }
+        return from..<to
+    }
+
+    private static func decode(
+        _ code: [Int32], width: Int, state: Set<Int>, offsets: [Int], delays: (bases: [Int], lengths: [Int]), curves: [Int: Int]
+    ) -> (UnsafeMutablePointer<Int32>, Int) {
         var out: [Int32] = []
         var pc = 0
         while pc < code.count {
             let op = DSPOpcode(rawValue: code[pc])!
-            var slot = [Int32](repeating: 0, count: 8)
+            var slot = [Int32](repeating: 0, count: 12)
             slot[0] = op.rawValue
-            slot[1] = code[pc + 1] * Int32(lanes)
-            for k in 0..<op.arity { slot[2 + k] = code[pc + 2 + k] * Int32(lanes) }
+            for k in 0..<(1 + op.arity) {
+                let register = Int(code[pc + 1 + k])
+                slot[1 + k] = Int32(register * width)
+                if state.contains(register) { slot[8] |= 1 << (1 + k) }
+            }
             if op.builtin != nil { slot[7] = Int32(offsets[Int(code[pc + 2 + op.arity])]) }
+            if op == .adsr { slot[11] = Int32(curves[Int(code[pc + 2 + op.arity])] ?? 0) }
+            if op.longest != nil {
+                let instance = Int(code[pc + 2 + op.arity])
+                slot[9] = Int32(delays.bases[instance])
+                slot[10] = Int32(delays.lengths[instance])
+            }
             out += slot
             pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
         }
-        let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(8, out.count))
-        pointer.initialize(repeating: 0, count: max(8, out.count))
+        let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(12, out.count))
+        pointer.initialize(repeating: 0, count: max(12, out.count))
         out.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: out.count) }
-        return (pointer, out.count / 8)
+        return (pointer, out.count / 12)
+    }
+
+    /// Lists one after another: where each starts and its length.
+    private static func zeros(_ count: Int) -> UnsafeMutablePointer<Float> {
+        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: Swift.max(1, count))
+        pointer.initialize(repeating: 0, count: Swift.max(1, count))
+        return pointer
+    }
+
+    private static func copy(_ values: [Float]) -> UnsafeMutablePointer<Float> {
+        let pointer = zeros(values.count)
+        values.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: values.count) }
+        return pointer
+    }
+
+    /// A wavetable's samples as the machine reads them (as machine.ts `tableLevels` makes them), off the audio thread,
+    /// for `replaceTable`.
+    public static func tableLevels(frames: [[Float]], cosines: [[Float]]? = nil) -> DSPBuffer {
+        let (pointer, count) = levels(frames: frames, cosines: cosines)
+        return DSPBuffer(taking: pointer, count: count)
+    }
+
+    /// Replaces table `index`'s samples (`tableLevels`) from the next block, swapping them with `levels`, which then
+    /// holds what the machine let go of, to free off the audio thread. False (nothing swapped) where they do not fit.
+    public func replaceTable(_ index: Int, levels: DSPBuffer, frames: Int) -> Bool {
+        guard index >= 0, index < tableCount, frames >= 1, levels.count == frames * DSPProgram.tableLevels * DSPProgram.tableFrame else { return false }
+        var total = frames
+        for i in 0..<tableFrames.count where i != index { total += tableFrames[i] }
+        guard total <= DSPProgram.tableFramesMax else { return false }
+        swap(&tablePointers[index], &levels.pointer)
+        swap(&tableSizes[index], &levels.count)
+        tableFrames[index] = frames
+        return true
+    }
+
+    /// Replaces shape `index`'s points from the next block, swapping them with `points` (as `replaceTable`).
+    public func replaceShape(_ index: Int, points: DSPBuffer) -> Bool {
+        guard index >= 0, index < program.shapes.count, (2...DSPProgram.shapePointsMax).contains(points.count) else { return false }
+        var total = points.count
+        for i in 0..<shapeLengths.count where i != index { total += shapeLengths[i] }
+        guard total <= DSPProgram.shapesPointsMax else { return false }
+        swap(&shapePointers[index], &points.pointer)
+        swap(&shapeLengths[index], &points.count)
+        return true
+    }
+
+    /// Replaces sample `index`'s audio, at `rate` frames a second, from the next block, swapping it with `audio` (as
+    /// `replaceTable`); a sound playing it goes on from where it is, inside the new length.
+    public func replaceSample(_ index: Int, audio: DSPBuffer, rate: Double) -> Bool {
+        guard index >= 0, index < program.samples.count, rate >= 1000, rate <= 384_000, audio.count >= 2 else { return false }
+        var total = audio.count
+        for i in 0..<sampleLengths.count where i != index { total += sampleLengths[i] }
+        guard total <= DSPProgram.samplesMax else { return false }
+        swap(&samplePointers[index], &audio.pointer)
+        swap(&sampleLengths[index], &audio.count)
+        sampleRatios[index] = Float(rate / Double(Float(sampleRate)))
+        sampleSprays[index] = UInt32(Swift.max(1, (rate * 0.02).rounded(.down)))
+        return true
+    }
+
+    /// A table's samples and how many floats: each level one with the harmonics past 512, 256 … dropped, 2048 samples,
+    /// each its frames side by side.
+    private static func levels(frames tableFrames: [[Float]], cosines tableCosines: [[Float]]?) -> (UnsafeMutablePointer<Float>, Int) {
+        let N = DSPProgram.tableFrame
+        let levels = DSPProgram.tableLevels
+        let count = Swift.max(1, tableFrames.count) * levels * N
+        let samples = zeros(count)
+        var cosT = [Double](repeating: 0, count: N / 2)
+        var sinT = [Double](repeating: 0, count: N / 2)
+        for j in 0..<(N / 2) {
+            cosT[j] = Foundation.cos(2 * Double.pi * Double(j) / Double(N))
+            sinT[j] = Foundation.sin(2 * Double.pi * Double(j) / Double(N))
+        }
+        var re = [Double](repeating: 0, count: N)
+        var im = [Double](repeating: 0, count: N)
+        do {
+            let count = tableFrames.count
+            // A level's samples one after another, each its frames side by side: a read between two samples and two
+            // frames is one span of memory.
+            func store(_ level: Int, _ n: Int, _ f: Int) -> Int { (level * N + n) * count + f }
+            for (f, amplitudes) in tableFrames.enumerated() {
+                for level in 0..<levels {
+                    let limit = Swift.min(512 >> level, amplitudes.count)
+                    if level > 0 && limit == Swift.min(512 >> (level - 1), amplitudes.count) {
+                        // No harmonic dropped: the level above's samples.
+                        for n in 0..<N { samples[store(level, n, f)] = samples[store(level - 1, n, f)] }
+                        continue
+                    }
+                    for i in 0..<N {
+                        re[i] = 0
+                        im[i] = 0
+                    }
+                    // sin(kθ) = (e^{ikθ} − e^{−ikθ}) / 2i
+                    if limit >= 1 {
+                        for k in 1...limit {
+                            let a = Double(amplitudes[k - 1])
+                            im[k] = -a / 2
+                            im[N - k] = a / 2
+                        }
+                        // cos(kθ) = (e^{ikθ} + e^{−ikθ}) / 2
+                        if let cosines = tableCosines?[f] {
+                            for k in 1...limit {
+                                let c = Double(cosines[k - 1])
+                                re[k] = c / 2
+                                re[N - k] = c / 2
+                            }
+                        }
+                    }
+                    // Bit reversal, then radix-2 butterflies with e^{+2πij/len}.
+                    var j = 0
+                    for i in 1..<N {
+                        var bit = N >> 1
+                        while j & bit != 0 {
+                            j ^= bit
+                            bit >>= 1
+                        }
+                        j ^= bit
+                        if i < j {
+                            re.swapAt(i, j)
+                            im.swapAt(i, j)
+                        }
+                    }
+                    var len = 2
+                    while len <= N {
+                        let half = len >> 1
+                        let step = N / len
+                        var i = 0
+                        while i < N {
+                            for k in 0..<half {
+                                let wr = cosT[k * step]
+                                let wi = sinT[k * step]
+                                let xr = re[i + k + half] * wr - im[i + k + half] * wi
+                                let xi = re[i + k + half] * wi + im[i + k + half] * wr
+                                re[i + k + half] = re[i + k] - xr
+                                im[i + k + half] = im[i + k] - xi
+                                re[i + k] = re[i + k] + xr
+                                im[i + k] = im[i + k] + xi
+                            }
+                            i += len
+                        }
+                        len <<= 1
+                    }
+                    for n in 0..<N { samples[store(level, n, f)] = Float(re[n]) }
+                }
+            }
+        }
+        return (samples, count)
     }
 
     // MARK: Events
@@ -160,15 +1166,161 @@ public final class DSPMachine: @unchecked Sendable {
     public func setParameter(at index: Int, _ value: Float) {
         guard index >= 0, index < parameterRegisters.count, value.isFinite else { return }
         targets[index] = Swift.min(Swift.max(value, parameterRanges[index].min), parameterRanges[index].max)
+        retargeted = true
+    }
+
+    /// The transport's tempo, in beats a minute (1 … 999), from the next block.
+    public func setTempo(_ bpm: Double) {
+        if bpm.isFinite { tempo = Swift.min(Swift.max(bpm, 1), 999) }
+    }
+
+    /// Moves the transport to `beat`.
+    public func seek(toBeat beat: Double) {
+        if beat.isFinite { self.beat = beat }
+    }
+
+    /// Where the transport is, in beats.
+    public var position: Double { beat }
+
+    /// MIDI note on: `velocity` 1 … 127 (0 is a note off); at `atBeat` on the transport, or at the next block. False
+    /// when too many wait.
+    @discardableResult
+    public func noteOn(_ note: Int32, velocity: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 0, note, velocity) }
+        start(note, velocity: velocity)
+        return true
+    }
+
+    /// MIDI note off; at `atBeat` on the transport, or at the next block.
+    @discardableResult
+    public func noteOff(_ note: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 1, note, 0) }
+        release(note)
+        return true
     }
 
-    /// MIDI note on: `velocity` 1 … 127 (0 is a note off).
-    public func noteOn(_ note: Int32, velocity: Int32) {
+    /// 64 the sustain pedal, 120 all sound off, 123 all notes off (both dropping what waits); at `atBeat`, or at the
+    /// next block.
+    @discardableResult
+    public func controller(_ number: Int32, value: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 2, number, value) }
+        if number == 120 || number == 123 { queueCount = 0 }
+        control(number, value: value)
+        return true
+    }
+
+    /// The pitch wheel, 0 … 16383, 8192 centered: ±2 semitones; at `atBeat`, or at the next block.
+    @discardableResult
+    public func pitchBend(_ value: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 3, value, 0) }
+        bend = Double(Swift.min(16383, Swift.max(0, value)) - 8192) / 8192 * 2
+        return true
+    }
+
+    /// Puts an event in the queue after those at or before its beat.
+    private func schedule(_ beat: Double, _ kind: Int32, _ a: Int32, _ b: Int32) -> Bool {
+        guard beat.isFinite, queueCount < Self.queueCapacity else { return false }
+        var at = queueCount
+        while at > 0 && queueBeat[at - 1] > beat { at -= 1 }
+        (queueBeat + at + 1).update(from: queueBeat + at, count: queueCount - at)
+        (queueEvent + (at + 1) * 3).update(from: queueEvent + at * 3, count: (queueCount - at) * 3)
+        queueBeat[at] = beat
+        queueEvent[at * 3] = kind
+        queueEvent[at * 3 + 1] = a
+        queueEvent[at * 3 + 2] = b
+        queueCount += 1
+        return true
+    }
+
+    /// Applies what is due: each event whose beat is nearer this frame than the next.
+    private func applyDue(_ step: Double) {
+        while queueCount > 0 && queueBeat[0] < beat + step / 2 {
+            let kind = queueEvent[0]
+            let a = queueEvent[1]
+            let b = queueEvent[2]
+            queueBeat.update(from: queueBeat + 1, count: queueCount - 1)
+            queueEvent.update(from: queueEvent + 3, count: (queueCount - 1) * 3)
+            queueCount -= 1
+            switch kind {
+            case 0: start(a, velocity: b)
+            case 1: release(a)
+            case 2: control(a, value: b)
+            default: pitchBend(a)
+            }
+        }
+    }
+
+    /// Frames to the next waiting event, at most a block's.
+    private func framesToNext(_ step: Double) -> Int {
+        let frames = ((queueBeat[0] - beat) / step).rounded()
+        return frames >= Double(DSPProgram.blockFrames) ? DSPProgram.blockFrames : Swift.max(1, Int(frames))
+    }
+
+    /// The mode notes play in now: the voicing's parameter's, else the program's.
+    private func currentMode() -> DSPProgram.Mode? {
+        guard let p = modeParameter else { return program.mode }
+        let m = targets[p].rounded()
+        return m == 1 ? .mono : m == 2 ? .legato : nil
+    }
+
+    /// How many voices play now: the voicing's parameter's (1 … the program's), else the program's.
+    private func voiceLimit() -> Int {
+        guard let p = voicesParameter else { return program.voices }
+        let n = targets[p].rounded()
+        return n.isNaN || n < 1 ? 1 : n >= Float(program.voices) ? program.voices : Int(n)
+    }
+
+    /// At a block's start, where the voicing turned: the voices past those that play now let go, and the held notes a
+    /// mode keeps start again from the one voice that sounds (as machine.ts does).
+    private func revoice() {
+        let mode = currentMode()
+        let modeIndex = mode == .mono ? 1 : mode == .legato ? 2 : 0
+        let limit = mode != nil ? 1 : voiceLimit()
+        guard limit != voicedLimit || modeIndex != voicedMode else { return }
+        let first = voicedLimit < 0
+        voicedLimit = limit
+        voicedMode = modeIndex
+        if first { return }
+        for l in limit..<Self.lanes {
+            laneGate[l] = 0
+            laneHeld[l] = false
+        }
+        stackCount = 0
+        if mode != nil && laneGate[0] > 0.5 {
+            stack[0] = laneNote[0]
+            stackCount = 1
+        }
+    }
+
+    private func start(_ note: Int32, velocity: Int32) {
         if velocity <= 0 {
-            noteOff(note)
+            release(note)
             return
         }
-        let voices = program.voices
+        if let mode = currentMode() {
+            // One voice: the newest note, legato while another is held.
+            unstack(note)
+            if stackCount == Self.lanes {
+                (stack).update(from: stack + 1, count: stackCount - 1)
+                stackCount -= 1
+            }
+            stack[stackCount] = note
+            stackCount += 1
+            let held = laneGate[0] > 0.5
+            if laneActive[0] == 0 { resetLane(0) }
+            laneNote[0] = note
+            laneGate[0] = 1
+            laneHeld[0] = false
+            laneVelocity[0] = Float(Double(Swift.min(127, velocity)) / 127)
+            laneActive[0] = 1
+            newestLane = 0
+            if mode == .mono || !held {
+                trigger[0] += 1
+                masterTrigger[0] += 1
+            }
+            return
+        }
+        let voices = voiceLimit()
         var lane = -1
         for l in 0..<voices where lane < 0 && laneNote[l] == note && laneGate[l] > 0.5 { lane = l }
         var fresh = false
@@ -191,19 +1343,35 @@ public final class DSPMachine: @unchecked Sendable {
         laneVelocity[lane] = Float(Double(Swift.min(127, velocity)) / 127)
         laneActive[lane] = 1
         trigger[lane] += 1
+        masterTrigger[0] += 1
+        newestLane = lane
         age += 1
         laneAge[lane] = age
     }
 
-    public func noteOff(_ note: Int32) {
+    private func release(_ note: Int32) {
+        if let mode = currentMode() {
+            unstack(note)
+            guard laneNote[0] == note && laneGate[0] > 0.5 else { return }
+            if stackCount > 0 {
+                // Back to the note held before it.
+                laneNote[0] = stack[stackCount - 1]
+                laneHeld[0] = false
+                if mode == .mono { trigger[0] += 1 }
+            } else if pedal {
+                laneHeld[0] = true
+            } else {
+                laneGate[0] = 0
+            }
+            return
+        }
         for l in 0..<program.voices where laneNote[l] == note && laneGate[l] > 0.5 {
             // Under the pedal the gate stays up until it lifts.
             if pedal { laneHeld[l] = true } else { laneGate[l] = 0 }
         }
     }
 
-    /// 64 the sustain pedal, 120 all sound off, 123 all notes off.
-    public func controller(_ number: Int32, value: Int32) {
+    private func control(_ number: Int32, value: Int32) {
         let L = Self.lanes
         switch number {
         case 64:
@@ -215,24 +1383,32 @@ public final class DSPMachine: @unchecked Sendable {
         case 123:
             laneGate.update(repeating: 0, count: L)
             laneHeld.update(repeating: false, count: L)
+            stackCount = 0
         case 120:
+            stackCount = 0
             for l in 0..<L {
                 laneGate[l] = 0
                 laneHeld[l] = false
                 laneActive[l] = 0
                 resetLane(l)
             }
+            resetMaster()
         default:
             break
         }
     }
 
-    /// The pitch wheel, 0 … 16383, 8192 centered: ±2 semitones.
-    public func pitchBend(_ value: Int32) {
-        bend = Double(Swift.min(16383, Swift.max(0, value)) - 8192) / 8192 * 2
+    /// Drops `note` from a mono program's held notes.
+    private func unstack(_ note: Int32) {
+        var kept = 0
+        for i in 0..<stackCount where stack[i] != note {
+            stack[kept] = stack[i]
+            kept += 1
+        }
+        stackCount = kept
     }
 
-    /// Silences every voice at once.
+    /// Silences every voice, and the master stage, at once, and drops what waits.
     public func reset() {
         controller(120, value: 0)
     }
@@ -244,79 +1420,214 @@ public final class DSPMachine: @unchecked Sendable {
 
     // MARK: Rendering
 
-    /// Writes `frames` mono frames to `out`, in blocks of up to 128.
+    /// Writes `frames` frames to `out`, in blocks of up to 128: a program's two sides averaged (a mono program's
+    /// samples either way).
     public func render(into out: UnsafeMutablePointer<Float>, frames: Int) {
         var done = 0
         while done < frames {
-            let n = Swift.min(DSPProgram.blockFrames, frames - done)
-            block(out + done, n)
+            let step = tempo / 60 / Double(sampleRate)
+            applyDue(step)
+            // A block ends where the next event is due.
+            let n = Swift.min(DSPProgram.blockFrames, frames - done, queueCount > 0 ? framesToNext(step) : DSPProgram.blockFrames)
+            block(out + done, nil, n)
+            done += n
+        }
+    }
+
+    /// Writes `frames` frames, the left side to `left` and the right to `right`, in blocks of up to 128.
+    public func render(left: UnsafeMutablePointer<Float>, right: UnsafeMutablePointer<Float>, frames: Int) {
+        var done = 0
+        while done < frames {
+            let step = tempo / 60 / Double(sampleRate)
+            applyDue(step)
+            let n = Swift.min(DSPProgram.blockFrames, frames - done, queueCount > 0 ? framesToNext(step) : DSPProgram.blockFrames)
+            block(left + done, right + done, n)
             done += n
         }
     }
 
+    /// A voice starts over: its state and its builtins', not the master stage's.
     private func resetLane(_ l: Int) {
+        // A register holds the program's voices' lanes (a state register's value its lane's first frame).
+        if l < program.voices {
+            for entry in program.state where !entry.master { registers[entry.register * width + l] = entry.initial }
+        }
+        for i in instanceKinds.indices where !instanceMaster[i] { resetInstance(i, l) }
+    }
+
+    /// The master stage starts over, in lane 0.
+    private func resetMaster() {
+        for entry in program.state where entry.master { registers[entry.register * width] = entry.initial }
+        for i in instanceKinds.indices where instanceMaster[i] { resetInstance(i, 0) }
+    }
+
+    private func resetInstance(_ i: Int, _ l: Int) {
         let L = Self.lanes
-        for entry in program.state { registers[entry.register * L + l] = entry.initial }
-        for (i, kind) in instanceKinds.enumerated() {
-            let base = instanceOffsets[i] + l
-            if kind == .noise {
-                let seed = UInt32(truncatingIfNeeded: i + 1) &* 2_654_435_761 &+ UInt32(truncatingIfNeeded: l + 1) &* 2_246_822_519
-                noise[base] = seed == 0 ? 1 : seed
-                continue
-            }
-            for w in 0..<kind.words { state[base + w * L] = 0 }
-            if kind == .adsr {
-                state[base + 4 * L] = .nan
-                state[base + 6 * L] = .nan
-            } else if kind.words == 8 {
-                state[base + 2 * L] = .nan
-            }
+        let kind = instanceKinds[i]
+        let base = instanceOffsets[i] + l
+        let seed = UInt32(truncatingIfNeeded: i + 1) &* 2_654_435_761 &+ UInt32(truncatingIfNeeded: l + 1) &* 2_246_822_519
+        if kind == .noise {
+            noise[base] = seed == 0 ? 1 : seed
+            return
+        }
+        for w in 0..<kind.words { state[base + w * L] = 0 }
+        if kind == .delay || kind == .comb || kind == .allpass {
+            (delaySamples + delayBases[i] + l * delayLengths[i]).update(repeating: 0, count: delayLengths[i])
+        }
+        if kind == .grains {
+            // Its random state, a word of raw bits.
+            UnsafeMutableRawPointer(state + base + L).storeBytes(of: seed == 0 ? 1 : seed, as: UInt32.self)
+        }
+        if kind == .adsr {
+            state[base + 4 * L] = .nan
+            state[base + 6 * L] = .nan
+        } else if kind.words == 8 {
+            state[base + 2 * L] = .nan
+        } else if kind == .smooth {
+            state[base] = .nan
+            state[base + L] = .nan
         }
     }
 
-    private func block(_ out: UnsafeMutablePointer<Float>, _ n: Int) {
+    private func block(_ out: UnsafeMutablePointer<Float>, _ right: UnsafeMutablePointer<Float>?, _ n: Int) {
         let L = Self.lanes
+        let F = Self.frames
+        let W = width
         let R = registers
         let sr = sampleRate
-        // Parameters glide toward their targets, about 20 ms.
+        // Parameters glide toward their targets, about 20 ms, and come to rest on them: one at rest is left as it is.
         let alpha = snapped ? Float(1) : 1 - exp(-Float(n) / (0.02 * sr))
         snapped = false
         for (i, register) in parameterRegisters.enumerated() {
-            let at = R + register * L
-            at.update(repeating: at[0] + (targets[i] - at[0]) * alpha, count: L)
+            let at = R + register * W
+            let now = at[0]
+            let target = targets[i]
+            if now == target { continue }
+            var value = now + (target - now) * alpha
+            if abs(target - value) <= 1e-6 * (1 + abs(target)) { value = target }
+            at.update(repeating: value, count: W)
+        }
+        if retargeted || rerouted {
+            let force = rerouted
+            retargeted = false
+            rerouted = false
+            if !groupParameters.isEmpty || !choiceParameters.isEmpty || force { turnRegions(loading: false, force: force) }
+            if voicesParameter != nil || modeParameter != nil { revoice() }
         }
-        var any = false
-        for l in 0..<L where laneActive[l] != 0 { any = true }
-        guard any else {
+        (R + 5 * W).update(repeating: Float(tempo), count: W)
+        let beatStep = tempo / 60 / Double(sr)
+        // The voices run up to the highest that sounds: a note takes the lowest free lane, and an idle one starts
+        // over before it sounds again, so what the ones above would compute is never heard.
+        var lanes = 0
+        for l in 0..<L where laneActive[l] != 0 { lanes = l + 1 }
+        let any = lanes > 0
+        let master = program.master
+        guard any || master != nil else {
+            beat += Double(n) * beatStep
             out.update(repeating: 0, count: n)
+            right?.update(repeating: 0, count: n)
             return
         }
-        for l in 0..<L {
-            let note = laneNote[l]
-            R[1 * L + l] = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
-            R[2 * L + l] = laneGate[l]
-            R[3 * L + l] = laneVelocity[l]
-            R[4 * L + l] = note >= 0 ? Float(note) : 0
+        if any {
+            let V = program.voices
+            for l in 0..<V {
+                let note = laneNote[l]
+                let freq = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
+                for k in 0..<F {
+                    R[1 * W + k * V + l] = freq
+                    R[2 * W + k * V + l] = laneGate[l]
+                    R[3 * W + k * V + l] = laneVelocity[l]
+                    R[4 * W + k * V + l] = note >= 0 ? Float(note) : 0
+                }
+            }
+            run(blockCode, 0..<blockRunning, lanes: lanes, trigger: trigger, frames: F)
         }
-        run(blockCode, blockCount)
-        let o = R + program.output * L
+        if master != nil {
+            // The newest note, the master stage's inputs (registers 7 … 10), in lane 0.
+            let l = newestLane
+            let note = l >= 0 ? laneNote[l] : -1
+            let values: [Float] = [
+                note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0,
+                l >= 0 ? laneGate[l] : 0,
+                l >= 0 ? laneVelocity[l] : 0,
+                note >= 0 ? Float(note) : 0,
+            ]
+            let V = program.voices
+            for (i, value) in values.enumerated() { for k in 0..<F { R[(7 + i) * W + k * V] = value } }
+        }
+        let o = R + program.output * W
+        let or = R + (program.outputRight ?? program.output) * W
+        let V = program.voices
         var check: Float = 0
-        for i in 0..<n {
-            run(sampleCode, sampleCount)
-            var sum: Float = 0
-            for l in 0..<L { sum += o[l] * laneActive[l] }
-            out[i] = sum
-            check += sum
+        // A chunk of up to 16 frames at a time: each instruction over all of them, the serial part frame by frame.
+        var chunk = 0
+        while chunk < n {
+            let fc = Swift.min(F, n - chunk)
+            for k in 0..<fc {
+                for l in 0..<Swift.max(lanes, 1) { R[6 * W + k * V + l] = Float(beat) }
+                beat += beatStep
+            }
+            if any {
+                run(sampleCode, 0..<sampleSerial.lowerBound, lanes: lanes, trigger: trigger, frames: fc)
+                if !sampleSerial.isEmpty {
+                    for k in 0..<fc { run(sampleCode, sampleSerial, lanes: lanes, trigger: trigger, frames: 1, frame: k) }
+                }
+                run(sampleCode, sampleSerial.upperBound..<sampleCount, lanes: lanes, trigger: trigger, frames: fc)
+            }
+            for k in 0..<fc {
+                var leftSum: Float = 0
+                var rightSum: Float = 0
+                // The sounding voices only: an idle one may hold anything (log(0) of its freq, say), and NaN × 0 is NaN.
+                if any {
+                    for l in 0..<lanes where laneActive[l] != 0 {
+                        leftSum += o[k * V + l]
+                        rightSum += or[k * V + l]
+                    }
+                }
+                if let master {
+                    R[master.inputs[0] * W + k * V] = leftSum
+                    R[master.inputs[1] * W + k * V] = rightSum
+                } else {
+                    if let right {
+                        out[chunk + k] = leftSum
+                        right[chunk + k] = rightSum
+                    } else {
+                        out[chunk + k] = (leftSum + rightSum) * 0.5
+                    }
+                    check += leftSum + rightSum
+                }
+            }
+            if let master {
+                run(masterCode, 0..<masterSerial.lowerBound, lanes: 1, trigger: masterTrigger, frames: fc)
+                if !masterSerial.isEmpty {
+                    for k in 0..<fc { run(masterCode, masterSerial, lanes: 1, trigger: masterTrigger, frames: 1, frame: k) }
+                }
+                run(masterCode, masterSerial.upperBound..<masterCount, lanes: 1, trigger: masterTrigger, frames: fc)
+                for k in 0..<fc {
+                    let leftSum = R[master.outputs[0] * W + k * V]
+                    let rightSum = R[master.outputs[1] * W + k * V]
+                    if let right {
+                        out[chunk + k] = leftSum
+                        right[chunk + k] = rightSum
+                    } else {
+                        out[chunk + k] = (leftSum + rightSum) * 0.5
+                    }
+                    check += leftSum + rightSum
+                }
+            }
+            chunk += fc
         }
         guard check.isFinite else {
-            // A voice went to infinity or NaN: silence the block and start every voice over.
+            // A voice or the master stage went to infinity or NaN: silence the block and start everything over.
             out.update(repeating: 0, count: n)
+            right?.update(repeating: 0, count: n)
             for l in 0..<L {
                 laneActive[l] = 0
                 laneGate[l] = 0
                 laneHeld[l] = false
                 resetLane(l)
             }
+            resetMaster()
             return
         }
         // Denormals in the filters' integrators would slow every frame after.
@@ -344,180 +1655,731 @@ public final class DSPMachine: @unchecked Sendable {
         return 0
     }
 
-    // The interpreter: one instruction at a time, every lane per instruction.
-    private func run(_ code: UnsafeMutablePointer<Int32>, _ count: Int) {
+    /// A table's, shape's or sample's index from its register: in range, or the first.
+    @inline(__always)
+    private static func index(_ value: Float, _ count: Int) -> Int {
+        value >= 0 && value < Float(count) ? Int(value) : 0
+    }
+
+    // The interpreter: instructions `range` of `code` in the first `lanes` lanes (every voice's, or the master
+    // stage's one), each lane's note on counted in `trigger`, over the chunk's first `frames` frames; or, given a
+    // `frame`, at that frame alone, as the serial part runs (a state register's one value a lane, its first).
+    private func run(
+        _ code: UnsafeMutablePointer<Int32>, _ range: Range<Int>, lanes: Int, trigger: UnsafeMutablePointer<Float>, frames: Int, frame: Int = -1
+    ) {
         let L = Self.lanes
+        let F = Self.frames
         let R = registers
         let S = state
         let N = noise
         let sr = sampleRate
-        var at = 0
-        let end = count * 8
-        while at < end {
+        let serial = frame >= 0
+        let fc = serial ? 1 : frames
+        let V = program.voices
+        let shift = serial ? frame * V : 0
+        // A stateless instruction: every lane's frames at once (the chunk's last ones, past fc, go unread), the
+        // sounding lanes of each frame; in the serial part, the one frame's.
+        @inline(__always) func each(_ body: (Int) -> Void) {
+            if serial {
+                for l in 0..<lanes { body(l) }
+            } else if lanes == V {
+                for i in 0..<(F * V) { body(i) }
+            } else {
+                for k in 0..<F {
+                    for l in 0..<lanes { body(k * V + l) }
+                }
+            }
+        }
+        var next = range.lowerBound * 12
+        let end = range.upperBound * 12
+        while next < end {
+            // A constant for the instruction: a variable the kernels' closures read would be checked for exclusive
+            // access at every read.
+            let at = next
+            next += 12
             let op = code[at]
-            let d = R + Int(code[at + 1])
-            let a = R + Int(code[at + 2])
-            let b = R + Int(code[at + 3])
-            let c = R + Int(code[at + 4])
+            let states = code[at + 8]
+            // A register at this frame, or a state register's one value.
+            @inline(__always) func register(_ slot: Int) -> UnsafeMutablePointer<Float> {
+                R + Int(code[at + slot]) + (states & (1 << slot) != 0 ? 0 : shift)
+            }
+            let d = register(1)
+            let a = register(2)
+            let b = register(3)
+            let c = register(4)
             switch op {
-            case 0: for l in 0..<L { d[l] = a[l] }
-            case 1: for l in 0..<L { d[l] = a[l] + b[l] }
-            case 2: for l in 0..<L { d[l] = a[l] - b[l] }
-            case 3: for l in 0..<L { d[l] = a[l] * b[l] }
-            case 4: for l in 0..<L { d[l] = a[l] / b[l] }
-            case 5: for l in 0..<L { d[l] = a[l].truncatingRemainder(dividingBy: b[l]) }
-            case 6: for l in 0..<L { d[l] = -a[l] }
-            case 7: for l in 0..<L { d[l] = Swift.min(a[l], b[l]) }
-            case 8: for l in 0..<L { d[l] = Swift.max(a[l], b[l]) }
-            case 9: for l in 0..<L { d[l] = Swift.abs(a[l]) }
-            case 10: for l in 0..<L { d[l] = a[l].rounded(.down) }
-            case 11: for l in 0..<L { d[l] = a[l].rounded(.up) }
-            case 12: for l in 0..<L { d[l] = (a[l] + 0.5).rounded(.down) }
-            case 13: for l in 0..<L { d[l] = a[l].squareRoot() }
-            case 14: for l in 0..<L { d[l] = Foundation.sin(a[l]) }
-            case 15: for l in 0..<L { d[l] = Foundation.cos(a[l]) }
-            case 16: for l in 0..<L { d[l] = Foundation.tan(a[l]) }
-            case 17: for l in 0..<L { d[l] = Foundation.exp(a[l]) }
-            case 18: for l in 0..<L { d[l] = Foundation.log(a[l]) }
-            case 19: for l in 0..<L { d[l] = Foundation.pow(a[l], b[l]) }
-            case 20: for l in 0..<L { d[l] = Foundation.tanh(a[l]) }
-            case 21: for l in 0..<L { d[l] = a[l] < b[l] ? 1 : 0 }
-            case 22: for l in 0..<L { d[l] = a[l] <= b[l] ? 1 : 0 }
-            case 23: for l in 0..<L { d[l] = a[l] > b[l] ? 1 : 0 }
-            case 24: for l in 0..<L { d[l] = a[l] >= b[l] ? 1 : 0 }
-            case 25: for l in 0..<L { d[l] = a[l] == b[l] ? 1 : 0 }
-            case 26: for l in 0..<L { d[l] = a[l] != b[l] ? 1 : 0 }
-            case 27: for l in 0..<L { d[l] = a[l] != 0 && b[l] != 0 ? 1 : 0 }
-            case 28: for l in 0..<L { d[l] = a[l] != 0 || b[l] != 0 ? 1 : 0 }
-            case 29: for l in 0..<L { d[l] = a[l] == 0 ? 1 : 0 }
-            case 30: for l in 0..<L { d[l] = a[l] != 0 ? b[l] : c[l] }
-            case 31: for l in 0..<L { d[l] = Swift.min(Swift.max(a[l], b[l]), c[l]) }
-            case 32: for l in 0..<L { d[l] = a[l] + (b[l] - a[l]) * c[l] }
-            case 33: for l in 0..<L { d[l] = a[l] - a[l].rounded(.down) }
-            case 34: for l in 0..<L { d[l] = a[l] > 0 ? 1 : a[l] < 0 ? -1 : 0 }
-            case 35: for l in 0..<L { d[l] = Foundation.atan(a[l]) }
+            case 0: each { d[$0] = a[$0] }
+            case 1: each { d[$0] = a[$0] + b[$0] }
+            case 2: each { d[$0] = a[$0] - b[$0] }
+            case 3: each { d[$0] = a[$0] * b[$0] }
+            case 4: each { d[$0] = a[$0] / b[$0] }
+            case 5: each { d[$0] = a[$0].truncatingRemainder(dividingBy: b[$0]) }
+            case 6: each { d[$0] = -a[$0] }
+            case 7: each { d[$0] = Swift.min(a[$0], b[$0]) }
+            case 8: each { d[$0] = Swift.max(a[$0], b[$0]) }
+            case 9: each { d[$0] = Swift.abs(a[$0]) }
+            case 10: each { d[$0] = a[$0].rounded(.down) }
+            case 11: each { d[$0] = a[$0].rounded(.up) }
+            case 12: each { d[$0] = (a[$0] + 0.5).rounded(.down) }
+            case 13: each { d[$0] = a[$0].squareRoot() }
+            case 14: each { d[$0] = Foundation.sin(a[$0]) }
+            case 15: each { d[$0] = Foundation.cos(a[$0]) }
+            case 16: each { d[$0] = Foundation.tan(a[$0]) }
+            case 17: each { d[$0] = Foundation.exp(a[$0]) }
+            case 18: each { d[$0] = Foundation.log(a[$0]) }
+            case 19: each { d[$0] = Foundation.pow(a[$0], b[$0]) }
+            case 20: each { d[$0] = Foundation.tanh(a[$0]) }
+            case 21: each { d[$0] = a[$0] < b[$0] ? 1 : 0 }
+            case 22: each { d[$0] = a[$0] <= b[$0] ? 1 : 0 }
+            case 23: each { d[$0] = a[$0] > b[$0] ? 1 : 0 }
+            case 24: each { d[$0] = a[$0] >= b[$0] ? 1 : 0 }
+            case 25: each { d[$0] = a[$0] == b[$0] ? 1 : 0 }
+            case 26: each { d[$0] = a[$0] != b[$0] ? 1 : 0 }
+            case 27: each { d[$0] = a[$0] != 0 && b[$0] != 0 ? 1 : 0 }
+            case 28: each { d[$0] = a[$0] != 0 || b[$0] != 0 ? 1 : 0 }
+            case 29: each { d[$0] = a[$0] == 0 ? 1 : 0 }
+            case 30: each { d[$0] = a[$0] != 0 ? b[$0] : c[$0] }
+            case 31: each { d[$0] = Swift.min(Swift.max(a[$0], b[$0]), c[$0]) }
+            case 32: each { d[$0] = a[$0] + (b[$0] - a[$0]) * c[$0] }
+            case 33: each { d[$0] = a[$0] - a[$0].rounded(.down) }
+            case 34: each { d[$0] = a[$0] > 0 ? 1 : a[$0] < 0 ? -1 : 0 }
+            case 35: each { d[$0] = Foundation.atan(a[$0]) }
+            // The superinstructions: the product or the sum a float, as its own instruction would have stored it.
+            case 58: each { d[$0] = a[$0] * b[$0] + c[$0] }
+            case 59: each { d[$0] = (a[$0] + b[$0]) * c[$0] }
+            case 60: each { d[$0] = Foundation.log2(a[$0]) }
+            case 61: each { d[$0] = Foundation.log10(a[$0]) }
+            case 62: each { d[$0] = Foundation.exp2(a[$0]) }
+            case 63: each { d[$0] = a[$0].rounded(.towardZero) }
+            case 64: each { d[$0] = Foundation.asin(a[$0]) }
+            case 65: each { d[$0] = Foundation.acos(a[$0]) }
+            case 66: each { d[$0] = Foundation.atan2(a[$0], b[$0]) }
+            case 67: each { d[$0] = Foundation.sinh(a[$0]) }
+            case 68: each { d[$0] = Foundation.cosh(a[$0]) }
+            case 69: each { d[$0] = Foundation.cbrt(a[$0]) }
+            case 70: each { d[$0] = Foundation.hypot(a[$0], b[$0]) }
+            case 71: each { d[$0] = Foundation.expm1(a[$0]) }
+            case 72: each { d[$0] = Foundation.log1p(a[$0]) }
+            case 73:
+                // softclip(x): x (27 + x²) / (27 + 9x²) within ±3.
+                each {
+                    let x = a[$0] > -3 ? (a[$0] < 3 ? a[$0] : 3) : -3
+                    let x2 = x * x
+                    d[$0] = x * (27 + x2) / (27 + 9 * x2)
+                }
+            case 74:
+                // onepole(input, cutoff): toward the input by 1 − e^(−2π cutoff / sampleRate) a frame.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let cutoff = Swift.min(Swift.max(b[el], 0), 0.49 * sr)
+                        if !(s[L + l] == cutoff) {
+                            s[L + l] = cutoff
+                            s[2 * L + l] = 1 - Foundation.exp(-2 * Float.pi * cutoff / sr)
+                        }
+                        let y = s[l]
+                        s[l] = y + (a[el] - y) * s[2 * L + l]
+                        d[el] = s[l]
+                    }
+                }
+            case 75:
+                // dcblock(input): y = x − x before + r × y before, r = 1 − 2π 20 / sampleRate.
+                let s = S + Int(code[at + 7])
+                let r = 1 - Float(125.66370614359172) / sr
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let x = a[el]
+                        let y = (x - s[l]) + r * s[L + l]
+                        s[l] = x
+                        s[L + l] = y
+                        d[el] = y
+                    }
+                }
+            case 76, 77:
+                // comb(input, seconds, feedback, damp, longest): its line read seconds back, between samples, through a
+                // one-pole (damp the share it keeps) back in with the input times feedback. allpass(input, seconds,
+                // gain, longest): w = input + gain × w seconds back, out = w seconds back − gain × w.
+                let s = S + Int(code[at + 7])
+                let length = Int(code[at + 10])
+                let mask = length - 1
+                let memory = delaySamples + Int(code[at + 9])
+                let damping = register(5)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let w = Int(s[l])
+                        var ds = b[el] * sr
+                        ds = ds >= 1 ? (ds <= Float(length - 2) ? ds : Float(length - 2)) : 1
+                        let position = Float(w) - ds
+                        let i0 = Int(position.rounded(.down))
+                        let fr = position - Float(i0)
+                        let line = memory + l * length
+                        let v0 = line[i0 & mask]
+                        let v = v0 + (line[(i0 + 1) & mask] - v0) * fr
+                        let x = a[el]
+                        let g = c[el]
+                        if op == 76 {
+                            let damp = damping[el] > 0 ? (damping[el] < 1 ? damping[el] : 1) : 0
+                            let store = v * (1 - damp) + s[L + l] * damp
+                            s[L + l] = store
+                            line[w & mask] = x + store * g
+                            d[el] = v
+                        } else {
+                            let into = x + g * v
+                            line[w & mask] = into
+                            d[el] = v - g * into
+                        }
+                        s[l] = Float((w + 1) & mask)
+                    }
+                }
             case 40, 41, 42, 43, 44:
                 // Oscillators: the output from the phase now, then the phase steps by freq / sampleRate.
                 let s = S + Int(code[at + 7])
-                for l in 0..<L {
-                    let p = s[l]
-                    let dt = a[l] / sr
-                    var v: Float
-                    switch op {
-                    case 40: v = p
-                    case 41: v = Foundation.sin(2 * Float.pi * p)
-                    case 42:
-                        v = 2 * p - 1
-                        if dt > 0 { v -= Self.blep(p, dt) }
-                    case 43:
-                        let w = Swift.min(Swift.max(b[l], 0), 1)
-                        v = p < w ? 1 : -1
-                        if dt > 0 {
-                            let q = p + 1 - w
-                            v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let p = s[l]
+                        let dt = a[el] / sr
+                        var v: Float
+                        switch op {
+                        case 40: v = p
+                        case 41: v = Foundation.sin(2 * Float.pi * p)
+                        case 42:
+                            v = 2 * p - 1
+                            if dt > 0 { v -= Self.blep(p, dt) }
+                        case 43:
+                            let w = Swift.min(Swift.max(b[el], 0), 1)
+                            v = p < w ? 1 : -1
+                            if dt > 0 {
+                                let q = p + 1 - w
+                                v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                            }
+                        default: v = 1 - 4 * Swift.abs(p - 0.5)
                         }
-                    default: v = 1 - 4 * Swift.abs(p - 0.5)
+                        d[el] = v
+                        let next = p + dt
+                        s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
                     }
-                    d[l] = v
-                    let next = p + dt
-                    s[l] = next - next.rounded(.down)
                 }
             case 45:
                 let s = N + Int(code[at + 7])
-                for l in 0..<L {
-                    var x = s[l]
-                    x ^= x << 13
-                    x ^= x >> 17
-                    x ^= x << 5
-                    s[l] = x
-                    d[l] = Float(Double(x) / 4_294_967_296 * 2 - 1)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        var x = s[l]
+                        x ^= x << 13
+                        x ^= x >> 17
+                        x ^= x << 5
+                        s[l] = x
+                        d[el] = Float(Double(x) / 4_294_967_296 * 2 - 1)
+                    }
                 }
             case 46:
                 // adsr(gate, attack, decay, sustain, release): stage, level, trigger, gate before, decay time and coefficient, release time and coefficient.
+                // With curves, what it puts out is each stage bent by its exponent, and a stage that starts takes up
+                // where the last left off: its last output, and where a release started.
                 let s = S + Int(code[at + 7])
-                let sustainIn = R + Int(code[at + 5])
-                let releaseIn = R + Int(code[at + 6])
-                for l in 0..<L {
-                    let gate = a[l]
-                    var stage = s[l]
-                    var level = s[L + l]
-                    if s[2 * L + l] != trigger[l] {
-                        s[2 * L + l] = trigger[l]
-                        if gate > 0.5 { stage = 1 }
-                    } else if gate > 0.5 && s[3 * L + l] <= 0.5 {
-                        stage = 1
-                    }
-                    if gate <= 0.5 && stage >= 1 && stage <= 3 { stage = 4 }
-                    s[3 * L + l] = gate
-                    let sustain = Swift.min(Swift.max(sustainIn[l], 0), 1)
-                    if stage == 1 {
-                        level += 1 / Swift.max(1, b[l] * sr)
-                        if level >= 1 {
-                            level = 1
-                            stage = 2
-                        }
-                    } else if stage == 2 {
-                        let time = c[l]
-                        if !(s[4 * L + l] == time) {
-                            s[4 * L + l] = time
-                            s[5 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                let sustainIn = register(5)
+                let releaseIn = register(6)
+                let curve = Int(code[at + 11]) - 1
+                let curved = curve >= 0
+                // The curves' registers (a knob's, or modulated), read at the chunk's first frame a voice (as machine.ts
+                // reads them), 1/16 … 16, 1 for NaN.
+                let ra = curved ? R + curveRegisters[curve * 3] + shift : R
+                let rd = curved ? R + curveRegisters[curve * 3 + 1] + shift : R
+                let rr = curved ? R + curveRegisters[curve * 3 + 2] + shift : R
+                for l in 0..<lanes {
+                    let ea = curved ? Self.exponent(ra[l]) : 1
+                    let ed = curved ? Self.exponent(rd[l]) : 1
+                    let er = curved ? Self.exponent(rr[l]) : 1
+                    // All three 1: no stage bent (what it put out kept all the same, for a curve turned later).
+                    let bent = curved && (ea != 1 || ed != 1 || er != 1)
+                    for fk in 0..<fc {
+                        let el = fk * V + l
+                        let gate = a[el]
+                        var stage = s[l]
+                        var level = s[L + l]
+                        let before = stage
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            if gate > 0.5 { stage = 1 }
+                        } else if gate > 0.5 && s[3 * L + l] <= 0.5 {
+                            stage = 1
                         }
-                        level = sustain + (level - sustain) * s[5 * L + l]
-                        if level - sustain < 0.0001 { stage = 3 }
-                    } else if stage == 3 {
-                        level = sustain
-                    } else if stage == 4 {
-                        let time = releaseIn[l]
-                        if !(s[6 * L + l] == time) {
-                            s[6 * L + l] = time
-                            s[7 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                        if gate <= 0.5 && stage >= 1 && stage <= 3 { stage = 4 }
+                        s[3 * L + l] = gate
+                        if curved && stage != before {
+                            let last = s[8 * L + l]
+                            if stage == 1 {
+                                level = last > 0 ? (ea == 1 ? last : Float(Foundation.pow(Double(last), 1 / ea))) : 0
+                            } else if stage == 4 {
+                                level = last
+                                s[9 * L + l] = last
+                            }
                         }
-                        level *= s[7 * L + l]
-                        if level < 0.0001 {
+                        let sustain = Swift.min(Swift.max(sustainIn[el], 0), 1)
+                        if stage == 1 {
+                            level += 1 / Swift.max(1, b[el] * sr)
+                            if level >= 1 {
+                                level = 1
+                                stage = 2
+                            }
+                        } else if stage == 2 {
+                            let time = c[el]
+                            if !(s[4 * L + l] == time) {
+                                s[4 * L + l] = time
+                                s[5 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                            }
+                            level = sustain + (level - sustain) * s[5 * L + l]
+                            if level - sustain < 0.0001 { stage = 3 }
+                        } else if stage == 3 {
+                            level = sustain
+                        } else if stage == 4 {
+                            let time = releaseIn[el]
+                            if !(s[6 * L + l] == time) {
+                                s[6 * L + l] = time
+                                s[7 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                            }
+                            level *= s[7 * L + l]
+                            if level < 0.0001 {
+                                level = 0
+                                stage = 0
+                            }
+                        } else {
                             level = 0
-                            stage = 0
                         }
-                    } else {
-                        level = 0
+                        s[l] = stage
+                        s[L + l] = level
+                        var out = level
+                        if bent {
+                            // An exponent of 1 is no bend: the stage as it is, with no power worked out.
+                            if stage == 1 {
+                                out = ea == 1 ? level : Float(Foundation.pow(Double(level), ea))
+                            } else if stage == 2 {
+                                let span = 1 - sustain
+                                let along = Swift.max(0, (level - sustain) / span)
+                                out = span > 1e-6 ? sustain + span * (ed == 1 ? along : Float(Foundation.pow(Double(along), ed))) : level
+                            } else if stage == 4 {
+                                let from = s[9 * L + l]
+                                let along = Swift.min(1, level / from)
+                                out = from > 0 ? from * (er == 1 ? along : Float(Foundation.pow(Double(along), er))) : 0
+                            }
+                        }
+                        if curved { s[8 * L + l] = out }
+                        d[el] = out
                     }
-                    s[l] = stage
-                    s[L + l] = level
-                    d[l] = level
                 }
             case 47, 48, 49:
                 // A state-variable filter (Simper's form): resonance 0 … 1.
                 let s = S + Int(code[at + 7])
-                for l in 0..<L {
-                    let cutoff = Swift.min(Swift.max(b[l], 10), 0.49 * sr)
-                    let resonance = Swift.min(Swift.max(c[l], 0), 0.98)
-                    if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
-                        s[2 * L + l] = cutoff
-                        s[3 * L + l] = resonance
-                        let g = Foundation.tan(Float.pi * cutoff / sr)
-                        let k = 2 - 2 * resonance
-                        let a1 = 1 / (1 + g * (g + k))
-                        s[4 * L + l] = a1
-                        s[5 * L + l] = g * a1
-                        s[6 * L + l] = g * g * a1
-                        s[7 * L + l] = k
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let cutoff = Swift.min(Swift.max(b[el], 10), 0.49 * sr)
+                        let resonance = Swift.min(Swift.max(c[el], 0), 0.98)
+                        if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
+                            s[2 * L + l] = cutoff
+                            s[3 * L + l] = resonance
+                            let g = Foundation.tan(Float.pi * cutoff / sr)
+                            let k = 2 - 2 * resonance
+                            let a1 = 1 / (1 + g * (g + k))
+                            s[4 * L + l] = a1
+                            s[5 * L + l] = g * a1
+                            s[6 * L + l] = g * g * a1
+                            s[7 * L + l] = k
+                        }
+                        let a1 = s[4 * L + l]
+                        let a2 = s[5 * L + l]
+                        let a3 = s[6 * L + l]
+                        let ic1 = s[l]
+                        let ic2 = s[L + l]
+                        let x = a[el]
+                        let v3 = x - ic2
+                        let v1 = a1 * ic1 + a2 * v3
+                        let v2 = ic2 + a2 * ic1 + a3 * v3
+                        s[l] = 2 * v1 - ic1
+                        s[L + l] = 2 * v2 - ic2
+                        d[el] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
+                    }
+                }
+            case 50:
+                // wavetable(table, freq, position): the level that cannot alias at freq (worked out again only when freq
+                // changes), read between samples and between frames.
+                let s = S + Int(code[at + 7])
+                // The table is a constant register's, the same in every lane.
+                let index = a[0]
+                let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
+                let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
+                let T = tablePointers[t]
+                let base = 0
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let p = s[l]
+                        let f = b[el]
+                        let dt = f / sr
+                        if s[L + l] != f {
+                            s[L + l] = f
+                            var level = 0
+                            let allowed = 0.5 * Double(sr) / Double(Swift.abs(f))
+                            if allowed < 512 {
+                                let octaves = Foundation.log2(512 / allowed)
+                                level = octaves > 8 ? 9 : Int(octaves.rounded(.up))
+                            }
+                            s[2 * L + l] = Float(level)
+                        }
+                        let level = Int(s[2 * L + l])
+                        // NaN reads as 0 here, as in the JavaScript machine.
+                        let morph = c[el] > 0 ? (c[el] < 1 ? c[el] : 1) : 0
+                        let position = morph * Float(frames - 1)
+                        // Never below 0: truncating is rounding down.
+                        let f0 = Int(position)
+                        let f1 = Swift.min(f0 + 1, frames - 1)
+                        let ff = position - Float(f0)
+                        let x = p * 2048
+                        // A phase gone to NaN reads NaN, which the block's check silences.
+                        let i0 = x >= 0 && x < 2048 ? Int(x) : x.isFinite ? Int(x.rounded(.down)) : 0
+                        let fr = x - Float(i0)
+                        let j0 = i0 & 2047
+                        let j1 = (i0 + 1) & 2047
+                        // Samples j0 and j1, each its frames side by side.
+                        let row0 = base + (level * 2048 + j0) * frames
+                        let row1 = base + (level * 2048 + j1) * frames
+                        let v0 = T[row0 + f0] + (T[row1 + f0] - T[row0 + f0]) * fr
+                        let v1 = T[row0 + f1] + (T[row1 + f1] - T[row0 + f1]) * fr
+                        d[el] = v0 + (v1 - v0) * ff
+                        let next = p + dt
+                        s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
+                    }
+                }
+            case 51:
+                // delay(input, seconds, longest): read at least a sample back, between samples, then write.
+                let s = S + Int(code[at + 7])
+                let length = Int(code[at + 10])
+                let mask = length - 1
+                let memory = delaySamples + Int(code[at + 9])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let w = Int(s[l])
+                        let x = a[el]
+                        var ds = b[el] * sr
+                        ds = ds >= 1 ? (ds <= Float(length - 2) ? ds : Float(length - 2)) : 1
+                        let position = Float(w) - ds
+                        let i0 = Int(position.rounded(.down))
+                        let fr = position - Float(i0)
+                        let line = memory + l * length
+                        let v0 = line[i0 & mask]
+                        let v1 = line[(i0 + 1) & mask]
+                        d[el] = v0 + (v1 - v0) * fr
+                        line[w & mask] = x
+                        s[l] = Float((w + 1) & mask)
+                    }
+                }
+            case 52:
+                // shape(shape, x): x 0 … 1 along it, between points.
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], shapeLengths.count)
+                        let points = shapeLengths.isEmpty ? 1 : shapeLengths[t]
+                        let P = shapePointers[t]
+                        let base = 0
+                        let x = b[el]
+                        let position = (x > 0 ? (x < 1 ? x : 1) : 0) * Float(points - 1)
+                        let i0 = Int(position.rounded(.down))
+                        let v0 = P[base + i0]
+                        let v1 = P[base + Swift.min(i0 + 1, points - 1)]
+                        d[el] = v0 + (v1 - v0) * (position - Float(i0))
+                    }
+                }
+            case 53:
+                // play(sample, rate, start): from start (0 … 1 along it) at each note on, at rate (1 its own pitch),
+                // between samples; silent past either end. Where it plays is a whole sample and the fraction past it,
+                // so it keeps time.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let A = samplePointers[t]
+                        let base = 0
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            let start = c[el]
+                            let p = (start > 0 ? (start < 1 ? start : 1) : 0) * Float(length - 1)
+                            s[l] = p.rounded(.down)
+                            s[L + l] = p - p.rounded(.down)
+                        }
+                        let index = s[l]
+                        let fraction = s[L + l]
+                        var v: Float = 0
+                        if index >= 0 && index < Float(length) {
+                            // Past the last sample, silence.
+                            let k = base + Int(index)
+                            let after = index < Float(length - 1) ? A[k + 1] : 0
+                            v = A[k] + (after - A[k]) * fraction
+                        }
+                        d[el] = v
+                        var step = b[el] * (sampleRatios.isEmpty ? 1 : sampleRatios[t])
+                        step = step > -65536 ? (step < 65536 ? step : 65536) : -65536
+                        let next = fraction + step
+                        let whole = next.rounded(.down)
+                        let moved = index + whole
+                        s[l] = moved > -1 ? (moved < Float(length) ? moved : Float(length)) : -1
+                        s[L + l] = next - whole
+                    }
+                }
+            case 78:
+                // tableread(table, phase, freq, position): wavetable's read, at a phase the program keeps (wrapped to
+                // 0 … 1), at the level that cannot alias at freq (worked out again only when freq changes).
+                let s = S + Int(code[at + 7])
+                let e = register(5)
+                // The table is a constant register's, the same in every lane.
+                let index = a[0]
+                let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
+                let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
+                let T = tablePointers[t]
+                let base = 0
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let f = c[el]
+                        if s[l] != f {
+                            s[l] = f
+                            var level = 0
+                            let allowed = 0.5 * Double(sr) / Double(Swift.abs(f))
+                            if allowed < 512 {
+                                let octaves = Foundation.log2(512 / allowed)
+                                level = octaves > 8 ? 9 : Int(octaves.rounded(.up))
+                            }
+                            s[L + l] = Float(level)
+                        }
+                        let level = Int(s[L + l])
+                        let morph = e[el] > 0 ? (e[el] < 1 ? e[el] : 1) : 0
+                        let position = morph * Float(frames - 1)
+                        let f0 = Int(position)
+                        let f1 = Swift.min(f0 + 1, frames - 1)
+                        let ff = position - Float(f0)
+                        let phase = b[el]
+                        // 0 … 1 (1 itself, as a phase just below 0 rounds to); NaN past infinities.
+                        let p = phase - phase.rounded(.down)
+                        let x = p * 2048
+                        let i0 = x >= 0 && x <= 2048 ? Int(x) : 0
+                        let fr = x - Float(i0)
+                        let j0 = i0 & 2047
+                        let j1 = (i0 + 1) & 2047
+                        let row0 = base + (level * 2048 + j0) * frames
+                        let row1 = base + (level * 2048 + j1) * frames
+                        let v0 = T[row0 + f0] + (T[row1 + f0] - T[row0 + f0]) * fr
+                        let v1 = T[row0 + f1] + (T[row1 + f1] - T[row0 + f1]) * fr
+                        d[el] = v0 + (v1 - v0) * ff
+                    }
+                }
+            case 79:
+                // loop(sample, rate, start): play's, but round and round: past either end it comes in at the other.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let A = samplePointers[t]
+                        let base = 0
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            let start = c[el]
+                            let p = (start > 0 ? (start < 1 ? start : 1) : 0) * Float(length - 1)
+                            s[l] = p.rounded(.down)
+                            s[L + l] = p - p.rounded(.down)
+                        }
+                        // Always a sample of this one, though a lane's index may change samples under it.
+                        let index = ((Int(s[l]) % length) + length) % length
+                        let fraction = s[L + l]
+                        let k = base + index
+                        let after = index < length - 1 ? A[k + 1] : A[base]
+                        d[el] = A[k] + (after - A[k]) * fraction
+                        var step = b[el] * (sampleRatios.isEmpty ? 1 : sampleRatios[t])
+                        step = step > -65536 ? (step < 65536 ? step : 65536) : -65536
+                        let next = fraction + step
+                        let whole = next.rounded(.down)
+                        s[l] = Float((((index + Int(whole)) % length) + length) % length)
+                        s[L + l] = next - whole
+                    }
+                }
+            case 54:
+                // grains(sample, position, density, length, pitch): a grain every 1 / density seconds from position
+                // (0 … 1 along the sample, and up to 20 ms on), length seconds (0.001 … 1) long, at pitch (1/16 …
+                // 16, 1 its own), under a parabola; up to 8 at once (with none free, one is skipped).
+                let s = S + Int(code[at + 7])
+                let lengthIn = register(5)
+                let pitchIn = register(6)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let A = samplePointers[t]
+                        let base = 0
+                        let ratio = sampleRatios.isEmpty ? 1 : sampleRatios[t]
+                        let density = c[el]
+                        var countdown = s[l]
+                        if density > 0 {
+                            if countdown <= 0 {
+                                var g = 0
+                                while g < 8 && s[(3 + 4 * g) * L + l] < s[(4 + 4 * g) * L + l] { g += 1 }
+                                if g < 8 {
+                                    let random = UnsafeMutableRawPointer(s + L + l)
+                                    var x = random.load(as: UInt32.self)
+                                    x ^= x << 13
+                                    x ^= x >> 17
+                                    x ^= x << 5
+                                    random.storeBytes(of: x, as: UInt32.self)
+                                    let position = b[el]
+                                    let spray = sampleSprays.isEmpty ? 1 : sampleSprays[t]
+                                    let start = ((position > 0 ? (position < 1 ? position : 1) : 0) * Float(length - 1)).rounded(.down) + Float(x % spray)
+                                    let seconds = lengthIn[el]
+                                    let frames = ((seconds > 0.001 ? (seconds < 1 ? seconds : 1) : 0.001) * sr).rounded(.down)
+                                    let pitch = pitchIn[el]
+                                    let w = s + (2 + 4 * g) * L + l
+                                    w[0] = start < Float(length - 1) ? start : Float(length - 1)
+                                    w[L] = 0
+                                    w[2 * L] = frames > 1 ? frames : 1
+                                    w[3 * L] = (pitch > 0.0625 ? (pitch < 16 ? pitch : 16) : 0.0625) * ratio
+                                }
+                                let interval = sr / density
+                                countdown += interval > 1 ? interval : 1
+                            }
+                            countdown -= 1
+                        } else {
+                            countdown = 0
+                        }
+                        s[l] = countdown
+                        var sum: Float = 0
+                        for g in 0..<8 {
+                            let w = s + (2 + 4 * g) * L + l
+                            let age = w[L]
+                            let frames = w[2 * L]
+                            guard age < frames else { continue }
+                            let offset = age * w[3 * L]
+                            let whole = offset.rounded(.down)
+                            let index = w[0] + whole
+                            if index >= 0 && index < Float(length - 1) {
+                                let k = base + Int(index)
+                                let v = A[k] + (A[k + 1] - A[k]) * (offset - whole)
+                                let phase = age / frames
+                                sum += v * (4 * phase * (1 - phase))
+                            }
+                            w[L] = age + 1
+                        }
+                        d[el] = sum
+                    }
+                }
+            case 57:
+                // modsum(routes): Σ amount × source over the list, route by route. An amount is a parameter, the same
+                // in every lane, so a route at 0 is passed over once for all of them and costs nothing.
+                each { d[$0] = 0 }
+                let index = Self.index(a[0], routeCount)
+                guard index < routeCount else { break }
+                var k = index * DSPProgram.routesMax
+                let end = k + routeCounts[index]
+                while k < end {
+                    let amount = R + routeRegisters[k + 1]
+                    let source = R + routeRegisters[k] + (routeState[k] ? 0 : shift)
+                    k += 2
+                    if amount[0] == 0 { continue }
+                    each { d[$0] += amount[$0] * source[$0] }
+                }
+            case 55:
+                // smooth(input, seconds): toward the input by 1 − e^(−1 / (seconds × sampleRate)) a frame, from where
+                // the input is on its first.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let x = a[el]
+                        var y = s[l]
+                        if y.isNaN { y = x }
+                        let time = b[el]
+                        if !(s[L + l] == time) {
+                            s[L + l] = time
+                            let frames = time * sr
+                            s[2 * L + l] = frames > 1 ? -Foundation.expm1(-1 / frames) : 1
+                        }
+                        y += (x - y) * s[2 * L + l]
+                        s[l] = y
+                        d[el] = y
+                    }
+                }
+            case 56:
+                // hold(input, trigger): takes the input as the trigger rises above 0.5, and keeps it.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = b[el]
+                        if t > 0.5 && !(s[L + l] > 0.5) { s[l] = a[el] }
+                        s[L + l] = t
+                        d[el] = s[l]
                     }
-                    let a1 = s[4 * L + l]
-                    let a2 = s[5 * L + l]
-                    let a3 = s[6 * L + l]
-                    let ic1 = s[l]
-                    let ic2 = s[L + l]
-                    let x = a[l]
-                    let v3 = x - ic2
-                    let v1 = a1 * ic1 + a2 * v3
-                    let v2 = ic2 + a2 * ic1 + a3 * v3
-                    s[l] = 2 * v1 - ic1
-                    s[L + l] = 2 * v2 - ic2
-                    d[l] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
                 }
             default:
                 break
             }
-            at += 8
         }
     }
 }
+
+/// Memory a machine reads (a table's samples, a shape's points, a sample's audio), made off the audio thread and
+/// swapped into a machine whole (`replaceTable` …). After a swap it holds what the machine let go of: freed with it,
+/// off the audio thread.
+/// A fixed number of values in memory of their own, each changed in place: what the machine reads as it renders and
+/// swaps when data is replaced, with no exclusivity checks (as an array property changed in place would need).
+struct Slots<Element> {
+    let base: UnsafeMutablePointer<Element>
+    let count: Int
+
+    init(_ values: [Element]) {
+        count = values.count
+        base = .allocate(capacity: Swift.max(1, values.count))
+        base.initialize(from: values, count: values.count)
+    }
+
+    var isEmpty: Bool { count == 0 }
+
+    subscript(i: Int) -> Element {
+        get { base[i] }
+        nonmutating set { base[i] = newValue }
+    }
+
+    func deallocate() {
+        base.deinitialize(count: count)
+        base.deallocate()
+    }
+}
+
+public final class DSPBuffer: @unchecked Sendable {
+    public fileprivate(set) var pointer: UnsafeMutablePointer<Float>
+    public fileprivate(set) var count: Int
+
+    /// `values`, copied.
+    public init(_ values: [Float]) {
+        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: Swift.max(1, values.count))
+        pointer.initialize(repeating: 0, count: Swift.max(1, values.count))
+        values.withUnsafeBufferPointer { if let base = $0.baseAddress { pointer.update(from: base, count: values.count) } }
+        self.pointer = pointer
+        count = values.count
+    }
+
+    fileprivate init(taking pointer: UnsafeMutablePointer<Float>, count: Int) {
+        self.pointer = pointer
+        self.count = count
+    }
+
+    deinit {
+        pointer.deallocate()
+    }
+}