TheRaK — DAWntless instrument rack

TheRaK is a rack of instruments, effects and sequencers that you stack like hardware in a studio rack. There are no cables: the order of the devices is the routing. Build several chains, jam them together on the shared clock, mix them, and print them into a Level Sequence as MIDI tracks that carry their own sound. A saved rack also plays in your game through the TheRaK Performer component (see TheRaK Performer (gameplay)). The standalone instrument windows remain available.

The device rack is on by default. With it off, TheRaK shows the classic STPR-1 → Afterglow → Delay panel described in Classic racks. Existing racks and printed tracks load and sound exactly as before either way.

You can also add your own MetaSound instruments and effects to the rack: see Your own devices.

• For the project: Edit > Project Settings > Project > DAWntless Settings, section TheRaK, Enable Device Rack. Untick it to go back to the classic panel. An open TheRaK switches at once.
• For this editor session only: untick Device rack in TheRaK's header, or run DAWntless.Rack.DevicePreview 0 in the console. 1 turns it on, default follows the project setting, and no argument toggles it. This choice is never saved and never changes the project setting. The checkbox shows while the project setting is on, or once you have used the console command.
• A rack that contains devices always opens in the device rack. To compare with the classic panel, press New rack or load a classic rack, then untick the checkbox. With the device rack off, TheRaK refuses to open a device rack and tells you why.

1. Open TheRaK from Tools > DAWntless > TheRaK, with OPEN TheRaK in the DAWntless transport panel, or with the console command DAWntless.Rack.
2. In the rack picker, choose DA_Rack_Demo_TwoChains (DAWntless Content > Examples > Rack; enable Show Plugin Content if needed). It has two chains at 122 BPM:
   • Stabs: STPR-1 pattern D4 "Minor chord conversation" → Afterglow VoltageLead → Stereo Delay;
   • Bass: STPR-1 pattern C1 "House bass conversation" → Afterglow RustReese → Stereo Delay.
3. Press Play jam. Both chains start together on the next bar of the shared jam clock.
4. Unfold a card to edit its pattern or sound, and press Mixer to balance the chains. Everything stays live while the jam plays.
5. Save as stores your version under /Game/DAWntless/Racks. The demo itself is never overwritten.

For drums and acid bass, choose DA_Rack_ThumprAcid in the same folder instead (see Thumpr and SQLCH). For DrumKing's sampled drums, STPR-1 Drum Mode and GLTCH, choose DA_Rack_BloomBeat (see DrumKing). For a whole arranged and automated track, open the Level Sequence Techno_Rulez (DAWntless Content > Demos) and its rack DA_Rack_TechnoRulez (see DA_Rack_TechnoRulez and Techno_Rulez).

To start from nothing, choose [...] > New empty device rack, then + Add Device > INSTRUMENT + SEQUENCER > Afterglow + STPR-1. New rack starts from the classic STPR-1 → Afterglow → Delay chain instead (see Classic racks).

TheRaK  [x] Device rack   2 chains · Stabs · Bass                           MASTER ||||||.. -1.9 dB  ===o=
[ DA_Rack_Demo_TwoChains   v ]  [New rack] [Save rack] [Save as]
[Play jam] [Stop]  [ ] Mute   BPM [122.0]   Launch: Bar
[Rack][Mixer]  [+ Add Device]  [Print...]  [...]                  Rack ready · 2 chains · 0 unsaved graphs
Status line                                                                                     [Upgrade]
 M |  v (o) *  STPR-1         SEQUENCER · Melodic     -> Stabs
 A |        [ pattern pads A1..D8, note grid ]
 S |  > (o) #  Stabs          INSTRUMENT · Afterglow  (K)
 T |  > (o) ~  Stereo Delay   EFFECT · Stereo Delay
 E |    == Stabs   Level ---o--  Pan (o)  [M] [S]  ||||||.. -8.4
 R |  > (o) *  STPR-1         SEQUENCER · Melodic     -> Bass
   |  > (o) #  Bass           INSTRUMENT · Afterglow  (K)
   |  > (o) ~  Stereo Delay   EFFECT · Stereo Delay
   |    == Bass    Level ----o-  Pan (o)  [M] [S]  ||||.... -12.0
   |    + Add Device

• Header: the chain summary (the chains' names; hover it for every chain's devices), the MASTER meter and the master level.
• Transport: Play jam, Stop, Mute (silences the whole rack while the patterns keep running), BPM and Launch (where Play jam starts: the next bar, the next beat, or immediately).
• Tools: the Rack / Mixer views, + Add Device, Print..., the [...] menu and the rack state: Rack ready or Rack rebuilding, the number of chains, and how many chain graphs are not saved yet.
• Status line: what the last action did, or why it was refused. [Upgrade] appears next to it when an edit needs it.
• Device list: the routing gutter on the left, one card per device, a strip after each chain, and + Add Device at the end. The whole window scrolls as one page.

TheRaK reads the rack from top to bottom:

1. An instrument starts a chain. Every effect below it belongs to that chain until the next instrument or sequencer.
2. An STPR-1 plays the instrument directly below it.
3. Each chain ends in its strip (level, pan, mute, solo) and goes to the master.
4. Chains play side by side. Moving a whole chain up or down changes its place on screen, never the sound.
5. Effects above the first instrument are in the master zone. They are kept but not played yet: master effects arrive in a later update. Their cards show a red strip.

The gutter draws these rules for you: a bracket in each chain's colour, from its first card to its strip, and the MASTER rail that every strip feeds. Point at the gutter beside a card to highlight that device's path to the master.

MASTER
  |    +- *  STPR-1          plays Stabs
  |    |  #  Stabs           instrument: starts the chain "Stabs"
  |    |  ~  Stereo Delay    effect: joins "Stabs"
  |<---+- == Stabs           strip -> master
  |    +- *  STPR-1          plays Bass
  |    |  #  Bass            instrument: starts the chain "Bass"
  |    |  ~  Stereo Delay    effect: joins "Bass"
  |<---+- == Bass            strip -> master

An effect belongs to whichever chain it sits in, so moving it is how you re-route it:

Before                               After dragging the delay below Bass
  #  Keys                              #  Keys
  ~  Stereo Delay   (Keys)             #  Bass
  #  Bass                              ~  Stereo Delay   (Bass)

