MIDI & Your DAW

Phaseburn One lives inside your DAW as an ordinary instrument plugin. Notes play the voice — one voice at a time, by design. Pitch bend bends the sounding note, ±2 semitones by default; the Pitch Bend Range row in the header’s cog menu widens that to as much as ±24 semitones, or ignores the wheel at 0. Control changes (CCs — the messages hardware knobs and faders send) can be mapped to the instrument’s controls through MIDI learn. Velocity — how hard you strike — and the modulation wheel are modulation sources, covered in the modulation chapter (Chapter 4 — Modulation). The host’s clock drives everything tempo-synced — LFO divisions and the sequencer’s bar lines — and a held note is what plays the sequence: one key steers the phrase and keys struck together feed it a chord, and while your DAW plays, its bars are the phrase’s bars. This chapter covers the keys, the mapping and the clock, plus what to try when a particular host has other ideas.

MIDI learn

Put the filter cutoff under a real knob in ten seconds. Right-click the CUTOFF knob on the FX tab, choose MIDI Learn, then turn the hardware knob you want to own it. While it waits, the control’s caption pulses between blue and amber and the help bar at the bottom names what it is listening for, so an armed control is obvious from across the room. Turn a knob and it is captured; the caption settles to a steady blue and the help bar tells you which CC it took.

Only a control you actually move can be captured. A knob that was touched earlier in the session, a pedal you never press, a mod wheel resting somewhere other than zero — none of them can claim the assignment, and neither can a single step of encoder jitter; a sustain pedal you do press captures normally, its full swing easily clearing that threshold. Nothing is armed forever either: Esc cancels, so does clicking anywhere else, and an arm nobody answers gives up after twenty seconds.

To map a whole controller, repeat that gesture control by control. Mappings are one-to-one — a CC drives one control, a control listens to one CC — and learning a CC that is already in use, or re-learning a control, replaces the old pairing. Two CCs can be spoken for before you start: with Program Change In switched on, CC 0 and CC 32 are read as bank select and never reach MIDI learn — see Program change (Chapter 10 — MIDI & Your DAW). There is no separate mapping panel: right-click a mapped control and the same context menu shows which CC it holds, right beside MIDI Forget.

MIDI learn reaches past the host parameters, too. On the Groove page, the GENERATE dials Morph, Busyness, Variation, Line and Spread, and the Humanize knob that leads each of the LENGTH, POSITION and VELOCITY modules, learn a CC the same way and show the same cue; their right-click menu holds just MIDI Learn and MIDI Forget. A CC on Morph moves the Figure relative to where it stood rather than picking one outright, and Soft Takeover does not apply to it (see Automate and learn the Figure (Chapter 8 — Generate)). A CC on a Humanize knob moves its module’s six sliders as dragging the knob does (see Timing feel (Chapter 7 — The Sequencer)). Your DAW records a CC on Morph on the Groove Figure lane, and one on a Humanize knob on its six sliders’ lanes; Busyness, Variation, Line and Spread are not host parameters, so a controller moving them records nothing.

The editor is where mappings are made, not where they run. CC handling lives in the audio engine itself, so once a knob is mapped you can close the editor and keep playing. And incoming CC moves are applied as genuine parameter changes through the host, so your DAW records them as automation on that parameter’s lane. The instrument brackets each run of CC movement in an automation touch gesture — recording punches in when your hand moves and out when it rests.

A hardware knob on a control the Phase-Locked Loop (PLL) macros steer is a case of its own, and it works. Map TRACK, DAMP, BURST or any of the other controls a macro sweeps, turn it while the macro layer is driving, and the macro that owns it hands its controls back — the loop holds exactly where it stood, your value lands on top, and that dial returns to HOME. The other three macros carry on, except that a knob on TRACK hands FIGHT back along with GRIP, with BURST THR held where it was. The MACRO view (Chapter 2 — Oscillators) covers what handing back means.

To unmap, right-click the control and choose MIDI Forget. To reset a control to its factory value without touching its mapping, the same menu offers Set to default. On any control a modulation route can reach, the menu opens with a MODULATION block — the routes already aimed at that control, each with its own depth slider, and Add modulation — covered in Assigning from the control (Chapter 4 — Modulation). The same menu also carries Unlink modulation, which clears every modulation route currently aimed at that control in one gesture — the caption tells you how many it will clear before you commit, and it is greyed out when there are none. The routes’ amounts are left alone, so picking a destination again restores the depth the route had. There is no undo for it.

