Generated tracks

A generated track follows another track and writes its own part from it — automatically, and again every time you change the track it follows. Think of it as a backing layer that stays in step with what you're playing: edit the original, and the generated part re-derives to match.

The classic use is atmosphere on top of a pad. You have a pad holding the chords; you add a generated track set to Atmosphere, and it lays a soft shimmer an octave above the pad. Change a chord in the pad and the shimmer follows on the next edit — you never touch the generated track directly.

Adding one

1. Add a track (the + in the mixer or arrangement) and choose ✨ Generated (follows another track).
2. Pick the track it should follow — its master. Only melodic tracks can be followed.
3. Pick a recipe — what kind of part to derive:
   • Atmosphere — a soft shimmer an octave above the master, held across each chord.
   • Sub pad — a held layer an octave below, for body and weight.
4. Create it. The generated track appears right under its master and is filled in immediately.

Give it an instrument like any other track, set its level in the mixer, and it plays and exports exactly like a part you played by hand.

It follows the master

Whenever you edit the master track's notes and the edit lands (you release the mouse or finish typing), the generated track re-derives. The same happens when you reorder or add sections — the generated part keeps lining up with its master. It does not re-derive when you only change the chord strip; touch the master itself to refresh.

It's read-only — you shape it with a script

You can't hand-edit a generated track's notes — they belong to its recipe. Instead, selecting a generated track opens its script editor. On the left are two piano rolls, one above the other: the source (the master clip you're following) on top, and the generated notes below, lined up on the same pitch range so you can see the relationship — the shimmer sitting an octave above the pad, say. Both show a bar grid for timing reference and refresh as you Apply (or edit the master). On the right is the script, with Reference, ▶ Audition, and Apply buttons and a console. Drag the divider to resize. The recipes above (Octave shimmer, Fifth above, …) are example scripts — pick one when you add the track, then tweak it here.

Give the generated track an instrument with the dropdown at the top of the editor — like any track, it needs one to make sound. ▶ Audition then plays the generated track together with its source so you can hear them in context; press it again to stop. While it plays, a cursor sweeps both grids in time.

One handler at a time

A script is built from handlers — on source_note (one master note at a time), on source_chord (each chord played in the master), on harmonic_chord (each chord in the song's progression), on bar, on beat, and on init — and the handler picker at the top of the editor lets you work on one at a time: pick on source_note and the editor shows just that handler's body — you write the contents, and the on …/end around it are handled for you. A reference line above the editor always names the values that handler can use (for on source_note, the master note's source_pitch, source_beat, source_length, and source_velocity). Pick another handler and it swaps in; choosing one you haven't used yet also drops in a ready-made starter. Pick All handlers (raw) to see and edit the whole script at once. Apply always runs the complete script, whichever view you're in.

The script is color-coded as you write — keywords, functions, the values the master gives you, text, and comments each get their own color, with line numbers down the side — so the shape of the script reads at a glance. The editor also checks it as you type: a moment after you stop, the console shows how many notes it would produce — or, if you've made a typo, the mistake and the line it's on. Click the error and the cursor jumps straight to that line. The Reference button lists every word the script language knows — handlers, keywords, functions, and values — each with what it does; click one to drop its name in at the cursor, so you don't have to remember the exact spelling.

Here is the Octave shimmer script in full:

# A soft shimmer one octave above each note the master plays.
on source_note
    emit_note(source_pitch + 12, source_beat, source_length, source_velocity * 0.5)
end

on source_note means "for every note the master plays, do this." source_pitch is that note's pitch, so source_pitch + 12 is an octave above; emit_note places it at the same spot (source_beat) for the same length, at half the velocity so it sits behind the master. Change the + 12 to + 7 for a fifth, or add a second emit_note line for a thicker sound. Press Apply and the derived notes update across your song.

For the full language — every handler, value, and function — see Scripting generated tracks.

The console shows what happened — how many notes the script produced, anything you log(), and any mistakes (with the line number) so a typo never silently empties the track. Clearing the script puts the track back on its recipe.

A script can also mute(true) the track — that's the only way to mute a generated track, since it owns its own output.

Removing the master removes the generated tracks that follow it — they have nothing left to derive from.