And an effect above every instrument is stored in the master zone:

  ~  Stereo Delay   master zone: kept, not played yet
  #  Keys           the first instrument: the first chain starts here

Open the Add Device menu with + Add Device in the toolbar (it adds below the selection), with the + Add Device row at the end of the list (it adds at the end of the rack), with Ctrl+T, or by right-clicking a card and choosing Insert below. The menu's header says where the device goes, and each effect entry names the chain it joins (→ Bass).

Search. Type in the Search devices box at the top of the menu to narrow the list. Every word you type must appear, in any order and in any letter case, in the entry's name, its section, its device type, the chain it joins, its description or, for your own devices, user and its category. drum seq finds DrumKing + STPR-1 Drum, and also DrumKing (its description says it is sequenced by STPR-1 Drum Mode) and Thumpr FM Drum (own sequencer). user chorus finds the Chorus example, and bass finds every effect entry that joins the chain Bass. While you search, RECENT is hidden, so each result appears once, in its own section; with nothing matching, the menu says "No device matches". Typing highlights the first entry that is enabled, and Enter adds the highlighted entry. After drum seq the highlighted entry is DrumKing, so press Down until DrumKing + STPR-1 Drum is highlighted before you press Enter. Up and Down move through the results, and Esc closes the menu. Clearing the box shows everything again.

Entries of later updates are listed but disabled with the reason. Hover a disabled entry to see why it is disabled; it is the same reason the edit itself would give. Hovering an enabled entry previews the result in the gutter.

Where a new device goes depends on the selection:

• An instrument goes after the selected chain, or at the end, and starts a new chain in the next free chain colour.
• An effect goes directly below the selected card. With a strip selected it goes at the end of that chain; with nothing selected, at the end of the last chain. A rack without an instrument refuses effects: "Add an instrument first".
• An STPR-1 attaches to the selected instrument, or to the one you pick in the submenu.

Every add is one Undo step.

• STPR-1 plays only an instrument that has no sequencer of its own. Afterglow and DrumKing accept one. On DrumKing, and on your own drum instruments, it runs in Drum Mode: one lane per pad, many hits per step, no transpose (see Drum Mode in TheRaK).
• Thumpr FM Drum and SQLCH have built-in sequencers, so STPR-1 cannot attach to them. With one of them selected, STPR-1 → attach to is disabled, and otherwise its submenu does not list them; the menu's tooltip and the drag preview give the reason "Thumpr uses its own sequencer" or "SQLCH uses its own sequencer". Adding either one never attaches an STPR-1, and replacing an instrument that has an STPR-1 with either one removes the STPR-1 after you confirm. Your own instruments with a built-in sequencer are refused the same way, with "<name> has its own sequencer".
• An instrument has at most one STPR-1, directly above it. The STPR-1 travels with its instrument when you move the chain.
• An STPR-1 left where it cannot play, for example above an effect, stays in the rack but does nothing, and its card says why. Drag it onto an instrument's header to attach it.
• The STPR-1's patterns stay with it when you move it to another instrument.

Drag a card by its header. While you drag, the gutter shows the result: a teal line where the drop is allowed, or a red line with the reason beside the cursor where it is not. Hold Ctrl to duplicate instead of moving. Each drop is one Undo step.

The three rows of a classic rack cannot be dragged (see Classic racks).

A card's header shows, from left to right: the fold triangle, bypass (o), the role (* sequencer, # instrument, ~ effect), the colour chip, the name, the type (for example INSTRUMENT · Afterglow), where it goes (→ Stabs), the preset, the MIDI focus key K on instruments, activity and state, and the [...] menu.

• Select a card by clicking its header. Ctrl-click adds to the selection and Shift-click extends it. Clicking a header also gives the device list keyboard focus for the shortcuts.
• Fold with the triangle, a double-click on the header, or F. Alt-click a triangle to fold every other card; Ctrl+Shift+F folds or unfolds them all. Fold state is saved with the rack and is not an Undo step. A card builds its controls the first time you unfold it.
• Bypass with (o) or B. A bypassed effect passes audio through (the Stereo Delay and GLTCH let their echoes ring out), a bypassed instrument is silent, and a bypassed STPR-1 stops sending notes. Bypass never rebuilds audio. (o) is a device's only on/off switch: a Stereo Delay that was switched off in a classic rack shows a dim (o) after the rack becomes a device rack, and (o) switches it back on.
• Rename with a double-click on the name, or F2. An instrument's name is its chain's name: the strip, the Mixer column, the Print dialog and the printed track use it.
• Colour with the colour chip or [...] > Colour: one of 16 chain colours. A colour belongs to a chain: the gutter bracket, the left edge and the colour chip of every card in the chain, the strip, the Mixer column and the printed track all show it. On an STPR-1 or an effect the chip (and [...] > Chain colour) recolours its chain. A master-zone effect is red and a loose STPR-1 outside every chain is grey; they have no chain colour.
• Delete removes the selection. Deleting an effect closes the gap; deleting an instrument deletes its whole chain in one Undo step; deleting an STPR-1 detaches it. Alt+Delete removes only the instrument and its STPR-1, and its effects join the chain above. When there is no chain above, TheRaK asks first, because those effects would land in the master zone.
• Duplicate (Ctrl+D), Copy (Ctrl+C) and Paste (Ctrl+V, below the selection) create new devices. A copied chain is a new chain with its own strip. Copy uses the clipboard, so you can paste devices into another rack, or into TheRaK in another editor.
• Move the selection with Alt+Up and Alt+Down. A whole chain moves past its neighbour.
• Replace instrument ([...]) changes the instrument and keeps the chain's effects and strip, and its STPR-1 when the new instrument accepts one.

Each chain ends in a strip:

• the chain's colour and name;
• Level, from −inf to +6 dB: drag it (a click alone changes nothing, so a stray click never jumps the level); double-click resets it to 0 dB;
• Pan, a balance control: centred, both sides stay at full level;
• M mutes the chain. Its STPR-1 keeps running, so the chain comes back in time;
• S solos the chain. Solos add up; Ctrl-click solos this chain alone;
• a peak and RMS meter that turns orange near full scale; the red light marks a clip and stays lit for two seconds;
• a mark for the chain's graph: a filled dot when it is saved, a hollow dot while it is new (Save or Print builds it and the dot fills), an amber dot when it is out of date, and a small amber square for a chain on the legacy engine, which has no graph to build;
• a badge when something needs your attention: REBUILDING while an edited chain is being rebuilt (the old sound keeps playing until the new one fades in), GRAPH OUT OF DATE with [Rebuild], LEGACY ENGINE with [Upgrade] (see Classic racks), or SILENT when the chain cannot play, for example because its instrument is missing.