High-resolution controllers

Some controllers send a knob as two messages: a coarse byte on one CC and a fine byte on the CC 32 higher, which together give 16384 steps instead of 128. Phaseburn One recognises that pairing on its own — nothing to switch on — and treats the two as the single control they are. You learn it by turning the knob, exactly as with any other, and the context menu reports it as 14-bit beside its CC number. The fine byte never becomes a control of its own, which matters: on its own it races through its whole range several times per turn of the hardware knob.

Assignments follow the controller

In the standalone, what you map is remembered against the input device you mapped it on. Plug a different controller in and its own assignments come back, rather than a layout made for something else; plug the first one back in and yours return untouched. Each controller keeps its own set, and there is nothing to tidy up between them.

A plugin has no device of its own — your DAW decides what reaches it — so there all instances share one set of assignments, and the cog says as much where the standalone shows its device picker. Your hardware still works: route the controller to the instrument’s track as you would for any plugin, and MIDI learn takes whatever the host sends.

What your keys do

Your keys play the sequence, and one law covers everything they do — there is no mode to pick. A single key plays the phrase from that key; keys struck together are the notes the phrase plays from; and with no sequence to drive, the keys play the voice itself. What this instance’s keys feel like — the velocity controls and the pitch-bend range — sits in the keyboard row, the control row above the on-screen piano, under every page in every format, so it is always in reach while you play. The cog menu in the top-right corner is where the same settings appear as standing arrangements rather than as this instance’s, and it opens in two columns. On the left, New instances start with — the word a brand-new instance is born with: change one and every plugin you add from then on arrives set up your way, while the instances you already have keep playing as they are. One click, Save current, copies this instance’s settings up. On the right, This machine — the settings that belong to the computer rather than to any instance or project. The instance settings themselves are recalled with your DAW project and — deliberately — never changed by loading a preset.

One key plays the phrase from that key. Your keyboard is the sequencer’s gate. Silence until you play; press a key and the phrase sounds, transposed so the note you played acts as the root; play the preset’s own root, shown in the browser’s footer, and it sounds exactly as saved — every factory sound is made to play right around C3, middle C. Hold the key and the line runs; let go and the sound rings out through its release. Change notes legato — new key down before the old one is up — and the line transposes mid-flight without restarting; strike again from silence and the bar re-rolls its dice, so every re-attack is a fresh take.

Where the phrase starts depends on your DAW. With the DAW stopped — or in the standalone, whenever no master is running — your key is the transport: the phrase begins at step 1 on your attack, so short stabs play its opening, and like an arpeggiator it needs nothing from the host. While the DAW plays, the DAW owns time: the phrase runs on its bar lines whether or not a key is down, and your key only un-mutes it where the playhead stands. Nothing behind the playhead fires, and a note the phrase is sounding at that moment plays at once for the length it has left; let go and the bar runs on without you. A held note in your piano roll is all it takes to print the line into an arrangement, on your project’s grid.

Playing below the root pulls the whole phrase down; above pulls it up — and the keyboard strip’s piano shows it live: while you hold a key, the root marker slides there, dashed and softly breathing so it cannot be mistaken for the authored root, and the pool’s tints shift with it — exactly the notes the phrase is playing from your key. Release, and the roll snaps back to what you wrote. Playing never edits the patch: the temporary root is display and sound, not state.

Keys struck together are the notes the phrase plays from. Keys that land within about 30 ms of each other form a chord, and the chord becomes the note pool the sequencer draws from: each held note a candidate, how hard you struck it that note’s chance of being picked. Whatever is already held folds in — hold a bass note, strike a triad on top later, and the phrase draws from all four. The chord gates the phrase the way a single key does: it sounds while your hand is down and stops when you lift it. With the DAW stopped a fresh chord restarts it from step 1, so stabbed chords answer with the phrase’s opening bar; while the DAW plays, a chord joins the bar in progress.

