Appearance
MIDI
MIDI is the language that carries notes, control movements and timing around your patch. Think of it as the performance instructions ("play this note, this loud, for this long") rather than the sound itself. The MIDI nodes work with that data: some bring MIDI in from your music software or keyboard and send it back out, others reshape notes by moving them up or down, fitting them to a key, building chords or turning held notes into running patterns, and a few create fresh patterns or convert control movements to and from CV (the internal signal MNodes uses to move knobs and modulate sound). Most controls double as inputs, so you can drive them from elsewhere in the patch. The note-changing nodes also keep careful track of which notes are being held, so changing a setting in the middle of a note never leaves a note ringing forever.
MIDI In
This is where MIDI enters your patch. In plugin mode it picks up everything coming from your music software (your DAW), and in standalone mode it picks up everything from your connected MIDI keyboard or controller. Every kind of message on the track comes through: notes, knob and slider movements (CC), pitch bend, the tempo clock and more.
Inputs: none. Outputs: In (all MIDI messages from the host).
MIDI Out
This is where MIDI leaves your patch and goes back to your music software. Use it to record what your patch is playing, send notes to other plugins, or play external hardware instruments.
Inputs: Out (MIDI messages to send to the host). Outputs: none.
MIDI Keyboard
A playable piano keyboard built right into the node. Click or drag across the keys to play notes. Any MIDI coming in is passed along too, blended together with the notes you play by hand. With Hold turned on, both the keys you click and the notes coming in stay on until you trigger them again, instead of only sounding while pressed.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Hold | On / Off | Off | When on, notes latch (toggle on/off) instead of behaving momentarily. Turning it off releases latched notes. |
| Channel | 1 to 16 | 1 | Output channel for notes played from the keyboard UI. Does not rewrite incoming MIDI channels. |
| Min Note | 0 to 126 | 48 | Lowest visible note of the keyboard range. |
| Max Note | 1 to 127 | 84 | Highest visible note of the keyboard range. |
How hard a clicked note sounds (its velocity) depends on where you click: clicking lower on a key plays it louder. Hold, Channel, Min Note and Max Note can be set right on the node or driven from inputs. There is also an Appearance input that takes a small block of JSON text so you can change the key labels and colours.
Inputs: MIDI In, Hold, Channel, Min Note, Max Note, Appearance (JSON). Outputs: MIDI Out (incoming MIDI merged with the notes you play).
MIDI Monitor
A live, scrolling readout of every MIDI message flowing through. It shows note presses and releases, knob and slider movements (CC), pitch bend, timing and more as they happen, which makes it the first node to grab when your MIDI is not doing what you expect.
Inputs: MIDI (the stream to monitor). Outputs: none.
MIDI Note Trigger
Turns a simple trigger (a quick "go" signal) into an actual MIDI note with a pitch, loudness, length and channel you choose. It is the bridge between trigger-style logic and instruments that expect notes: the note starts the moment the trigger fires and ends after the time you set in Length (measured in milliseconds, where 1000 ms is one second).
| Parameter | Range | Default | Description |
|---|---|---|---|
| Note | 0 to 127 | 60 | MIDI note number to play. |
| Velocity | 1 to 127 | 100 | Velocity used for the note. |
| Length | 1 to 10000 ms | 250 ms | How long the note stays on before it is released. |
| Channel | 1 to 16 | 1 | MIDI channel for the generated note. |
The Trigger fires from a click, from an Event, or from any incoming value of 0.5 or higher. Note, Velocity, Length and Channel can also be driven from inputs.
Inputs: Trigger, Note, Velocity, Length, Channel. Outputs: MIDI (the generated note).
MIDI Panic
The emergency stop for stuck notes. Click the button or send it a trigger and it sends a full rescue sequence on every channel at once: it lets go of the Sustain, Sostenuto and Hold 2 pedals, sends a note-off for every possible note, recentres the pitch bend, then fires All Sound Off, All Notes Off and Reset All Controllers. In short, if a note is hanging and will not stop, this clears it.
Needs: the MIDI Panic node with its Panic button, wired to a synth's MIDI input.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Panic | Button / trigger | n/a | Click, or send an Event or rising trigger, to broadcast the panic messages on all 16 channels. |
Inputs: Trigger (fires the panic). Outputs: MIDI (the panic messages on every channel).
MIDI Octave
Moves incoming notes up or down by whole octaves (steps of twelve, so the same note name but higher or lower), while letting everything that is not a note pass straight through. Notes that are already being held keep the shift they started with, so nudging the control while a note is down never leaves it stuck.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Octaves | -4 to +4 | 0 | Octaves to shift. +1 moves up 12 semitones, -1 down 12, 0 passes through. |
The Octaves control can be set on the node or driven from an input.
Inputs: MIDI In, Octaves. Outputs: MIDI Out (octave-shifted MIDI).
MIDI Chord
Turns each single note you play into a full chord built on that note. The chord shape you pick is stacked on top of whatever note comes in, so the same shape follows you to every key. Anything that is not a note passes through, and the node keeps track of overlapping chord notes so they all release correctly.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Chord | Built-in chord types | First chord in the list | Chord shape applied above each incoming note. |
The Chord control can be set on the node or driven from an input.
Inputs: MIDI In, Chord. Outputs: MIDI Out (chord-expanded MIDI).
MIDI Arpeggiator
Takes a held chord and plays its notes one after another as a running pattern (an arpeggio). It gives you eight different play orders, swing for a more human feel, control over how long each note rings, the option to spread notes across extra octaves, and a latch to keep the pattern going after you let go. It can run on its own built-in tempo or follow the play/stop and tempo of your music software (the transport).
| Parameter | Range | Default | Description |
|---|---|---|---|
| Transport Source | Internal, Transport (DAW) | Transport (DAW) in plugin mode, Internal in standalone | Clock source: the internal BPM, or the host transport. |
| BPM | 20 to 300 | 120 | Tempo used in Internal mode. |
| Cycle | Bars and note values (dotted and triplet included) | 1/16 | Musical length of each arp step. |
| Swing | 50 to 99 % | 50 | Swing amount. 50 is straight; higher delays the odd steps. |
| Gate | 1 to 100 % | 75 | Note length as a percentage of the step length. |
| Direction | Up, Down, UpDown, DownUp, Played, Reverse Played, Random, Chord | Up | How the held notes are sequenced. Chord plays them all at once. |
| Octaves | -4 to +4 | 0 | Octave spread. 0 is the original octave only. |
| Latch | On / Off | Off | When on, notes keep playing after keys are released; new notes add to the pattern. |
| Out Channel | Input, 1 to 16 | Input | Output channel. Input keeps each note on its incoming channel. |
Every control can be set on the node or driven from an input.
Inputs: MIDI In, Transport, BPM, Cycle, Swing, Gate, Direction, Octaves, Latch, Out Ch. Outputs: MIDI Out (the arpeggio), Current Step (the active step index).
MIDI Scale
Pulls any incoming note onto a key you choose. Notes that do not belong to the key are nudged to the nearest note that does, which is a handy way to keep random or auto-generated MIDI sounding in tune and in key. The piano keyboard part of the node can be placed on the front panel, and clicking its keys lets you build your own Custom scale.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Root | C, C#, D, D#, E, F, F#, G, G#, A, A#, B | C | Root note of the scale. |
| Scale | Built-in scales (Major, Minor and more) plus Custom | Second preset in the list | Which scale to snap notes to. |
Root and Scale can be set on the node or driven from inputs, and both update continuously at stream rate. Anything that is not a note passes through untouched. There is also an Appearance input that takes a small block of JSON text so you can change the keyboard's colours.
Inputs: MIDI In, Root, Scale, Appearance (JSON). Outputs: MIDI Out (the quantized notes).
MIDI Transpose
Moves every incoming note up or down in semitones (the smallest steps between piano keys), up to two octaves in either direction. It is the quick way to change key without re-recording anything. Non-note messages pass through, and notes already being held keep the shift they started with.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Semitones | -24 to +24 | 0 | Semitones to shift. +12 is an octave up, +7 a perfect fifth, 0 passes through. |
The Semitones control can be set on the node or driven from an input.
Inputs: MIDI In, Semitones. Outputs: MIDI Out (transposed MIDI).
MIDI Velocity
Adjusts how loud incoming notes are (their velocity). The new loudness is the original loudness multiplied by Scale %, then with Offset added on top, kept within the usual 1 to 127 range. Everything else in the MIDI stream passes through unchanged.
Needs: the MIDI Velocity node with its Scale and Offset controls reshaping note dynamics.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Scale % | 0 to 400 % | 100 | Velocity multiplier. 100 leaves it unchanged, 50 halves it, 200 doubles it, 0 makes Offset a fixed value. |
| Offset | -127 to +127 | 0 | Added to the velocity after scaling. The result is clamped to 1-127. |
To make every note the same fixed loudness, set Scale to 0 and put your chosen level in Offset. Scale and Offset can be set on the node or driven from inputs.
Inputs: MIDI In, Scale, Offset. Outputs: MIDI Out (MIDI with transformed note velocities).
MIDI Set Channel
Moves every message that belongs to a channel (notes, knob and slider movements, aftertouch, pitch bend and program change) onto one channel you pick. Messages that do not belong to any channel, like the tempo clock, the transport and SysEx, pass through unchanged.
Needs: the MIDI Set Channel node with its Channel control re-routing a MIDI stream.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Channel | 1 to 16 | 1 | Target channel for all channel-voice messages. |
The Channel control can be set on the node or driven from an input.
Inputs: MIDI In, Channel. Outputs: MIDI Out (MIDI with all channel messages re-assigned).
MIDI Merge
Joins up to four separate MIDI streams into one. Every message from each connected input is sent on to the single output with its timing kept intact. Useful for putting split MIDI back together, or for stacking several MIDI nodes into one stream before MIDI Out.
Needs: the MIDI Merge node with several MIDI sources wired into inputs A to D and one output.
Inputs: A, B, C, D (MIDI streams). Outputs: MIDI Out (the merged stream).
MIDI CC Transform
Reassigns one knob or slider control (a CC) to a different one, and can scale or shift its value along the way. Messages that match From CC come back out as To CC, with the value multiplied by Scale % and then with Offset added, kept within 0 to 127. Everything else, including controls that do not match, passes through unchanged.
Needs: the MIDI CC Transform node with From CC, To CC, Scale and Offset controls retargeting a controller.
| Parameter | Range | Default | Description |
|---|---|---|---|
| From CC | 0 to 127 | 1 | Controller number to match (1 is the mod wheel). |
| To CC | 0 to 127 | 1 | Controller number to emit instead. |
| Scale % | 0 to 400 % | 100 | Value multiplier in percent. |
| Offset | -127 to +127 | 0 | Added to the value after scaling. The result is clamped to 0-127. |
If you set From CC and To CC to the same number, you can scale or shift a control without changing which one it is. All four controls can be set on the node or driven from inputs.
Inputs: MIDI In, From CC, To CC, Scale, Offset. Outputs: MIDI Out (MIDI with the matching CC transformed).
MIDI Note Filter
Lets notes through, or holds them back, depending on where they sit on the keyboard. Notes between the Low and High note are either kept (Pass Range) or removed (Block Range). A note's release always follows whatever happened to its press, so changing the range while a note is held never leaves it stuck. Other MIDI passes through.
Needs: the MIDI Note Filter node with Low Note, High Note and Mode set for a key split.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Low Note | C-2 to G8 (by letter name) | C-2 (lowest) | Lowest note of the range. |
| High Note | C-2 to G8 (by letter name) | G8 (highest) | Highest note of the range. |
| Mode | Pass Range, Block Range | Pass Range | Pass Range keeps notes inside the range; Block Range removes them. |
You pick the notes by name (for example C3 or F#4), where C3 is middle C. Great for splitting a keyboard into zones, so different ranges of keys can do different things.
Inputs: MIDI In. Outputs: MIDI Out (the filtered stream).
MIDI Note Remap
Swaps individual notes for other notes, chosen by name. You get up to eight From-to-To slots. A slot only does something when its From and To notes are different, and if more than one slot matches, the last matching one wins. Notes you have not mapped keep their pitch, and a note's release follows the new pitch its press was sent to.
Needs: the MIDI Note Remap node with a few From and To slots set, remapping drum-pad notes.
| Parameter | Range | Default | Description |
|---|---|---|---|
| From 1 to From 8 | C-2 to G8 (by letter name) | C3 | The note to match for each slot. |
| To 1 to To 8 | C-2 to G8 (by letter name) | C3 | The note to send instead for each slot. |
Each From and To can be set on the node or driven from an input. Other MIDI passes through unchanged. Handy for rearranging which key triggers which drum or pad.
Inputs: MIDI In, From 1 to From 8, To 1 to To 8. Outputs: MIDI Out (MIDI with remapped notes).
MIDI Sel
A simple two-way MIDI switch. It sends just one of its two inputs (A or B) to the output, so you can flip between two MIDI sources. When you switch, it sends All Notes Off on every channel so nothing gets left hanging.
| Parameter | Range | Default | Description |
|---|---|---|---|
| A/B | Off (A) / On (B) | Off | Selects which input passes through: off routes A, on routes B. |
The A/B control can be set on the node or driven from an input.
Inputs: MIDI A, MIDI B, A/B. Outputs: MIDI Out (the selected input).
MIDI Channel Filter
Lets through only the MIDI coming in on one channel and ignores the rest. Messages that have no channel at all, like the tempo clock, the transport and SysEx, are dropped.
Needs: the MIDI Channel Filter node with its Channel control isolating one channel from a multi-channel stream.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Channel | 1 to 16 | 1 | The channel to keep. Everything else is dropped. |
The Channel control can be set on the node or driven from an input.
Inputs: In, Channel. Outputs: Out (raw MIDI from the selected channel only).
MIDI Channel Gate
Puts out a simple on/off signal (a gate): it reads 1 while any note on the chosen channel is being held, and 0 the rest of the time. Useful for kicking off CV logic whenever there is activity on one particular MIDI channel.
Needs: the MIDI Channel Gate node with its Channel control, its gate output driving an envelope.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Channel | 1 to 16 | 1 | The channel to watch for held notes. |
The Channel control can be set on the node or driven from an input.
Inputs: In, Channel. Outputs: Gate (1 while a note from the selected channel is held, 0 otherwise).
MIDI Riff Generator
A step-by-step MIDI riff maker that plays one note per step. Its timing can lock to your music software, to an outside position or phase signal, or run freely on its own tempo. It can create patterns for you, slide them around, transpose them and loop them. Holding notes transposes the riff, and its step grid (laid out like a keyboard) can be placed on the front panel.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Transport Source | Internal, Transport (DAW), External Position, External Phase | Transport (DAW) in plugin mode, Internal in standalone | Where the sequencer gets its timing. |
| BPM | 20 to 300 | 120 | Tempo used in Internal mode. |
| Cycle | Bars and note values (dotted and triplet included) | 1/16 | Musical length of each step. |
| Swing | 50 to 99 % | 50 | Swing amount. 50 is straight; higher delays the odd steps. |
| Steps | 1 to 128 | 16 | Number of steps in the pattern. |
| Page | Notes, Velocity, Duration | Notes | Which value the step grid edits. |
| Loop Start | 0 to 127 | 0 | First step of the playback loop. |
| Loop Length | 1 to 128 | 16 | Number of steps in the loop. |
| Retrigger | On / Off | On | When on, an incoming note restarts the pattern from the loop start. |
| Keyboard Mode | On / Off | Off | When on, the pattern plays only while a note is held and follows that note. |
| Out Ch | 1 to 16 | 1 | Output MIDI channel. |
| Velocity All | 1 to 127 | n/a | Sets the velocity of every step at once. |
| Duration All | 0.1 to 1.0 | n/a | Sets the note length of every step at once. |
| Complexity | 0 to 100 % | n/a | How busy the generated pattern is when you press Generate. |
| Pattern Out | Full, Active Only | Full | Whether the Pattern Out export includes every step or only active ones. |
Buttons on the node do one-time actions: Play and Stop (in Internal mode), Generate a fresh pattern, Clear it, Step Left / Step Right to roll the steps along, and Semi + / Semi - to transpose. Every control and button can also be driven from an input. A Pattern In takes a step-list in JSON text to load a pattern, and an Appearance input takes a JSON block so you can change the node's colours.
Inputs: MIDI In, Position, Phase, Transport Source, BPM, Cycle, Swing, Steps, Page, Loop Start, Loop Length, Retrigger, Keyboard Mode, Out Ch, Velocity All, Duration All, Play, Stop, Complexity, Generate, Clear, Step Left, Step Right, Semi +, Semi -, Pattern In (JSON), Emit Pattern, Appearance (JSON).
Outputs:
| Output | Description |
|---|---|
| MIDI Out | The generated riff. |
| Current Step | The active step index as CV. |
| Pattern Out | The current pattern as a step-list JSON. |
Pattern To MIDI File
Turns a Pattern (in JSON text) into an actual MIDI file you can save or drag straight into your music software. It is the way to capture patterns you have made, such as one from the MIDI Riff Generator, as proper MIDI clips.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Emit MIDI File | Button / trigger | n/a | Writes the current pattern to a temporary MIDI file and outputs its descriptor. |
A common setup is to run the MIDI Riff Generator's Pattern Out into this node's Pattern In, then send MIDI File Out on to the MIDI Drag Exporter.
Inputs: Pattern In (pattern JSON with step data and timing), Emit MIDI File. Outputs: MIDI File Out (a MIDI file descriptor JSON with the path and file name).
MIDI CC Extract
Watches for one particular knob or slider control (a CC) in the incoming MIDI and turns its position into a steady CV signal in the usual MIDI number range (0 to 127). This lets you take any control your music software or an earlier MIDI node is sending and use it to drive the rest of your patch.
Needs: the MIDI CC Extract node with a CC number selected, its Value output driving a parameter.
| Parameter | Range | Default | Description |
|---|---|---|---|
| CC # | 0 to 127 | 1 | Which controller to capture. Common ones: 1 Mod Wheel, 7 Volume, 10 Pan, 11 Expression, 64 Sustain. |
| Channel | All, 1 to 16 | All | Channel filter. All matches any channel; pick 1-16 to lock to one. |
It holds the last value it received until a new matching control comes along, starting from 0. CC # and Channel can be set on the node or driven from inputs.
Inputs: MIDI In, CC #, Channel. Outputs: Value (the latest CC value, 0-127, held between updates).
MIDI CC Inject
Takes any moving value (from an LFO, an envelope, a slider or your software's automation) and turns it into a MIDI control message (a CC), blending it into the MIDI output. Whatever MIDI arrives on the In pin passes through untouched, so the node sits neatly in the middle of a MIDI chain. Pair it with MIDI CC Extract to grab a control from your software and send it back out as a different control.
Needs: the MIDI CC Inject node with an LFO wired into Value, emitting a CC into the MIDI output.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Value | 0 to 127 | 0 | The CC byte to emit. Drag to test, or feed a CV source already scaled to 0-127. |
| CC # | 0 to 127 | 1 | Which controller number to emit. |
| Channel | 1 to 16 | 1 | MIDI channel for the emitted CC. |
It only sends a new message when the value actually changes, so it does not flood the MIDI stream with repeats. Value, CC # and Channel can be set on the node or driven from inputs.
Inputs: MIDI In, Value, CC #, Channel. Outputs: MIDI Out (the passthrough MIDI plus the generated CC events).
MIDI Voice Allocator
Shares out incoming notes across a set of single-note (mono) outputs, so a chord can be split into one note per output. If you replay the same note it reuses the same output, otherwise it grabs the first free one, and if they are all busy it takes over the one that has been held longest. It handles the Sustain pedal (CC64), All Notes Off and All Sound Off on its own to cut down on stuck notes.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Voices | 1 to 16 | 4 | Number of voice outputs. More outputs appear as you raise the count. |
The Voices count can be set on the node or driven from an input. A common use is one output feeding each single-note MIDI To CV chain.
Inputs: In (polyphonic MIDI), Voices. Outputs: Voice 1 to Voice N (one MIDI stream per allocated voice).
MIDI Pattern Step
Builds a small piece of pattern data (in JSON text) describing a single step. Connect its output straight to the MIDI Riff Generator's Pattern In to set or change just that one step.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Index | 0 to 127 | 0 | Which step this patch targets. |
| Active | On / Off | On | Whether the step plays. |
| Note | 0 to 127 | 60 | MIDI note for the step. |
| Velocity | 1 to 127 | 100 | Velocity for the step. |
| Duration | 0.1 to 1.0 | 1.0 | Note length as a fraction of the step. |
| Emit On Change | On / Off | On | When on, editing any field sends the patch automatically. |
| Emit | Button / trigger | n/a | Re-sends the current one-step patch. |
Every field can be set on the node or driven from an input.
Inputs: Index, Active, Note, Velocity, Duration, Emit On Change, Emit. Outputs: Pattern Out (a JSON array containing one step patch).