Click a strip to select it; M and S act on the selected strip, or on the chain of the selected card. Each fader or knob drag is one Undo step, and so is each click on M or S, and each double-click reset. The chain's CPU time turns orange above 420 µs per audio block, on the strip, its Mixer column and the instrument's card alike.

Mixer view. Press Mixer to see one column per chain (fader, pan knob, M, S and meter), then the MASTER column and the MASTER EFFECTS panel, which reads "Master effects arrive in a later update". Columns wrap onto a new row in a narrow window. Click a column to select its chain: then M and S mute and solo it, Left and Right select the next column, Space plays or stops, and Ctrl+T opens Add Device. Click a column's name to return to the Rack view at that chain. The view you pick is kept with the rack and is not an Undo step; an [Upgrade] pressed in the Mixer stays in the Mixer.

Master. The header's MASTER meter shows the true sum of every chain after its strip. If that meter cannot connect to the audio device, it shows the loudest chain instead and reads approx. The master fader beside it (−inf to +6 dB, double-click for 0 dB) sets the level of the whole rack. On a classic rack the master fader is hidden, because the chain strip's Level is the rack's output.

Your MIDI keyboard plays one instrument at a time: the one with focus.

• Give an instrument focus with its K key, by pressing K on its card, or simply by selecting it: focus follows selection, which you can turn off in the [...] menu. Focus is not an Undo step and is never printed.
• Choose your controller in an STPR-1 card's MIDI input menu. It is DAWntless's shared MIDI input, the same port the transport's record controls use.
• Your notes play the focused chain, through its effects and strip, even while the rack is stopped.
• K:T: when the focused instrument's STPR-1 has MIDI transpose on and the rack is playing, your keys transpose its pattern instead of sounding, as in STPR-1's own MIDI transpose. Stop the rack, or turn MIDI transpose off, to play notes.
• A chain on the legacy engine only transposes; playing notes into it needs [Upgrade].
• DrumKing takes focus: note Kit Root + p − 1 plays pad p (notes 36-99 at the default Kit Root); other keys are silent.
• Thumpr FM Drum takes focus: a key plays the pad whose note in the kit's Pad Notes equals it; other keys are silent.
• GLTCH takes focus too, although it is an effect: twelve keys from its select root (48, C3, by default) select its patterns 1 to 12 on the bank's switch quantize; other keys do nothing (see GLTCH).
• SQLCH plays its own patterns and never takes focus: its K key is greyed, with the tooltip "SQLCH plays its own sequencer and takes no live MIDI focus."
• You never hear a key twice: while TheRaK plays a key, the Sequencer record monitor and the live MIDI performance component leave it alone.

• Powered. While TheRaK shows a device rack, the rack runs with its transport stopped, so a focused keyboard sounds at once. Closing the tab switches the rack off unless the jam is playing: a playing jam keeps running, your keyboard keeps playing the focused instrument, and the rack switches off when that jam stops (Stop, or Sequencer playback). [...] > Keep rack powered when TheRaK is closed keeps it on, keyboard included (off by default). PIE and map changes switch it off. A classic rack makes its sound when you press Play jam, as before. To play a rack in the game itself, use the TheRaK Performer.
• Play jam starts every chain together, sample-aligned, at the point Launch names: Bar (the next bar of the shared jam clock, the default, in time with the other Tools jams), Beat (the next beat) or Immediate (right away, after a 100 ms start-up). Patterns start from their first step. A classic rack always starts on the next bar. Space toggles Play jam and Stop while the device list has keyboard focus.
• Stop stops the patterns. Echoes ring out and the rack stays powered.
• Starting Sequencer playback or PIE stops the jam. Closing the tab keeps a playing jam running; reopen TheRaK to continue.
• Edits while playing. Knob, pattern, preset, bypass, mute, solo and STPR-1 changes never interrupt the sound. Adding, removing or moving a device rebuilds only the chains it changes: each one crossfades from its old sound to its new one while REBUILDING shows, and echoes of the old sound ring out. Moving a whole chain rebuilds nothing.

• Save rack updates the rack you loaded when it is a project asset, and otherwise creates a new asset under /Game/DAWntless/Racks. Save as always creates a new asset. The plugin's example racks are never overwritten.
• Before a device rack is saved, TheRaK builds the MetaSound graph of every new chain; a progress bar shows "Building N chain graphs...", about two seconds per chain. The graphs are stored as described in Generated chain graphs and Perforce, and the hollow strip dots become filled.
• A chain marked GRAPH OUT OF DATE blocks the save until you press [Rebuild] on its strip. This happens when a graph the chain embeds changed outside the rack; until then the chain keeps playing its saved graph. When the reason names a device that needs validation, register that device in the Device Validator first; [Rebuild] then works.
• The asset stores every device with its patterns, sound, imported sample data and settings, the strips, the names and colours, the master level and the jam tempo. For the editor it also remembers fold state, focus and the Rack / Mixer view.
• Load a rack with the rack picker. Classic and device racks both open as an editable copy. Loading stops the rack's current jam; press Play jam to start the loaded one.

1. Open the destination Level Sequence and place its playhead.
2. Press Print.... The dialog lists every chain with its colour, name, sequencer (STPR-1 Melodic, STPR-1 Drum, Thumpr, SQLCH, built-in sequencer for your own self-sequenced instruments, or no sequencer) and status: ok, not printed: no sequencer, not printed: self-sequenced device, or invalid: and the reason. The chains you can hear under the current mute and solo are ticked. Only the ticked chains are built and checked, so a chain you leave out (one marked GRAPH OUT OF DATE, say) does not stop the others from printing.
3. Choose Repeats (1–128) and press Print. TheRaK first builds any new chain graphs (progress bar), then creates one MIDI track per ticked chain at the playhead, named and coloured like its chain, and extends the playback range if needed. One Undo removes every track of the print.
4. Save the Level Sequence, and submit the generated graphs with it (see Generated chain graphs and Perforce).