A single later key while others are held is legato. It does not start a chord: the phrase transposes to the new key mid-flight, nothing is replaced and nothing restarts. Overlapping single notes in a DAW part that start more than 30 ms apart therefore transpose the line and never thin it out.

Once a chord stands, keys join and leave it. A further key adds its note, a released key removes it, and each change re-pitches the remaining steps of the bar in progress at once, keeping the bar’s rhythm; the note that is sounding is never cut. Lift a chord finger by finger and the last key left plays the full phrase from itself, on the bar in progress. Lift every key and the phrase stops and the pattern’s own note pool comes back, exactly as you wrote it; the next single key plays the phrase from itself again.

A slow chord slides into place under Glide. A hand’s chord spreads its onsets over a few milliseconds, so step 1 may already sound from the first key’s phrase before the chord is complete. When the chord commits, that note is re-chosen from the chord and slides there under the patch’s GLIDE — instantly with Glide off — with no new attack. A chord whose notes a DAW part sends at the same moment plays from the chord from step 1. The sequencer chapter (Chapter 7 — The Sequencer) covers how the pool turns candidates into lines.

Earlier builds switched between two modes here, KEY TRIGGER and CHORD FOLLOW. Both are inside the one law, so the MIDI Mode picker is gone from the keyboard row and from the cog menu. A project saved in either, a cog-menu default, or an automation lane on the old MIDI Mode parameter opens and plays by the law above — the host still lists the parameter for those projects, and all its values now play identically. FREE RUN, the older mode that ran the sequence on its own beside the notes you played, is retired too: hold a note, or switch LATCH on, to run its sequence.

Your keys drive the sequencer, not the voice. And whenever there is no sequence to drive — the SEQ switch is off, or the pattern has no beats at all — notes play the voice directly, so an empty patch behaves like a plain keyboard instrument rather than a silent one. The SEQ switch rides on the Groove nav tab itself, reachable from any page, and it silences the note sequencer while everything outside that page carries on: the modulation sequencers, every tempo-synced division, and your MIDI. The oscillators’ Skip and Paraphony on the OSC page keep gambling with the notes you send — around the key you play, or in the chord you hold (see Oscillator independence (Chapter 2 — Oscillators)) — and the law above runs with SEQ off too, so a chord struck with SEQ off is the chord the phrase plays from the moment SEQ comes back on. Loading a preset keeps the keys you hold and re-strikes them in the order you played them. Like the velocity settings, the SEQ switch is per instance — recalled with your DAW project, untouched by preset loads — so a track you drive from the piano roll stays that way through every patch you try; see One bar, one page (Chapter 7 — The Sequencer).

The velocity block in the same menu decides what how-hard-you-play means. Volume Velocity Lock levels how loud you played, and only that: every note-on sounds at the engine’s resting velocity — the level the sequencer and the bar preview’s audition keys already use — however hard the key was struck. Leave it on when the patch is voiced the way you want it and your playing would keep knocking it off that voicing: a weighted keyboard under a percussive patch, a controller whose curve you cannot change, or a take where the loudness should come from the sequencer’s velocity modifiers rather than your hands. The lock stops at the voice’s own level. How hard you played still reaches everything that shapes the note — the Vel›Attack / Decay / Sustain / Release offsets on all three envelopes, the VELOCITY modulation source on the Mod page, the notes the plugin sends to its MIDI output and a chord’s velocity-as-chance — so a locked keyboard is an even keyboard you can still play expressively. It is an instance setting — your DAW project recalls it, no preset load touches it — and new instances start with it on unless the cog menu says otherwise, while a project saved before the lock existed opens with it off and Amount at 100%, exactly as it played. Turn it off when the level itself should answer your hands.

The Amount slider under it narrows that hand for every reader, locked or not. It scales each note’s deviation from the resting hit before anything sees it, so 100% is your keyboard as it is, 0% is a flat hit everywhere — the envelopes and the modulation routes included — and the range between tames a wild controller into something playable. Under the lock, Amount is therefore the control that decides how much dynamic still reaches the shaping; with the lock off it does the same job to the loudness as well.

