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.
| 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). An Enable switch mutes the pattern without losing your hands' position: the arp keeps watching the keyboard while it is off, and switching it back on resumes from whatever you are still holding.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Enable | On / Off | On | Off stops the arp from sending notes (ending the sounding one cleanly) while it keeps tracking held keys; back on, the pattern resumes from what you are holding. Drive it from a Toggle or a gate to punch the arp in and out. |
| 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, Enable, Transport, BPM, Cycle, Swing, Gate, Direction, Octaves, Latch, Out Ch. Outputs: MIDI Out (the arpeggio), Current Step (which step is playing, counted from 0, and -1 while nothing sounds; sent whenever it changes).
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.
| 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.
| 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.
Inputs: A, B, C, D (MIDI streams). Outputs: MIDI Out (the merged stream).
MIDI Pass
A pass-through that changes nothing: whatever MIDI comes in goes straight out, untouched. That sounds like doing nothing, but it makes a handy junction point. Give it a clear name and use it to gather several cables into one spot, fan one stream out to many places, keep long cable runs tidy, or hold a place in the chain while you are still building the patch. It is the MIDI version of CV Pass and Sig Pass.
Inputs: MIDI In. Outputs: MIDI Out (the same MIDI, unchanged).
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.
| 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 Convert
Converts one kind of MIDI message into another. It reads the value carried by the message type you pick in From (a note's velocity or note number, a knob or slider movement (CC), pitch bend, channel or poly pressure, or a program change), keeps its relative position, and sends it back out as the message type you pick in To. A classic use is turning how hard you play into a control stream: set From to Note Velocity and To to CC, and every note's loudness comes out as a CC you can route anywhere.
| Parameter | Range | Default | Description |
|---|---|---|---|
| From | Note Velocity, Note Number, CC, Pitch Bend, Channel Pressure, Poly Pressure, Program Change | Note Velocity | Which message type to read the value from. |
| From CC | 0 to 127 | 1 | The controller number to match. Only used when From is CC. |
| To | CC, Pitch Bend, Channel Pressure, Program Change | CC | Which message type to send instead. |
| To CC | 0 to 127 | 1 | The controller number to send. Only used when To is CC. |
| Keep Original | On / Off | Off | When on, the matched message is also passed along, so you extract a copy instead of replacing it. |
| Pass Through | On / Off | On | When on, every message that does not match From passes through unchanged. |
The converted message stays on the channel of the message it came from. All six controls can be set on the node or driven from inputs.
Inputs: MIDI In, From, From CC, To, To CC, Keep Original, Pass Through. Outputs: MIDI Out (the converted MIDI).
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.
| 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.
| 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 Single Note Remap
Remaps exactly one note to another. When a note matching In Note (and, if you set one, In Channel) arrives, it comes out as Out Note on Out Channel, optionally with a fixed loudness from Out Velocity. Every other message passes through untouched. Where the eight-slot MIDI Note Remap handles a whole set of mappings, this one is for when you just need a single change, like moving one drum pad to a different sound, and it can also change the note's channel and velocity along the way.
| Parameter | Range | Default | Description |
|---|---|---|---|
| In Note | 0 to 127 | 60 | The note number to catch. |
| In Channel | All, 1 to 16 | All | Only match the note on this channel. All matches it on any channel. |
| Out Note | 0 to 127 | 60 | The note number to send instead. |
| Out Channel | All, 1 to 16 | 1 | The channel to send on. All sends the note to all 16 channels at once. |
| Out Velocity | 0 to 127 | 0 | Velocity for the remapped note. 0 keeps the original velocity; 1 to 127 forces that fixed value. |
A note's release always follows where its press was sent, so changing the controls while a note is held never leaves it stuck. Chain a few of these to route different notes to different channels. All five controls can be set on the node or driven from inputs.
Inputs: MIDI In, In Note, In Channel, Out Note, Out Channel, Out Velocity. Outputs: MIDI Out (MIDI with the one note remapped).
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.
| 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.
| 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. |
MIDI Looper
A phrase looper for MIDI. Arm Record, play something, and your notes are captured into a looping step pattern that plays back on top of the live input (which always passes straight through, so you hear what you play). Timing can follow your music software (Sync set to Host, where the DAW transport drives playback) or run on its own clock (Sync set to Internal, driven by the Play, Pause and Stop buttons and Internal BPM). Stop sends the playhead back to the start like a classic looper, while Pause holds the position so Play carries on from where it left off. The body shows the loop grid, the playhead and the current state (IDLE, PLAY or REC), and it can be placed on the front panel. Recorded takes are saved with the project.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Record | On / Off | Off | Arms recording. Incoming notes are written into the current slot while it is on. |
| Play / Pause / Stop | Buttons / triggers | n/a | Transport for the internal clock. Stop rewinds to the start; Pause keeps the position. In Host sync your music software's transport is in charge instead. |
| Clear | Button / trigger | n/a | Empties the current slot. |
| Slot | 1 to 8 | 1 | Which of the eight pattern memories to record into and play. |
| Steps | 1 to 64 | 16 | Loop length in steps (when Auto Length is off). |
| Rate | Bars and note values (dotted and triplet included) | 1/16 | Musical length of each step. |
| Out Channel | 1 to 16 | 1 | Channel the looped notes play back on. |
| Sync | Host, Internal | Host | Host follows your music software's transport and tempo; Internal uses the built-in clock. |
| Internal BPM | 20 to 300 | 120 | Tempo used in Internal mode. |
| Quantize | On / Off | On | When on, recorded notes snap to the step grid. When off, their exact timing inside the step is kept. |
| Overdub | On / Off | On | When on, new recordings layer on top of what is already there. When off, arming Record starts a fresh take that replaces the old one. |
| Auto Length | On / Off | Off | When on, the first recording defines the loop length: arm Record, play, and the loop locks its length when you Stop, Pause or disarm Record. Leave off to use the fixed Steps length. |
Chords are captured too, with room for up to six notes per step. Every control can be set on the node or driven from an input, so a pedal or a gate can arm recording or fire the transport.
Inputs: MIDI In, Record, Play, Pause, Stop, Clear, Slot, Steps, Rate, Out Channel, Sync, Internal BPM, Quantize, Overdub, Auto Length. Outputs: MIDI Out (the live input plus the looped playback).
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 File Player
Plays a standard MIDI file (.mid or .midi) out of a MIDI output, as if the notes were being performed live. Load a file with the file slot or just drop one onto the node; the body shows the notes it contains. Press Play to start and Stop to end it, or turn on Sync to Host so the file starts, stops and keeps pace with your music software's timeline instead. Use it to feed a synth, an arpeggiator or anything else that takes MIDI.
| Parameter | Range | Default | Description |
|---|---|---|---|
| MIDI File | File picker | n/a | The file to play. You can also drop a .mid file straight onto the node. |
| Play / Stop | Buttons / triggers | n/a | Start and stop playback when Sync to Host is off. |
| Loop | On / Off | Off | When on, the file repeats from the top when it reaches the end. |
| Sync to Host | On / Off | Off | When on, the file follows your music software's play, stop and tempo and rides the timeline. |
| Speed | 1/4x, 1/3x, 1/2x, 2/3x, 3/4x, 1x, 1.5x, 2x, 3x, 4x | 1x | Playback speed when Sync to Host is off. |
On stop and at the loop point it sends All Notes Off so nothing keeps ringing. The Play input also works as a gate: an on value starts playback and an off value stops it, so a single toggle or footswitch can run the whole transport. Loop, Sync and Speed can be driven from inputs too.
Inputs: File, Play, Stop, Loop, Sync, Speed. Outputs: MIDI Out (the file's MIDI events).
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.
| 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.
| 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).