Each track owns a snapshot of its own chain: its devices, sound, sample data, pattern bank and level. It plays sample-accurately in the Sequencer arrangement and in PIE, and never drops a note. Later edits to the rack or its asset do not change printed tracks. A chain on the legacy engine prints as a classic track, identical to a classic print. The jam stops after a print.

Print writes each chain's selected pattern, repeated: an STPR-1 pattern with its control lane; an STPR-1 Drum pattern as the hits the jam plays, loop by loop (chance rolled as in the jam, ratchets expanded into notes; the dialog's Drum probability row can Re-roll them); a Thumpr pattern as one note per hit at the kit's pad notes; an SQLCH slot as one SQLCH phrase per repeat, with every note's accent, slide or tie, slide length and modulation. A pattern that cannot be printed (an empty one, for example) stops the print before any track is created, with the chain's name and the reason. So does a print longer than a track can play: at most 32,768 Thumpr hits or STPR-1 Drum notes, or 8,192 SQLCH notes, over all repeats. The message names the largest Repeats that fits. It does not record knob movements, pattern switches or live transpose. Mute and solo only decide which chains are ticked; they are not printed. Jam BPM is a rack preference; the arrangement tempo comes from the Level Sequence's DAWntless clock settings, so match the two when you compare the jam with the print.

To automate a printed chain, right-click its track and choose Add MetaSound Automation. It has one submenu per device of the chain, such as Wave (Afterglow), Delay1 (Stereo Delay), GLTCH1 (GLTCH) or SQLCH (SQLCH), then Other inputs. Each entry is a parameter with its range, units and resting value in the tooltip; the new lane is grouped under its device in the track and edited in the Curve Editor. Switches such as GLTCH1 > Bypass are on/off lanes and pattern selects such as GLTCH1 > Pattern are whole-number lanes; every value is clamped to the parameter's range. The lanes go on the track's own automation lane, which spans the whole sequence and which re-printing an STPR-1 phrase (Update phrase) never removes. While the sequence plays, a lane owns its parameter: it wins over the card, a preset or a chain rebuild; when playback stops, or when you remove the lane, the device gets its own value back. Remove MetaSound Automation removes a lane. In TheRaK, right-click an Afterglow knob, a Stereo Delay box or a knob of your own device (a parameter ticked Automatable) and choose Automate in Sequencer or Key current value to create the lane on the chain's printed track in the open Level Sequence; knobs never record. The details are in MIDI MetaSound automation; DA_Rack_TechnoRulez and Techno_Rulez shows lanes of every kind.

• Each device-rack chain plays a MetaSound graph that TheRaK composes from its devices. While you edit, the graph is temporary. Save and Print store it as an asset named MSS_Chain_ plus 16 characters, under the Generated Chain Root: Project Settings > Project > DAWntless Settings > TheRaK, /Game/DAWntless/Racks/Generated by default. The plugin's example racks use /DAWntless/Examples/Rack/Generated.
• The name comes from what the chain is built from (its devices and wiring, not its settings or patterns), so chains built the same way share one graph, across racks and across users. A graph is never overwritten or renamed.
• With source control connected, the editor marks new graphs for add when it saves them. Submit them together with the racks and Level Sequences that use them. A rack or printed track whose graph is missing is silent in a packaged game; the editor's data validation (Validate Assets on the rack, the sequence, or the level that holds a TheRaK Performer) reports it before you cook.
• If Perforce reports that someone else already added the same MSS_Chain_ file, revert your add and sync theirs: the same name means the same graph.
• Unused graphs accumulate as you experiment. Nothing is ever deleted on its own: clean them up when you choose, as described below.

Choose [...] > Clean up unused chain graphs... in TheRaK's toolbar. TheRaK first makes a dry run over the Generated Chain Root and shows the report in a Clean Up Chain Graphs window: how many MSS_Chain_ graphs it found, how many it keeps, and the unused ones with their file sizes. Nothing is deleted until you press Delete N graphs; Close leaves everything as it is.

• What is kept. A graph is kept when any asset on disk refers to it, hard or soft: a saved rack (and so every level whose TheRaK Performer plays that rack), a printed track's snapshot, a saved STPR-1 Performer whose Instrument Sound names it, or any other asset. A graph that an open TheRaK, an unsaved rack or a playing game holds in memory is kept too. Only graphs that nothing uses are offered.
• Checked again when you press Delete. Just before deleting, TheRaK scans again and deletes only graphs that are still unused and appeared in the report you read. A graph that became used meanwhile is kept, and the window lists it with the reason ("now referenced", "now in use", "held in memory by ..."). A graph that became unused after the report is left for the next clean-up.
• When it waits. While a game runs in the editor, the menu entry is disabled and its tooltip says "A game is running: stop it first.". In the window, Delete is disabled, with the reason as its tooltip, while a game runs or while a jam plays: TheRaK's jam or preview, or a Tools jam of Thumpr, SQLCH or STPR-1 ("Stop TheRaK first: deleting assets stops every sound in the editor."). A device rack that TheRaK only keeps powered, with its jam stopped, does not block it.
• Undo and source control. Deleting removes the files and cannot be undone. With source control connected, a graph that is only marked for add is reverted and removed; a submitted graph is marked for delete, and you submit that change yourself. The window scans only the Generated Chain Root, never the plugin's example graphs.
• From the console. DAWntless.Rack.CollectGeneratedGraphs lists the unused graphs of the Generated Chain Root without deleting anything. Root=<path> checks another folder, and -Delete deletes the listed graphs after the editor's own confirmation. Like the window, -Delete deletes nothing while a game runs or TheRaK plays.

The TheRaK Performer component plays a saved device rack in a game: in Play In Editor, in a -game session and in a packaged game. It plays the rack the way TheRaK's jam does: each device's own patterns, SQLCH bank slots, DrumKing, GLTCH, your registered devices, and chains still on the legacy engine. It plays the chain graphs saved with the rack; nothing is built in the game.

1. In TheRaK, save the rack (Save rack or Save as): saving builds every chain's graph. The factory racks are ready to play.
2. Add TheRaK Performer to an actor (Add Component, category Audio) and set Rack to the saved rack.
3. Keep Auto Play on to start when the actor begins play, or call Play from a Blueprint.

