Perform

The Perform page holds everything that happens to a note before it becomes sound. Three stages sit between your keyboard and the synth's voices, and they run in a fixed order:

Keys  ->  Script  ->  Chord  ->  Arp  ->  Voices  ->  MIDI Out

The strip along the top of the page draws that path. Each stage lights up when it is doing something and dims when it is passing notes straight through, so the strip shows the route a note actually takes through the patch you have loaded, not the route it could take.

The pill rail on the left opens a page per stage: Arp, Chord, Script.

The order matters

Each stage sees what the one before it produced. That is what lets the stages combine rather than merely coexist.

Hold one key with Chord on and the Arp on: the Chord stage turns the key into a stack of notes, and the Arp arpeggiates that stack. One finger, a running arpeggio in the right key. Turn the Chord stage off and the Arp has only the one note you held, so it repeats it.

A script sits ahead of both. It can hold keys into the pipeline, which means a script can decide the harmony while the Chord stage decides the voicing and the Arp decides the rhythm. It can also rewrite the key you actually pressed, before either stage sees it: snap it into the key, reshape its velocity, or drop it. See the on key handler in Scripting.

Nothing downstream can reach back: the Arp cannot call the script, and a note a script generates never re-enters the script. The path runs one way.

The stages

Keys is what you play. The pipeline starts here. The node shows how many keys you are holding.

Script is the patch's script. It is one of the three things in Kiwisynth that can generate notes, so it belongs on this path, but it does a second job that does not: it also writes the modulation lane. The strip shows that as a separate output leaving the pipeline. See Scripting.

Chord turns one key into a stack of notes, and it is where the key, scale and tuning live. See Chord.

Arp turns whatever is held into a rhythmic pattern. See Arpeggiator. It sits here, with the rest of the note pipeline, and not on the Effects page, because it generates notes and does not process audio.

Voices is where notes become sound. The node shows how many are playing.

MIDI Out sends the generated notes back to your host.

Sending generated notes to your DAW (MIDI Out)

Kiwisynth has three things that generate notes for you: the arpeggiator, the motif player, and a patch's script. Normally those notes only sound inside Kiwisynth. Click the MIDI Out node on the pipeline strip and they are also sent to your host as MIDI, so the pattern your synth is playing can be recorded onto a track, edited by hand, or sent to another instrument.

MIDI Out is off by default, so a patch behaves like an ordinary synth until you ask for it. When it is on:

• The arpeggiator sends the pattern it is playing, note for note. Hold a chord, record the track, and you have the arpeggio as editable MIDI.
• The chord stage sends the notes it built, so a one-finger chord comes back as a real chord you can edit.
• The motif player and a script's played notes are sent the same way.
• Only generated notes are sent. The notes you play on your keyboard are not echoed back, since your host already has them.

Set up a MIDI track in your host, choose Kiwisynth as its input, and arm it to record. This is the way to capture a generative idea and keep it, or to drive a second sound from a pattern Kiwisynth invents.

What this page is not

It is not a sequencer. There is no clip, no piano roll, and no place to draw a pattern in. The stages here react to what you play; they do not store a part. Your host is where a part lives.