Velocity As Strength reads your hand a different way: the raw struck velocity — before the lock or Amount touch it — becomes the note’s strength, the same quantity the sequencer’s strength map assigns to its own notes. It drives the NOTE STRENGTH modulation route and per-note SKIP/PARAPHONY targeting, and the strike sets the whole phrase’s strength — so a hard attack can open a filter or harden a transient across the bar while a soft one keeps it tame, even with the loudness itself locked flat. It is the one preset-carried piece of the MIDI response — part of how the patch expresses — so it travels with the preset rather than living in the cog. It has no panel control in this build: a preset saved with it on keeps it on, and your host reaches it as Velocity As Strength. The lock and Velocity As Strength are deliberately independent: lock the level, keep the expression.

Keyboard Octave is the OCT ± of a hardware keyboard, for this instance: incoming notes are shifted by whole octaves before anything else looks at them — before the sequencer measures them against the root or collects them into a chord — so it behaves exactly as if you had pressed a different key, MIDI OUT included. A note-off always releases the note its note-on started, even if you move the octave while holding. It has no on-screen control: reach it from your host as Keyboard Octave (automation or MIDI learn). It is never saved with a preset and never a global default, on purpose — a remembered octave shift is a shift you forget about. To voice a sound an octave away, use the preset’s Octave instead (at the left of the keyboard row under every page) — that one travels with the preset, and it is how a factory sound stays playable around C3 whatever register it lives in.

Note Priority decides which held note leads when several arrive — the most recent, the lowest or the highest; it has no panel control, being exposed to the host rather than drawn on the window. It comes up again with glide in the oscillators chapter (Chapter 2 — Oscillators).

New instances start with — the cog menu’s left column — is what a brand-new instance starts from: the moment a fresh Phaseburn One initializes for the first time, it copies these five — Volume Velocity Lock, Velocity Amount, the SEQ and FX switches and the Pitch Bend Range — and from then on owns its own values. Editing one never reaches back into an existing instance, this one included; it is a promise about the next one. Set them once — “my instances start volume-velocity-locked, bending ±12” — and every new track arrives set up your way. Two buttons close the column: Save current captures this instance’s whole setup in one click, and Reset to factory puts the same five values back the way Phaseburn One shipped. Nothing in the right-hand column moves either way — the two are independent.

This machine — the right column — is the computer’s own. Its first row is Theme, the editor’s look: Modern, the default since v0.4.0, whose dials carry a gloss cap lit from the upper left, whose large macro dials take the same light, and whose panels sit a shade brighter on a darker ground, with a soft sheen, a fine brushed grain and a bevelled edge; its displays sit under glass — the envelope, transient, glide and Master EQ charts, the level meter and stereo scope, the Groove editor and the preset banks. Classic is the other pick: the face Phaseburn One has always had. The choice applies to every instance and format on the computer and is never saved in a preset or a DAW project. Below it, the MIDI section starts with Soft Takeover for MIDI learn: off to begin with, so a mapped knob takes the parameter the moment you touch it. Switch it on and a mapped knob instead stays inert until it passes the value the parameter is actually sitting at, which is what you want after loading a preset: nothing lurches to wherever your hands happened to leave the hardware. A mapped switch is exempt either way — it toggles on the first press, since there is no position for it to catch up to. Under it, a plug-in simply says that your host routes MIDI here, while the standalone gets its MIDI input device and channel and then the MIDI Clock In and Transport In switches described in Following an external clock (Chapter 10 — MIDI & Your DAW). Every format ends the section with Program Change In — whether program numbers pick presets, covered in Program change (Chapter 10 — MIDI & Your DAW).

Below the MIDI section, the standalone carries an AUDIO DEVICE block for the output and input the app opens (The standalone audio device (Chapter 1 — Getting Started)). Last in the column, for every format, is the STARTUP PRESET: Set captures whatever is loaded, and from then on every brand-new instance opens with it — restored DAW sessions are never touched, and Clear puts the default patch back.

Playing without a controller