Every chain of the rack follows one Quartz clock, so the chains start sample-aligned and a tempo change reaches all of them at once.

• Own clock (free-running). Play creates the component's own clock, in Clock Time Signature (4/4 by default), at Tempo (or the rack's BPM), and the component deletes it when it stops. Set Tempo changes it while the rack plays; the patterns follow without restarting.
• World clock (by name). The rack follows the world's Quartz clock named Clock Name: the clock of a DAWntless Sequence Clock actor (the clock name of its Clock Data Asset), or one your Blueprint created. The rack takes that clock's tempo, so Set Tempo is refused: the clock's owner sets it. The component never creates, starts, stops or deletes a world clock, and never changes its tempo.
  • Play waits (state Preparing) until the clock exists and runs.
  • A clock you create yourself needs Use Audio Engine Clock Manager on. The component cannot follow a clock outside the audio engine's clock manager: Play stays in Preparing and Get Last Error says so.
  • If the clock is deleted, stopped or paused, or its transport restarts, the rack's transport stops (On Stopped). The rack starts again on the clock's next Launch point once the clock runs, in the time signature of whoever runs it then. A paused clock counts as stopped: the patterns start again from their first step, not from where the pause left them.
  • The rack follows the clock's time signature too (see Time signatures).

The rack follows its clock in any time signature: its patterns run on without a jump at the clock's bar lines, a Launch on the Bar starts on the clock's bar line, and Next bar pattern switches and GLTCH bar lengths follow the clock's bar. Patterns keep their own length in quarter notes: a 16-step STPR-1 pattern of sixteenth notes still lasts four quarter notes, so on a 3/4 clock it starts at a different beat of each bar.

Quartz cannot tell the rack a clock's time signature, so the rack takes it from whoever made the clock:

