MIDI Processing

Throughline can treat MIDI as material in its own right. A MIDI node takes a stream on MIDI In, changes it, and passes it out of MIDI Out — so you build a MIDI chain the same way you build an audio chain, left to right, and order matters.

This is what the Throughline MIDI plugin variant is for: it takes MIDI from the host and returns MIDI, so you can shape a performance before it reaches some other instrument. The same nodes work inside the Synth and FX variants when you want to shape MIDI before it hits your own voice.

The Shape of a MIDI Chain

Everything starts at MIDI Input and ends either at MIDI Output or at a node that turns MIDI into signals.

graph LR
    IN[MIDI Input] -->|MIDI| PROC[MIDI processors]
    PROC -->|MIDI| DEC[MIDI Decode]
    PROC -->|MIDI| OUT[MIDI Output]
    DEC -->|Pitch / Gate| VOICE[Voice]

MIDI ports never coerce. A MIDI cable connects to a MIDI port or it does not connect at all, so a chain that patches together is a chain that is carrying real events. To get numbers out of MIDI, use MIDI Decode — see Data Types and Conversion.

Choosing What Gets Through

• MIDI Channel narrows a stream to one channel. Set Channel to All to pass everything, or 1–16 to keep only that channel. Put one at the head of each branch when several controllers or DAW channels share an input.
• MIDI Filter is the general gate. Min Note and Max Note set a note range, and separate toggles pass or block Note On, Note Off, CC, and Pitch Bend. Use it to drop controller data you do not want, or to restrict a branch to notes only.
• MIDI Split passes only notes inside its Min Note to Max Note range. To build a keyboard split, run two branches from the same source with complementary ranges — one node does not fan out to two outputs.
• MIDI Merge combines several streams back into one. Feed a keyboard into MIDI A, a generated part into MIDI B, and so on.

graph LR
    IN[MIDI Input] -->|MIDI| LOW[MIDI Split 0-59]
    IN -->|MIDI| HIGH[MIDI Split 60-127]
    LOW -->|MIDI| BASS[Bass voice]
    HIGH -->|MIDI| LEAD[Lead voice]

Changing Pitch

• MIDI Transpose shifts notes by Semitones (−48 to +48) and Octaves (−4 to +4). Clamp to MIDI keeps the result inside 0–127 instead of letting notes fall off the ends of the keyboard.
• MIDI Scale Quantize snaps notes to a root and scale, so out-of-key notes move to the nearest allowed degree. Put it after anything that randomises pitch.
• MIDI Chord turns each incoming note into a chord, adding configured intervals above the root. One finger becomes a voicing.

MIDI Transpose is the right node for a fixed interval shift. Do not use the arithmetic nodes for this — they do raw math on numbers and know nothing about notes. See Math and Logic.

For key and scale as a shared, visible decision rather than a per-node setting, patch a Scale node into the Scale input of MIDI Scale Quantize. See Pitch and Scales.

Changing Velocity

• MIDI Velocity Curve reshapes how playing force maps to output velocity. Use it to make an instrument feel softer or more aggressive, or to compensate for a controller that feels wrong.
• MIDI Velocity Clamp scales velocity and then holds it between Min Velocity and Max Velocity. Use it to guarantee a minimum strike level or to stop a part from ever hitting full.

Both leave pitch and timing untouched.

Changing Timing

• MIDI Delay echoes notes in the MIDI domain rather than the audio domain, in milliseconds or synced to a clock. The downstream instrument renders each repeat with its own sound, so repeats stay articulate in a way an audio delay cannot match.
• MIDI Ratchet retriggers each note as a burst of faster subdivisions, for rolls, stutters, and fills. Its Clock input drives tempo-synced spacing.
• MIDI Gate Length reshapes note duration by moving note-offs. Absolute mode enforces a fixed length whatever you play. Scale mode extends notes proportionally, and only ever lengthens — it will not cut short a note you are still holding.
• MIDI Humanize loosens mechanical playback with small timing and velocity variation. Timing is nudged later rather than earlier, because a live note cannot be moved into the past.

Chance and Variation

• MIDI Probability lets each note through only some of the time.
• MIDI Randomize varies pitch and velocity within bounds you set.

Both offer a seeded Reproducible mode and a Free run mode. In Reproducible mode the seeded sequence restarts once when the transport moves from stopped to playing, so a bounced take matches what you heard. Free run keeps the live sequence running across transport starts. Loading a patch or resetting the node restarts the seed either way.

Follow a randomiser with MIDI Scale Quantize to keep the variation in key.

Holding and Limiting

• MIDI Latch keeps notes sounding after you let go. Toggle holds each note until its next note-on, Hold passes note-ons and note-offs while tracking what is down, and Replace releases held notes whenever a new note-on arrives. A rising edge on Reset emits a note-off for everything held, then clears the latch.
• MIDI Voice Limit caps how many notes may sound at once and emits note-offs for the notes it steals. Use it to protect a limited-voice instrument or to deliberately thin a dense passage.
• MIDI Panic emits all-channel resets from a Trigger. This is the recovery hatch for a stuck note.

MIDI Voice Limit caps notes in a MIDI stream. To cap the voices of an authored Throughline voice, use the Voices control on a Polyphony Zone instead.

Watching the Stream

MIDI Monitor lists events as they arrive and passes the stream through unchanged, so it can live in the patch permanently. When a MIDI chain misbehaves, drop one in above and below the suspect node to find where the stream stops looking right. See Inspecting Signals.

Crossing Between MIDI and Signals

CC Emit is how internal modulation reaches the outside world: send an LFO or envelope into it and set CC Number. It emits on channel 1; use MIDI Channel to filter a stream, or the Channel control on MIDI Input and MIDI Output for I/O routing.

Common Patch Examples

Harmonise what you play, in key

1. MIDI Input → MIDI Chord.
2. MIDI Chord → MIDI Scale Quantize.
3. Out to MIDI Output or into a Polyphony Zone.

graph LR
    IN[MIDI Input] -->|MIDI| CHORD[MIDI Chord]
    CHORD -->|MIDI| QUANT[MIDI Scale Quantize]
    QUANT -->|MIDI| ZONE[Polyphony Zone]

Loosen a rigid sequence

1. Host or arpeggiator MIDI → MIDI Humanize for timing and velocity spread.
2. → MIDI Probability to thin the pattern.
3. → MIDI Velocity Curve to reshape the dynamics that survive.

Set both random nodes to Reproducible while you are still deciding, so each pass sounds the same.

Recover from a stuck note

1. Drive MIDI Panic Trigger from any trigger source — the Changed output of a Compare watching a control you can reach, or the Trigger output of MIDI Decode on a note you reserve for the job.
2. MIDI Panic MIDI Out → MIDI Merge alongside your normal stream.

Assigning that control to a Macro gives you a panic button you can hit from the host.

Rules of Thumb

• MIDI chains run left to right, and order changes the result. Quantize after you randomise, not before.
• MIDI never coerces. If a cable connects, the types already agree.
• Use MIDI nodes for musical edits to notes; use math nodes only on control signals.
• Set random nodes to Reproducible while writing, Free run when performing.
• Reach for MIDI Monitor before guessing which node broke the stream.
• Use the Throughline MIDI variant when the destination instrument is somewhere else in your project.