Every format carries a keyboard strip under every page — a performance row over a piano — because notes play the sequence and a mouse should be enough to work with them. It is always there, and it is the same piano on every page: C0–C6, every key in the same place. A pressed key is played: it runs the phrase from that key, and with no sequence to drive it sounds on its own. The mouse is one finger, so on-screen keys never form a chord — chords come from a hardware keyboard or a DAW part. Keyboard Octave, Volume Velocity Lock and Amount apply exactly as they do to a hardware key. Where you click on a key sets the velocity — soft near the top, full at the bottom — which the envelopes and the VELOCITY source read whether or not the lock is holding the loudness flat. Drag across the keys to glide: the next key goes down before the last comes up, so the phrase re-roots without restarting, however fast the drag crosses the keys. Held keys light amber; the note that sounds lights blue. While the sequencer can play, the strip also marks the root, shades the scale and tints each key by its chance in the note pool; with an empty beat grid, or with SEQ switched off in the header, its keys go unmarked, since nothing would follow them. On the Groove page the strip is also where the pool is edited: it grows a note-edit row above the keys, a press selects the key it lands on, and a plain press follows that row’s Play Note / Play Seq menu — Play Note to hear the pitch alone, Play Seq to play it as described here (see Choosing notes (Chapter 7 — The Sequencer)).

The row starts with the preset’s OCTAVE — the one control here that is saved with the preset; everything else in the row belongs to the instrument. Next to it, LATCH: on, keys stay down after you let go, until you switch it off. It reads your two keyboards differently, because they are played differently. From a hardware keyboard, releasing keeps the notes held, and the next press with nothing held replaces them — one key plays the phrase from itself, keys struck together form the new chord — while a press with a key still down joins the chord as usual. On the screen, where a mouse has one finger, a click is strictly one note at a time: it replaces whatever the mouse holds, and a click on the note already sounding turns it off — chords are a hardware keyboard’s privilege, and notes your hardware is holding are never touched by a click. Held and latched notes also survive a preset change: loading a preset re-strikes whatever you hold, in the order you played it, so browsing sounds under a held key keeps playing — the phrase starts again on the new sound, or, while the DAW plays, rejoins the bar where the playhead stands. Switching LATCH off releases everything you are not physically holding. Latch is never saved; every launch starts with it off.

On the right sit the instance’s Volume Velocity Lock, Velocity Amount and Pitch Bend Range themselves, so the feel of the keys stays a glance away while you play. The Standalone app adds two things a DAW provides itself: the tempo — its own, never a preset’s, remembered between launches, and hidden while a master’s MIDI clock drives it — beside LATCH, and the MIDI IN device and channel pickers at the right end.

Driving other instruments

Every note the sequencer plays is also sent out of the plugin as MIDI, carrying the velocity the generator gave it. Point another instrument track at Phaseburn One’s MIDI output and the probability engine plays that instrument; pull Phaseburn’s own Master volume down and it becomes a pure MIDI generator, a bar of rolled dice feeding whatever you like. All three plug-in formats emit it — VST3, CLAP and AU.

The stream matches the voice: one note at a time, each released before the next begins, and whatever is sounding is released when the transport stops, so nothing is left hanging on the receiving instrument. The one overlap is a tie (see Ties (Chapter 7 — The Sequencer)): where a tied beat slides into a new pitch, the new note goes out before the old one is released, so a mono synth on the receiving end slides too, and a tie into the same pitch sends nothing new. Notes you play in yourself are not echoed while they drive the sequencer — this is the sequencer’s output, not a MIDI thru. With no sequence to drive (SEQ off, or an empty grid), your keys play the voice directly and go out as they sound.

How you pick it up is the host’s business, and support varies: some hosts let a track listen to another plug-in’s MIDI output directly, some expose it only while the source track is record-armed, and a few do not offer plug-in MIDI output at all. Look for a MIDI input source naming the Phaseburn track. Recording that output to a clip is also the simplest way to keep a roll you like — the bar is re-rolled on every pass, so capturing it is what makes a variation permanent.

The standalone app is the exception: it has no host to send to, and it sends no MIDI at all — it follows a controller or a master clock rather than driving other gear.

Clock and transport

The host’s clock is always the instrument’s clock: tempo, bar lines and every synced division come from the DAW in both modes. Who owns time depends on whether the DAW is playing. While it plays, the DAW does — the host transport is the instrument’s transport, with nothing to arm on the window — and your key decides only whether the phrase sounds. Press play and the sequencer, the step modulators and every LFO start from beat 1 of bar 1, rather than wherever the playhead happens to sit, so every take opens the same way. Loop wraps and relocates move them whether or not a key is held; with a key held, one that lands inside a phrase note plays that note for the length it has left, as a key pressed there would; with no key down the bar runs on, muted. Stop, and the sounding note is released and the sequencer and the modulators park.