• Own clock: Clock Time Signature.
• A DAWntless Sequence Clock actor's clock: the actor's time signature (the Level Sequence's tempo data, else its Clock Data Asset). Clock Time Signature is ignored.
• Another TheRaK Performer's own clock: that component's Clock Time Signature.
• Any other clock (one your Blueprint created): Clock Time Signature. Set it to the time signature the clock was created with. If the clock counts a different number of beats per bar, the log says so once (verbosity Log). A clock with fewer beats, for example a 3/4 clock with Clock Time Signature left at 4/4, is reported after two complete bars: the world clock '…' counts 3 beats per bar but Clock Time Signature is 4/4: set the time signature the clock was created with. A clock with more beats is reported at its first extra beat: … counts at least 5 beats per bar but Clock Time Signature is 4/4 ….

The time signature is read when the rack binds to its clock, and again when a world clock that stopped runs again: if another Sequence Clock actor re-created the clock in another time signature meanwhile (for example a streamed level whose actor uses the same clock name, with its own sequence's time signature), the rack follows the new one from its next launch. When two Sequence Clock actors use the same clock name, the one playing its sequence wins. A clock whose time signature changes while it runs keeps the one the rack found: stop the rack, then play it again.

Beats. A beat is the denominator's note, as Quartz counts it: in 6/8 Next beat switches and a Launch on the Beat land on eighth notes. For a dotted-quarter beat (6/8 felt in two), give Clock Time Signature a Pulse Override of two dotted-quarter pulses (own clock, or a clock your Blueprint created with the same override). A Sequence Clock actor's clock always beats on the denominator's note.

Pulse overrides. The rack follows a pulse override only when all its pulses have the same length and fill the bar. Any other override (for example 7/8 as 2 + 2 + 3) is refused: with Own clock, Play fails and data validation reports an error; with World clock, data validation warns, and Play waits in Preparing with the reason in Get Last Error when no DAWntless Sequence Clock actor or other TheRaK Performer created the clock.

Very short beats. Quartz counts at most one beat per audio buffer, so its beat count skips beats that are shorter than a buffer: when 7.5 × sample rate ÷ BPM × 32 ÷ denominator is less than the buffer's frame count. At 48 kHz that is a /32 beat above 176 BPM with 2048-frame buffers (above 161 BPM at 44.1 kHz), a /16 beat above 352 BPM with 2048-frame buffers, and a quarter-note beat above 703 BPM with 4096-frame buffers. For a clock outside 4/4 the rack notes it in the log; a 4/4 clock gets no such line.

Chains are addressed by name: the instrument's name, as TheRaK's strip and Print show it. Letter case does not matter; when two chains share a name, the first one in the rack wins. Every function below is under DAWntless > TheRaK.

A refused call returns false and logs one warning with the reason, once per reason.

• Classic racks (the STPR-1 → Afterglow → Delay format) are refused; the STPR-1 Performer component plays them. The STPR-1 Performer in turn refuses a device rack with "Device racks play through TheRaK or the TheRaK Performer component."
• A chain whose graph is missing stays silent while the other chains play, and the log names it: "TheRaK Performer <owner>: chain '<name>' is silent: <reason>". Validate Assets on the level that holds the component checks it before you cook: no rack assigned (a warning), a classic rack or a rack with no chain that can play (an error), or a chain that cannot play (a warning per chain). Validating the rack itself reports a chain without its graph too.
• DrumKing samples. Play waits up to 2 seconds for DrumKing to decode its samples, without holding up the game, then starts.
• Where it does not play. In an editor world (a construction script, an editor utility), and in a world without audio (a dedicated server, -nosound), Play returns false with the reason in Get Last Error and logs no error. The component is not replicated: every client plays its own copy.

• Pausing the game does not pause the rack: its chains play as interface sounds, which a pause leaves running, and its clock keeps running. Call Stop or Set Master Level from your pause menu. The component keeps working while the game is paused: Stop lets the tails ring and switches off, and Play starts.
• Destroying the actor, changing level, ending PIE or quitting stops everything at once, without tails, and releases the rack's audio.
• Editing the component's properties during PIE keeps the rack playing.

The component writes its events to the log (category LogDAWntlessRuntime) as DAWNTLESS_RACK_PERFORMER event=... lines: ready (the chains are on), started (the patterns run), stopped (with the reason), error (a refusal, as a warning) and prepare_timeout (it stopped waiting for samples). To log every chain's meter once a second, as a DAWNTLESS_RACK_METER line, start the game with -DAWntlessRackMeterLog, set the console variable DAWntless.Rack.PerformerMeterLog 1, or tick Log Meters. The console command DAWntless.Rack.PerformerReport logs every performer's state and meters once.

Before you cook, UnrealEditor-Cmd <project>.uproject -run=cook -targetplatform=Windows -CookList -MAP=<your map> lists what the level takes along: the rack, its MSS_Chain_ graphs, the device graphs and the samples. Submit the rack and its generated graphs together (see Generated chain graphs and Perforce).

Thumpr FM Drum and SQLCH are rack instruments with their own sequencers: each plays its own pattern bank on the rack's clock, through its effects and strip, and neither takes an STPR-1.

Every kit, bank and sound in the rack is the device's own copy: loading one never changes the asset, and rack edits never reach the standalone windows or your sequence tracks. Save preset... in the card's [...] menu stores the kit or sound as a project asset. SQLCH sounds only while the rack or the sequence plays. On a printed SQLCH track its sound's Cutoff (30 to 16000 Hz), Resonance, Env mod, Decay and Accent can be automated from the track's SQLCH (SQLCH) automation submenu (SQLCH_Cutoff, SQLCH_Resonance, SQLCH_EnvMod, SQLCH_Decay, SQLCH_Accent; see SQLCH sound settings). A printed SQLCH track plays through its chain's own SQLCH sequencer: a note edit reaches it a tenth of a second later, and an edit that makes the track invalid (more than five notes on one onset, say) silences it until the track is valid again. The details are in Thumpr in TheRaK and SQLCH in TheRaK.

The factory rack DA_Rack_ThumprAcid (DAWntless Content > Examples > Rack) has two chains at 128 BPM:

• Thumpr: Thumpr FM Drum with the default kit and the first pattern of the Club bank (Berlin Concrete), at −3 dB → GLTCH (a copy of the BeatRepeatClassic bank, pattern 1);
• Acid: SQLCH with the Init sound and slot 02 (Warehouse) of the factory bank, at −6 dB → Stereo Delay (a dotted eighth, 0.352 s, feedback 0.35, mix 0.18).

Load it, press Play jam, and Print... writes both chains to the open Level Sequence as two tracks. Like the demo, it is never overwritten: Save as stores your version.

DrumKing is a 64-pad sample drum machine, in the spirit of Ableton's Drum Rack and Drum Sampler: an 8x8 grid of pads (four banks of 16), each playing a sample with its own tuning, envelope and burst, filter, two playback effects (pitch envelope, loop, stretch, punch, 8-bit, FM, ring modulation, sub oscillator, noise, drive, comb), a second layer, variations, modulation, choke group and voice limit. An STPR-1 in Drum Mode sequences it.

• Add it with + Add Device > INSTRUMENT + SEQUENCER > DrumKing + STPR-1 Drum, or run DrumKing.Open, which opens TheRaK and adds one when the rack has none. A new DrumKing plays its own copy of the Engine 808 kit, and its STPR-1 plays factory drum pattern A1.
• Kits. The kit browser in the card header steps through the eight factory kits (Bloom Studio, Engine 808, Trap Boom, UI Minimal, Dusty Keys, Warehouse, Transitions, Mallets & Plucks) and your kits in /Game/DAWntless/DrumKing/Kits. Choosing one copies it into the device; Save preset... in the card's [...] menu stores the device's kit as a new asset, and Reset returns to Engine 808. Every factory kit uses only sounds that ship with Unreal Engine and its Harmonix plugin.
• Pads. Unfold the card to play and edit the pads: click to audition, drag a pad onto another to swap them (the STPR-1's lanes follow when Lanes follow sounds is on), drop SoundWaves from the Content Browser to fill pads. Every gesture is one Undo step, and the sounds keep playing while you edit.
• Loading. DrumKing decodes its samples when its chain powers; the card shows LOADING n/m meanwhile and Play jam waits up to 2 seconds for them. The arrangement and PIE never wait: a hit whose sample is still decoding is skipped and counted under MISSED HITS.
• Cooking. UI Minimal uses editor sounds, which "Exclude editor content when cooking" leaves out (a validation warning says so); Engine 808 and Mallets & Plucks cook everywhere.
• Racks saved before this update. An STPR-1 attached to one of your own Drum-mode instruments used to stay silent; it now plays factory drum pattern A1.

The full guide, with every setting, the factory kits and where their samples come from, is DrumKing; Drum Mode itself is in Drum Mode in TheRaK.

The factory rack DA_Rack_BloomBeat (DAWntless Content > Examples > Rack) has two chains at 120 BPM:

• Drums: STPR-1 in Drum Mode, factory drum pattern A2 → DrumKing with a copy of the Bloom Studio kit, at −3 dB → GLTCH (a copy of the GlitchGrid bank);
• Keys: STPR-1 pattern D5 "Basement progression" → Afterglow GlassDrift, at −8 dB → Stereo Delay (a dotted eighth, 0.375 s, feedback 0.3, mix 0.2).

Load it and press Play jam. It is never overwritten: Save as stores your version.

GLTCH, the stutter and glitch effect on the drum chains of both factory racks, is described in GLTCH.

GLTCH is a tempo-synced stutter and glitch effect, in the spirit of Sugar Bytes Effectrix and Ableton's Beat Repeat. You draw blocks on 11 lanes (Repeat, Reverse, Tape Stop, Scratch and Stretch; Crush, Filter, Gate and Pitch Shift; a delay throw and a reverb throw), and a Beat Repeat engine adds repeats of its own. Repeats go down to 1/256 and 1/256T.

• Add it with + Add Device > EFFECTS > GLTCH: like any effect, it lands directly below the selected card. GLTCH.Open opens TheRaK and adds one when the rack has none. Each GLTCH gets a number counted across the rack (GLTCH1, GLTCH2 and so on) that names its automation controls and is kept when you move it; the card shows the device's name, GLTCH until you rename it. A new GLTCH plays its own copy of the Subtle Stutter bank. The card header's preset browser steps through the 12 factory banks and your banks in /Game/DAWntless/GLTCH/Presets, and Save preset... in the card's [...] menu stores the device's bank.
• The card body. Unfold the card for the 12 pattern slots, the header row (switch quantize, run mode, master mix and law, output, smooth, seed, MIDI select root and GLTCH's own CPU time) and two pages: LANES (the loop bar, the lane grid, the mod strip and the dice) and BEAT REPEAT. The REPEAT button on the tab row repeats while you hold it. Every gesture is one Undo step.
• Timing. A GLTCH gives its chain the rack's clock (behind SQLCH too), so its blocks and repeats land sample-accurately in the jam, in the arrangement and in PIE, counted from where the jam started or the print starts. While the rack is stopped its blocks rest; the REPEAT button and the Manual and Hold run modes still play, on a free-running clock.
• MIDI focus. A focused GLTCH selects patterns with twelve keys (see MIDI focus).
• Bypass (o) crossfades to the dry sound over 10 ms. Its echoes and reverb ring out, and then the output is exactly the input.
• Print writes the chain as usual. The printed track keeps the chain's own copy of the bank, and printed bar n sounds like jam bar n. GLTCH's chance comes from the bank's Seed, so the Print dialog's Re-roll does not change it. The track's Add MetaSound Automation has a GLTCHn submenu with Mix, Pattern (a whole-number lane: −1 plays the device's own pattern selection), Repeat and Bypass (on/off lanes).
• CPU and memory. At most 250 µs per audio block with every lane busy (the card body's CPU readout turns orange above it), and about 6 MiB per GLTCH, released about 2 seconds after its chain's graph stops.

Both factory racks use GLTCH: DA_Rack_ThumprAcid (the Thumpr chain into GLTCH1 with the Beat Repeat Classic bank, see DA_Rack_ThumprAcid) and DA_Rack_BloomBeat (the DrumKing chain into GLTCH with the Glitch Grid bank, see DA_Rack_BloomBeat). Every lane, setting and factory bank is in the full guide, GLTCH.

The Level Sequence Techno_Rulez (DAWntless Content > Demos) is a 32-bar techno track at 128 BPM in 4/4, printed from the factory rack DA_Rack_TechnoRulez (DAWntless Content > Examples > Rack), arranged by muting note sections, and automated with device lanes. Open it in Sequencer and press play, or play it in PIE and in a packaged game with the DAWntless sequence clock actor.

DA_Rack_TechnoRulez has four chains at 128 BPM, master output 0.8. Everything is in C minor: the acid's Warehouse slot plays C, E♭, G and B♭, and the stabs use only the notes of C natural minor.

• The muted 808 kick. Techno Drive puts an 808 kick on every beat, and the Kick chain already plays the song's kick. The Drums STPR-1 keeps its own copy of the factory drum patterns with the Techno Drive kick lane muted, so the hits are still there: unmute the lane on the Drum page to hear both kicks.
• Techno Rulez Stabs uses per-note lengths (see STPR-1). Four pad chords last 16 steps each: Cm, B♭, A♭ and Gm, whose three notes last 8, 12 and 16 steps so the last chord thins out. A short stab on the "and" of beats 2 and 4 starts under each held chord and plays with its own velocity and gate. A high G starts at step 57 and holds to the end of the pattern. Drag a bar's edge in the STPR-1 grid to change a length.

Load the rack in TheRaK and press Play jam to hear the chains without the arrangement. Like the other factory racks it is never overwritten: Save as stores your version.

Each chain is printed into its own track for the 32 bars, and the arrangement mutes whole note sections, so every note stays in the track and you can unmute a section in Sequencer to hear it.

Muted sections: Drums in bars 1–4 and 25–28; Acid in bars 1–8 and 29–32. Kick and Stabs play throughout.

The sequence's tempo data (the duration the DAWntless transport shows) says 33 bars, as it was saved; the playback range, and the song, end after bar 32.

Each track has its lanes on its automation row, grouped by device (see Print to Sequencer). Select a lane and open the Curve Editor to edit it.

"Held" lanes keep each value until the next key; "smooth" keys are the Curve Editor's own cubic keys with automatic tangents (the first and last key of SQLCH > Cutoff have fixed tangents). When playback stops, every device gets its own values back (the Acid its 700 Hz cutoff).

Any MetaSound Patch that declares a DAWntless interface can become a rack instrument or effect, and a MetaSound Source can become an instrument. Check it in the Device Validator (+ Add Device > Manage user devices..., Tools > DAWntless > Device Validator, or Validate as DAWntless Device... on the asset in the Content Browser), fix what it reports, and press Register. The device then appears in Add Device under User, or User > <Category>, with knobs from its inputs. The examples Chorus, Pluck and Source Lead are in DAWntless Content > Examples > UserDevices, and Add Device lists them under User > Examples.

If you change a registered device's MetaSound inputs or its definition's ranges later, its cards show NEEDS VALIDATION and its chains keep the sound they have until you register it again (see Device cards).

The full guide is Your own TheRaK devices: formats, interfaces, parameter names, the validator's checks and codes, NEEDS VALIDATION, and validation in CI.

Click a card's header first, so the device list has keyboard focus. Typing in a text or number field never triggers these keys.

In the Mixer view, click a column first: M and S (Ctrl+S: solo only this chain), Left / Right (the next column), Space and Ctrl+T work there too.

Every rack saved before this update, and every rack you start with New rack, is a classic rack: one STPR-1 → Afterglow → Stereo Delay chain on the classic engine. Classic racks load, play, save and print exactly as before, and printed classic tracks are never changed.

With the device rack on, a classic rack shows three rows, 01 STPR-1, 02 AFTERGLOW and 03 STEREO DELAY, with the same controls as the classic panel, followed by a chain strip and + Add Device. The strip's Level is the rack's output (up to 0 dB), its M is the jam mute, its Pan is disabled, and it shows LEGACY ENGINE [Upgrade]. Opening, playing and saving a classic rack this way changes nothing in its file. Bypass, rename and colour need a device rack, so the three rows do not offer them; the chain's name is the rack's Part name, which you rename with a double-click on the strip's name.

The rack stays classic until you change its structure. Adding a device turns it into a device rack within the same Undo step: the three rows become device cards, the original chain stays on the legacy engine, and chains you add beside it use the device engine. Deleting the chain ([...] > Delete chain) leaves an empty device rack. [Upgrade] turns the rack into a device rack and moves its chain to the device engine at once. Undo restores the classic rack exactly.

A device rack that still holds exactly one chain on the legacy engine, with nothing a classic rack cannot store (chain level at 0 dB and pan centred, no mute or solo, master level at 0 dB or below, STPR-1 and Afterglow not bypassed, STPR-1 and delay not renamed or recoloured), is saved in the classic format, so older versions of the plugin still open it.

A chain on the legacy engine keeps working: knobs, patterns, presets, bypass, mute, level up to 0 dB, moving or deleting the whole chain, and adding chains beside it. Some things wait for [Upgrade]:

• Pan and Level above 0 dB are disabled, with the tooltip "Upgrade this chain to use Pan / +dB".
• Editing the devices inside the chain (adding, removing or moving one of its effects, replacing its instrument, or re-attaching its STPR-1) is refused with "Upgrade this chain to edit its devices", and the status line offers [Upgrade].
• Playing notes into it with MIDI focus: your keys only transpose its pattern, as they always did.

Why they wait. The legacy engine is the original graph your rack was built with. It sequences on the game thread, has a fixed STPR-1 → Afterglow → Delay shape, has no pan input and stops at unity output. Keeping it untouched guarantees that your existing racks and prints sound exactly as before until you decide otherwise; nothing upgrades on its own.

[Upgrade], on the strip badge, in the status line or in the card's [...] menu, moves the chain to the device engine in one Undo step. The chain sounds musically the same, but its timing becomes sample-accurate, so the result is not bit-identical. Undo reverts it.

With the device rack off, TheRaK shows the classic panel. The three rows described above behave the same way in both.

1. Open TheRaK from Tools > DAWntless, or press OPEN TheRaK in the DAWntless transport panel.
2. Select one of STPR-1's 32 pattern buttons. Use the grid to add or move up to three notes per step; each note has its own velocity. Velocity zero keeps a note visible but silent. A pattern can contain up to 64 steps.
3. Set BPM and press Play jam. The rack joins the shared jam clock at its next 4/4 bar. The DAWntless transport's metronome follows that clock when Click is enabled.
4. Expand Afterglow to edit the sound or load another preset. Its controls affect this rack while the pattern plays. Pattern-bank and sound-preset selections copy their contents into the rack, so factory assets remain available for reuse.
5. Expand Delay to change its time, feedback, mix, or bypass. Time is in seconds. Output controls the level after the instrument and delay; Mute silences the chain while its pattern keeps moving.

Pattern buttons switch at the next step without restarting the instrument or cutting its delay tail. The small OUT meter at the top shows this rack's stereo output in dBFS, after its instrument, delay and output gain. Orange indicates little headroom; red indicates clipping.

The whole rack scrolls together, and device sections can be collapsed. Normal mouse-wheel movement over the grid scrolls the rack; Ctrl-wheel changes the grid's pitch range. Closing the tab keeps the jam running and preserves the working rack. Reopen it to continue editing, or press Stop. Starting arrangement playback or PIE stops the editor jam.

STPR-1 MIDI input transposes the sequence. Select a root note and input channel; channel zero accepts all channels. A positive-velocity note-on sets the transpose, which stays in effect until another key is pressed or transpose is reset. It does not arpeggiate incoming chords; the pattern itself supplies the polyphonic notes.

MIDI device selection uses DAWntless's shared input port. Transpose controls are saved with the rack's bank. A connected controller is optional; patterns play without one.

Save rack creates a project asset under /Game/DAWntless/Racks on the first save, and updates that asset on later saves. Save as creates another asset. The asset stores the pattern bank, selected slot, Afterglow settings and imported sample PCM, delay settings, output level, part name and jam tempo.

Use the rack asset picker to load an editable copy. Loading a complete rack stops its current jam; press Play jam to launch the loaded setup. Changing the Afterglow preset or pattern bank within a playing rack keeps that performance available for live editing.

1. Open the destination Level Sequence and position its playhead.
2. Enter a Part name and choose Repeats (1–128).
3. Press Print to Sequencer. DAWntless creates a new MIDI track at the playhead, writes the selected pattern and any control lane, and extends the sequence's playback range if needed. One Undo removes the whole print.
4. Save the Level Sequence. Use the arrangement transport to hear the printed track, and the existing DAWntless sequence clock actor workflow for PIE or game playback.

The track owns a snapshot of the rack's instrument, sample data, effects and pattern bank. Later edits to the jam rack or its saved asset do not change that printed track. Several printed rack tracks have independent audio components and sound settings; they can use MIDI routes beyond the three routes of the legacy playback graph.

• Devices available now: STPR-1 (melodic patterns, and Drum Mode on drum instruments), Afterglow and DrumKing (instruments, see DrumKing), Thumpr FM Drum and SQLCH (instruments with their own sequencers, see Thumpr and SQLCH), GLTCH and Stereo Delay (effects), and your own MetaSound instruments and effects once you register them (see Your own devices).
• Example racks: DA_Rack_Demo_TwoChains, DA_Rack_ThumprAcid, DA_Rack_BloomBeat and DA_Rack_TechnoRulez, with eight DrumKing kits and twelve GLTCH banks, and the demo track Techno_Rulez (see DA_Rack_TechnoRulez and Techno_Rulez).
• In your game: the TheRaK Performer component plays a saved device rack in PIE and in packaged games (see TheRaK Performer (gameplay)).
• Note lengths and device automation: STPR-1 notes have lengths that you drag in its grid (see Per-note lengths), and a printed chain is automated device by device from Add MetaSound Automation or from a knob's right-click (see Print to Sequencer).
• Search in the Add Device menu (see Add devices) and [...] > Clean up unused chain graphs... (see Clean up unused chain graphs).
• Coming in later updates, listed but disabled in Add Device: master-bus effects.
• The device rack is on by default; Enable Device Rack in the project settings turns it off. Every existing rack keeps working with it on or off.

Printed rack tracks reference their saved chain graphs, or the classic rack source for classic chains, and the TheRaK Performer plays a saved rack's graphs. Save and cook the Level Sequence or the level through the normal project workflow: nothing is composed in a packaged game. Playback uses runtime modules; TheRaK's window and the graph builder are editor-only.

For a procedural performance of a classic rack in a game, the STPR-1 Performer component takes a saved classic Rack Preset, with its MIDI transpose and custom-controller InputNote entry point. It does not play device racks: they play through the TheRaK Performer, or as printed tracks in a Level Sequence. A printed rack track can also be targeted by DAWntless's live MIDI performance component for direct-note monitoring.