Press play mid-bar and the sequencer still starts its bar at that moment, so its bar lines sit off the DAW’s until something re-anchors it: the first loop wrap or relocate — or a preset change — pulls it onto the DAW’s bar lines, and from then on it phase-locks to the host timeline, its downbeat on the DAW’s downbeat. A key pressed while the DAW plays restarts nothing: it joins the bar where the sequencer’s clock already is. With the DAW stopped, a held note is the transport instead — press a key on beat 3 and the phrase still opens from its step 1, deliberately free of any grid, with the step modulators and LFOs starting beside it.

Phase-lock is what makes loop-based work behave. Loop four bars and every wrap snaps the sequencer back into step. Relocate the playhead and it follows. Change tempo — even a ramp — and the playhead and pending notes rescale rather than drift. When the host jumps far enough to matter, the sounding note is released cleanly first — a relocate never leaves a note hanging. And because a Phaseburn bar is probabilistic, every wrap rolls the dice again: the loop plays a fresh variation of itself each pass, by design — record several and keep the take. The sequencer chapter (Chapter 7 — The Sequencer) covers what gets re-rolled.

The bar follows the host’s meter, and it can only shrink. A Phaseburn bar is a 4/4 grid, so an odd meter masks its tail off instead of stretching it — a sixteenth stays a sixteenth. 3/4 and 6/8 play the first three quarter notes and wrap, 7/8 three and a half; 5/4 and 12/8 clamp back to a full bar. The Beats grid draws that cut — a dimmed panel over the masked region, a cut line, an OUT OF BAR caption. GENERATE still composes a full 4/4 bar, so in an odd meter the tail of what it writes is never reached.

The lock reaches past the sequencer. When it re-seeks, tempo-synced LFOs and the step modulators re-phase too, so synced modulation lands in a bounce where it sat in the room. Step modulators in retrigger mode keep their note-driven phase.

Following an external clock

In a plugin the host is the clock and there is nothing to choose. The standalone has no host, so the MIDI section of the cog menu’s This machine column decides whether it runs on its own tempo or on someone else’s. MIDI Clock In hands the tempo over: with it on, the app follows the clock arriving at the MIDI input instead of the TEMPO field in the keyboard row, and every synced division, bar line and LFO follows with it. It locks within about a beat of the first clock, and from then on the TEMPO field hides, as it would under a DAW, while tempo and position both hold to the master’s grid for as long as the clock runs: the step modulators, the synced LFOs, the PLL LAB’s tempo-synced controls and the note sequencer. When the clock stops arriving, the TEMPO field comes back showing the master’s tempo, so a restart is already right; that tempo is not saved, and a relaunch returns to the one you typed. Transport In hands over the position: START plays from beat 1 of bar 1, STOP stops, CONTINUE resumes where the master left off, and a Song Position Pointer moves the sequencers and the synced LFOs to the bar and beat the master names — so looping or relocating on a drum machine, a groovebox or another DAW moves Phaseburn One with it. A pointer that arrives mid-flight relocates at once; one that arrives while the transport is stopped waits for the CONTINUE it belongs to. Both rows are off to begin with, and both are per machine rather than per project.

Once the master has sent START or CONTINUE it owns time exactly as a playing DAW does: its position and its pointers place the phrase, and a held key joins the bar where the master is. After its STOP the app hands time back to your keys, and a key restarts the phrase from step 1 again. A master that disappears without sending STOP counts as stopped too: with MIDI Clock In on, once its clock stops arriving; and in any case when the MIDI input is set to None or switched to another device in the cog menu, or is missing from the device list the next time the menu reads it — when you open the menu, or at the re-scan button beside the channel. Changing the input channel or picking the same device again keeps the master. Short of that it keeps time until its STOP: a master that sends START but no clock, or any master while MIDI Clock In is off, cannot be heard going quiet. While no master is running, a pointer is ignored whenever a sequence can play — your key owns the phrase then — and applies when there is none, with SEQ off or an empty grid.

When you go looking for the standalone at the other end — in your system’s MIDI setup, or in the app you want to slave it to — it names itself Phaseburn ONE: its client and its port carry the product’s name, so Phaseburn ONE input is what you send clock and notes to. It sends no clock or transport of its own: the standalone follows a master rather than leading one.

Program change

Your controller’s program buttons can change presets. Program Change In, at the foot of the cog menu’s MIDI section, turns it on — off to begin with, a setting of this machine rather than of a project, and receive only: Phaseburn One never sends a program change when you pick a patch in the browser.

With the row on, a program number 0–31 picks that slot in the current bank, and Bank Select — CC 0 for the bank’s high half, CC 32 for its low half — picks the bank before it:

A Bank Select on its own never loads anything; it parks the bank and waits for the program number that follows. An address that does not exist — a bank beyond the sixteen, an empty user slot — is ignored rather than guessed at. Switching the row back off forgets any bank you had selected, so turning it on again never replays a stale address.

A program change lands on the next bar line while a pattern is sounding or a key is held, and immediately when nothing is sounding, so a program change on the back of a phrase does not chop it in half.

One host-side limit worth knowing before you map a controller: VST3 hosts pass Bank Select through but not program change, which is a property of the VST3 plugin interface rather than a setting here — so in a VST3 the program buttons will not reach the instrument. Use the CLAP build, or the standalone, where both arrive.

While Program Change In is on, CC 0 and CC 32 are spoken for: they are read as bank select and are not offered to MIDI learn. Turn the row off and both are ordinary CCs again.

When something misbehaves

The plugin–host boundary is where any instrument meets the most variety. Hosts differ in how they report transport position, when they record automation, and which MIDI they forward to an instrument. We test against a range of hosts but have not met every configuration, and this chapter’s features are the most host-dependent in the instrument. Before anything else, walk this list:

The sequencer plays nothing. That is the design until a note arrives: in both modes the phrase sounds only while a key is held — play and hold one, or send it one from a clip, and it runs for exactly as long as the note does. Starting the DAW alone never plays it. To keep it running hands-free, switch LATCH on in the keyboard row and click one key. Then check the SEQ switch on the Groove tab: off mutes the internal note sequencer, and because that switch is saved with the project, a session someone else set up can arrive with it off.

The sequencer feels offset or ignores the loop. With the DAW stopped that is the anchor: the phrase starts where your note does, not on a bar line. Start the DAW and it sits on your project’s bars, loop wraps and relocates included, for as long as the transport runs; in the standalone the same holds once a master has sent START with Transport In on. If the pattern stops short instead, that is the meter: the grid is a 4/4 bar and an odd host signature masks its tail.

The standalone starts a fraction of a beat off the master. With both sync rows on, a master that sends clock only while it plays gives the app a beat to lock on its very first START, and until the lock the app runs at its own tempo — so that first take can sit a little early or late on the master’s grid, roughly 60 ms with the app at 120 BPM and the master at 140, until the next START. Type the master’s tempo into TEMPO beforehand, or stop and start the master once; a master that sends clock while stopped never shows it. A very abrupt, large tempo jump at a fast tempo over an unsteady MIDI link can also leave the position slightly off until the next START.

A mapped knob does nothing. The editor is not required — mappings run in the engine — so suspect the route: confirm your host forwards CC messages to the instrument’s track. Some hosts filter CCs or capture them for their own mapping layers before a plugin ever sees them. If the route is fine, check soft takeover in the cog menu: with it on, a knob stays inert until it passes the parameter’s current value. And in the standalone, check which input device is selected — assignments belong to the controller they were made on.

MIDI learn will not take the control I am turning. The capture wants a deliberate movement, so give the knob a real sweep rather than a nudge. If your controller sends the same physical knob on more than one CC, whichever moves furthest wins, which is the one under your hand.

Hardware moves are not recorded. The instrument presents CC movement as parameter gestures; whether the host writes them depends on the track’s automation mode. Arm the track and pick a mode that records.

A note hangs after a relocate. The host lock releases the sounding note on every material jump, so a hanging note is a bug rather than a setting — catch it and we want the steps.

Anything that survives this list is something we want to hear about. Report it through the contact form with your host and its version, your operating system, the version line from the top of the logo popup, and steps to reproduce. Per-host quirks are precisely what reports like yours find, and fixes ship in updated builds.