Skip to content

Atomik Rack v0.3.0-rc.1

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 11 Nov 02:37
· 1282 commits to main since this release
4b931cd

Added

  • Release and dependency hygiene. A freeze or an unfreeze that finishes while the transport runs no longer
    rebuilds the engine under it: the sound goes on, the message says the freeze plays when playback stops, and the
    engine is rebuilt at the stop. Where plugins run is shown, not assumed: Settings > Plugins says "Running now:
    separate process" or "in-process", the status line shows plugins: sandbox or plugins: in-process while plugins
    are on, and a sandbox that is switched on but cannot start says so once instead of falling back silently. Waiting
    for plugins to load is bounded by time. docs/DEPENDENCIES.md lists the deliberate pins and why, the duplicate
    versions that deny.toml skips by root cause (so only a new duplicate warns), and the quarterly bump of the
    0.x GUI stack, which a scheduled workflow opens as an issue; the same workflow prints cargo update --dry-run every
    Monday. Every advisory ignore has a review date and the Security workflow fails once it has passed. The nightly
    release uploads its new files before it deletes the old ones, so it is never empty, and a manual run can be a dry
    run (dry_run); every build writes a Sigstore provenance attestation for the files in SHA256SUMS. The MCP server
    skips a message over 16 MiB with a protocol error and stays usable, and docs/MCP.md states the headless, no audio,
    no plugins contract. SECURITY.md says how far the plugin cache is trusted and why the macOS app has the
    library-validation entitlement. The sandbox child is an accessory process on macOS (no Dock icon) and a utility
    window on X11; the sandbox end-to-end tests have a CI job on Linux and macOS.

  • Modulation matrix framework. A device can declare modulation sources and targets and sum up to eight
    slots (a source routed to a target with an amount, and optionally a second source that scales it) at its
    control rate, with no allocation and only + - * /, so the result is bit-identical for every block size and
    worker count. The document stores the slots per device with one undoable command, the amount of a slot is an
    ordinary automatable param, and a project without slots saves, loads and bounces as before (project format
    41). The poly synth and the mono bass use it first: the three envelopes, both LFOs, velocity, key, mod wheel
    and pressure (channel and poly pressure finally have a destination) can move cutoff, pitch and level. A device's
    right-click menu opens its matrix (see below).

  • Modulation matrix panel. Right-click a device that has a matrix (the poly synth, the mono bass) and choose
    Modulation Matrix: eight rows of source, target and via pickers (a menu of the device's own entries, the current
    one checked) and an amount bar, with the amount from -100 to +100 %. A slot needs a source and a target; until
    both are chosen the row stays a draft, and clearing either side of a slot in use clears it. Picks and the
    amount bar are ordinary undoable edits (a drag is one undo step) and the engine hears them like any other
    parameter change; editing a slot while a note sounds does not click. Esc closes the menu, then the panel.

  • Text fields with a caret, a selection, the clipboard and input methods. One text field now serves the Song
    Information panel: click to place the caret, drag or Shift+arrows to select, double-click a word, Ctrl+A,
    Ctrl+arrows by word, copy, cut and paste with the system clipboard (the arboard library, MIT or Apache-2.0,
    text only), and input-method composition (Japanese, Chinese, Korean, dead keys) with the pre-edit text
    underlined in the field. A character typed with AltGr is text and never runs a shortcut in a text field. The
    in-place name edits of the rack, mixer and arrangement keep their end-of-text editing for now.

  • The piano roll keeps the same notes selected through edits that reorder them. A quantize that moves a note
    past another, an undo, or a note added before the selection used to leave the selection on whatever sat at the
    old positions; it now follows the notes (by key and order within the key, else by start and key) and goes back
    to the original notes when an edit it could not follow, such as a transpose, is undone.

  • Saved-file corpus and sound pins. crates/model/tests/fixtures/corpus/ now holds one real saved project for
    every released format version with a surviving writer (1, 6 to 41), each checked to load without a warning, resave
    canonically and hold the same tracks, clips and notes as pinned; every file that has no audio bundle is also
    bounced and its per-second level (all platforms) and exact hash (Windows x86-64) pinned. The release workflow fails
    when the current format has no corpus file. A list of which sound is claimed bit-identical on every platform
    (claims.toml) is checked against the pinned stage blocks, every example project is checked to bounce to the same
    bits at several block sizes and worker counts, and the CI runs the release profile on Windows too.

  • CLAP presets, knobs that follow a preset, and a browser info pane. A CLAP plugin's presets (those inside the
    plugin and the files in the folders it declares) are listed and loaded in PARAMS like VST3 presets, also from a
    sandboxed plugin. After a preset is loaded, or a patch is changed inside the plugin's window, the rack's knobs show
    the values the plugin now holds, and undo puts them back together with the sound. With Browse aimed at a plugin
    device the file browser lists the plugin's presets as rows (Enter or a double-click loads one). Selecting one audio
    file in the browser shows an info pane under the list: format, channels, rate, length, size, the tempo the file
    states, tags, author and categories, and a loudness picture read on a worker thread. VST3 program lists and a
    background index of the browser are not built yet. No project format change.

  • SFZ and SoundFont import into the sampler. Drop an .sfz or .sf2 file on a sampler (or load it from the
    sample editor) and it becomes the sampler's zones in one undo step. An SFZ keeps its regions, key and velocity
    ranges, root keys, loops, tuning, volume and pan, amplitude envelope, filter, round-robin, velocity crossfades
    and <group> headers; a SoundFont brings its own samples, and its first preset is read (ranges, root, tuning,
    attenuation, pan, loops, volume envelope, low-pass filter). Samples are converted to the project rate and
    stored in the project. Whatever is not read (unknown opcodes, release-triggered regions, modulators, other
    presets) is named once in a message and never stops the import. The readers cap file, region and sample
    counts, never panic on damaged files and have a fuzz target. The loop slicer's eight slots and the sampler's
    eight outputs are not built yet. No project format change.

  • Space reverb, convolution reverb and vocoder. Three new effects. The Space Reverb adds arena, cathedral,
    spring and echoverb algorithms to the reverb engine, with a wet high cut and a gated tail (hold time and level).
    The Convolution Reverb plays an impulse response from an audio file of the project (drop a .wav on the device;
    no impulse files ship): a mono or stereo response of up to 5 seconds, level-normalised, with pre-delay, low and
    high cut, width and mix. It adds no latency, equals direct convolution to float rounding, allocates only when
    the device is prepared, and swapping the response crossfades instead of clicking. The Vocoder is a 4 to 32 band
    channel vocoder with a carrier input (an internal noise carrier when none is cabled) and a hiss path for
    consonants. A gated three-band filter, a bass amp voicing, echo loop jacks and a spectral vocoder mode are not
    built yet. No project format change.

  • Pattern lanes. The pattern lane of a step sequencer, CV sequencer or drum generator is now a pattern
    lane: it reads "Pattern", draws its held numbers as labelled blocks, and a right click on a clip lists the
    device's patterns to pick from (a clip drawn on it starts with one stepped point). A take now catches pattern
    changes without AUTO LANES: the first one adds the lane and each change is written on the next downbeat as a
    held number, so the clip switches on a bar line. Track > Add Pattern Lane adds the lane, and Track > Pattern
    Lane to Notes renders what the patterns play, in the order the lane chose them, into a clip on a new note
    lane. No project format change: a pattern clip is an ordinary automation clip. A pattern offset is not built.

  • Bent automation segments. Shift-drag on an automation segment bends it so the curve passes through the
    pointer at the middle of the segment (one undo step); a click without a drag, or a Shift-click on a point,
    straightens it again. The bend is a power curve evaluated with plain arithmetic only, so a bounce is
    bit-identical for every block size, worker count and platform, and the value a control shows is the value the
    engine applies. Points added on a choice, a switch or another whole-valued parameter now hold their value
    instead of ramping.

  • Parameter lanes in note clips. A note clip can carry device-parameter lanes (a cutoff sweep, a send
    level) that move, duplicate, split and loop with the clip; a track's own automation lane of the same
    parameter overrides them. Edit > Move Automation into Note Clip turns a selected automation clip into a
    lane of the selected note clip, and Edit > Clear Clip Parameter Lanes removes them. Recording into a note
    clip and drawing a lane inside the piano roll are not there yet. Both additions are written to the project
    only when used (format 41), and the MCP project_inspect lists the lanes.

  • Containers fold and unfold in the rack. A container no longer has to be opened in a view of
    its own to be worked on: the arrow on the title strip of its panel, or a double-click on the
    panel, draws its devices straight under it in the same column, framed in the container's colour
    between a thin INPUT strip and a thin OUTPUT strip that closes the frame. A container nested in
    an unfolded one unfolds the same way, one frame inside the other. The devices are the ones of
    the rack for every gesture: knobs and buttons, patch strips, selection (it stays inside one
    container), delete, duplicate, rename, the macro menu of a control (it maps to the container
    the device is drawn in), the add key after the selected device, and a drag inside the frame
    reorders. Drag a device of the rack into a frame and it moves inside; drag an inner device out
    of its frame and it moves back to the rack, in the column of its container (the model says why
    when it refuses); drop a browser row or a library item in a frame and it is added inside. On
    the back (Tab) the INPUT and OUTPUT strips show the container's own jacks, so cables between
    the container's sockets and its inner devices are patched as in the container's own view, and
    a cable never joins two levels. A Combine leaves the new container unfolded, so what you
    combined stays in view. Whether a container is unfolded is saved with the project (an optional
    "open": true in the container, written only when it is set; the project format is unchanged)
    and is one undo step. The OPEN button still shows the inside in a view of its own.

  • Master tune. Audio > Settings has a Master tune of -100 to +100 cents around A = 440 Hz. It
    shifts every pitched device (the synths, the sampler, the drum machine, the loop slicer and the grain
    sampler; a fixed-frequency FM operator keeps its Hz) and the reference of the audio track tuner, is
    saved with the song and is part of a bounce, so the file sounds as it was heard. Changing it while
    notes ring glides instead of stepping, and it is one undo step. A value changed in Settings is also
    the tune new projects start with. Audio tracks and plugins are not affected. It is written only when
    not 0, so older projects load and bounce unchanged.

  • Several control surfaces, generic controllers and command mappings. Settings > Surfaces now
    lists any number of surfaces (up to eight), each with its own driver, ports and an on/off
    switch; an older settings file with one surface loads as a list of one. A new Generic
    controller driver has no fixed layout: its controls are mapped with MIDI Learn, and a mapping
    learnt from a surface hears that surface only, so two controllers can send the same controller
    numbers to two devices at once. A mapping can address the focused device (the device selected
    in the rack) and Mixer > Lock Surfaces to Selection pins each surface to that device while the
    selection moves on. A control can also run a command: undo, redo, previous or next track,
    previous or next preset of the focused device (Mixer > Map Command arms one for the next
    control moved). Undo from a control takes back a whole mapped sweep as one step. The new
    mapping fields are written only when used, so older projects load and bounce unchanged.

  • Alt+drag a clip edge to stretch it. With the Select tool, hold Alt (the alternate-tool role)
    over the start or end edge of a clip and drag: the clip gets longer or shorter by a ratio, the
    opposite edge stays where it is, and everything in the clip follows. Note starts and lengths
    and automation points scale proportionally, and an audio clip is warped to the new length with
    its pitch kept (it keeps its warp mode, Repitch included; a clip that is not warped yet turns
    warping on with the default engine, and one that plays backwards is refused). Every selected
    clip stretches by the same ratio about its own fixed edge, so each keeps its own start (or end).
    The edge snaps to the grid like a resize does (the disable-snap role works), the clips change
    live while you drag, the release is one undo step and Esc puts everything back; over an edge
    with Alt held the pointer is a split-bar cursor. Alt on the body of a clip keeps the alternate
    tool. The same ratio code as Scale Tempo does the work (the model command is StretchClips;
    the project format is unchanged).

  • Insert and Remove Bars at Locators in the ruler menu. Right-click the ruler: the two
    commands sit under the locator items, next to the Edit menu entries that already did the same.

  • The logo in the About box and in assets/logo/. Help > About now draws the AR monogram at
    the top. assets/logo/monogram.png (transparent) and assets/logo/monogram-black.png (the same
    on opaque black), both 512 pixels, are derived from the master by the make_icons example. The
    headless screenshots draw images too now.

  • MIDI files in the browser. The file browser now lists .mid and .midi files (with a MIDI
    label, and kind:midi in the search field). Double-click or Enter, or Import in the row menu,
    imports one as File > Import MIDI does. Drag one from the browser or the system onto the
    arrangement: on a note lane it becomes one clip on that lane at the snapped drop position (a
    file with several tracks is merged into the one clip), below the tracks or on another kind of
    lane it makes new tracks from the drop position. Dropped anywhere else it still makes new
    tracks at the playhead.

  • Spectrum EQ window. View > Spectrum EQ (F2) opens a floating, resizable window with a
    real-time analyser of the selected mixer strip, measured after its EQ and before its fader, and
    the strip's filters and EQ drawn as a response curve. Drag the HF, HMF, LMF and LF points (Shift
    keeps one axis, Alt-drag or the wheel changes a bell's Q, Ctrl-click resets the gain) and the
    high-pass and low-pass corners; a drag is one undo step and records automation. Checkboxes
    switch the EQ, the filters and the shelf-or-bell shape of the outer bands, the arrows pick a
    strip, and Follow Selection keeps the window on the selected one. The master shows the analyser
    only. The strip writes its analyser tap only while the window shows it, so a closed window costs
    nothing and renders stay bit-identical.

  • Sampling into devices. A SAMPLE button beside EDIT on the sampler, granular, drum machine and

  • Direct Record, Send Players to Track, Fold All and Bypass All Players. New Track menu items
    act on the selected tracks that have players above their instrument. Direct Record makes the
    take record the notes the players generate (what the instrument receives) instead of the keys
    you play; the flag is saved with the track only when it is on. Send Players to Track renders
    the song offline and writes what the stack generated, from the start to the song end, as a clip
    on a new "Players" lane in one undo step. Fold All and Bypass All fold or bypass every player
    of the stack, and undo as one step.

  • Arpeggiator: step pattern, insert, free rate, shift, repeat and input range. A row of sixteen
    step cells (rest, on, tie, accent; a click cycles them) shapes the rhythm: a rest is silent, a
    tie lengthens the note before it, an accent plays at full velocity. Insert plays the lowest or
    highest key between the notes, shift transposes the figure, repeat plays each note up to four
    times, and a free rate sets the step in steps per second. Keys outside an input range are passed
    through as played. With all of it off the arpeggiator plays as before.

  • Note filter: fixed note length, polyphony limit and hold. A fixed length ends each note by
    itself whatever the key does, a limit of 1 to 16 voices either steals the oldest note or ignores
    the new one, and hold keeps notes until it is switched off. No note hangs on an all-off or a
    reset.

  • Key & Chord: custom scale, chord alter and chord size. Twelve toggles define a scale of your
    own (an empty set restricts nothing), alter moves the third or fifth of a chord (major or minor
    3rd, sus4, flat or sharp 5), and a size limit keeps the lowest one to five notes.

  • Note repeater: repeat mask and chord mode. A 16-bit mask picks which repeats play (the
    others keep their place and decay), and chord mode starts every repeat with the note.

  • Drum generator: map mode. The first four patterns become the corners of an XY map; position,
    density and mirror blend them with seeded randomness, so the corners play their own pattern
    exactly and the same hits come back after a locate. A lock per drum role keeps that role on the
    playing pattern. The panel is one rack unit taller for the map knobs.

  • Line Mixer: aux send and return. Every channel gets an aux send (post-fader, or pre-fader
    with one switch) into two new aux outputs, and two aux inputs come back into the master at their
    own level. A mixer without a return sums exactly as before.
    loop slicer panels records from an audio input pair into a 30 s ring, cuts the silence before the
    sound and lands the sample in the device as one undo step (a drum machine puts it on the selected
    pad). A second press stops, Esc cancels, a right-click picks the next input pair or single
    channel. Sampling and recording audio tracks exclude each other.

  • Sample edits as render operations. Crop, normalise, reverse and fade in or out render a new
    sample on a worker and swap it into one zone, or every zone that plays the same sample, in one
    undo step; the zone markers stay on the same audio. The pool can count what uses each sample.

  • Drum generator: 32 patterns, flams, ratchets and a resolution and shuffle per pattern. A step
    can carry a flam (a soft grace hit and the full hit up to half a step later) or a ratchet (two to
    eight even hits across the step). The panel shows 32 patterns as four banks of eight, has RES and
    SHUF steppers for the edited pattern's resolution and swing, and a mode button that makes the
    cells edit velocity, flam or ratchet. The later hits of a flam or ratchet always end, even across
    a jump, a mute or a bypass. Flams and ratchets are saved as optional lane rows, only when a step
    uses them; the CV sequencer also holds 32 patterns (its panel shows the first eight).

  • Drum machine: tone, low and high cut, drive and two sends per pad. Each pad gets a tilt
    tone, a low cut, a high cut, a drive and two send levels that feed four new shared send outputs
    (send1_l, send1_r, send2_l, send2_r). A pad with every effect at its default renders
    exactly as before; the drum panel is one rack unit taller for the extra knobs.

  • Step editor: shift, randomise, alter and invert. Toolbar buttons and the commands
    editor.step_shift, editor.step_randomise, editor.step_alter and editor.step_invert move
    every hit a step, replace the pads in use with random hits, flip a few cells or swap hits and
    gaps. Each is one undo step; the random tools are seeded, so a repeat press gives another take
    and the same press always the same one.

  • Mod Source: LFO cross-modulation, lag, key follow and a 1 kHz rate. LFO 2 can bend the rate
    and dip the level of LFO 1, a lag smooths all three outputs, key follow scales the free LFO rate
    with the latest key, and a free LFO runs up to 1000 Hz. All new params default to no change.

  • Sampler: zone groups, velocity crossfades, round-robin and per-zone envelope and filter. A
    zone can belong to a group, fade in and out over a velocity range with an equal-power curve,
    take a slot in a round-robin cycle (counted per group and key, so a bounce and a locate repeat
    it) and carry its own amplitude envelope and filter. The sample editor has a SYNTH page for them;
    envelope and filter edits follow the zone's group. New zone fields are written only when set, so
    existing projects load and render as before. Not in this version: SoundFont and SFZ import,
    eight sampler outputs and the eight-slot loop slicer.

  • Effects: more distortion, an echo, a soft clip, split-band width and a choice of look-ahead.
    The distortion gains five curves (tape, fuzz, modulate, warp, scream, each with
    first-order anti-aliasing), a cut.low and cut.high pair and a body bank (resonant or
    cabinet-like, with body.amount and body.size); its panel is three rack units tall now. The
    new Echo (atomik.echo) is a stereo delay whose repeats take a saturator, a low and high cut, a
    bit crusher, diffusion and wobble in the feedback loop, with ducking by the input level, ping-pong
    and three modes: normal, triggered (the repeats are heard while a trigger cable is high) and roll
    (the input is cut and the loop holds). Mastering gains a softclip before the limiter, a
    lookahead of 0.5, 1.5 or 4 ms (it changes the reported latency, and the ceiling holds at every
    one), and a split-band width: width.split with width.freq, width.lo, width.hi and a
    width.solo to hear one band; its panel is five rack units tall. Every new param defaults to the
    old sound bit for bit, so existing projects render as before. Not in this version: the
    Pulveriser, the echo loop breakout jacks, the extra reverb algorithms with gate and EQ,
    convolution with impulse responses, the vocoder, the gated filter, the bass amp voicing and the
    modulation and ensemble additions. The project format is unchanged.

  • Synth expansion: wave tables, oscillator modes, a second filter, a mono bass and a dual
    layer.
    The poly synth gains params, all defaulting to the old sound bit for bit (existing
    patches and projects render as before): osc1.table and osc2.table pick one of 32 additive
    waves (band-limited by mip level), osc2.mode makes oscillator 2 ring, FM or hard-synced to
    oscillator 1 (osc2.amount), filter.type swaps the 12 dB filter for a 24 dB ladder with an
    anti-aliased filter.drive, filter2.* adds a second filter in series or parallel whose
    cutoff follows the first one's modulation by filter.link, lfo2.* is a second LFO (pitch,
    cutoff, level), env.mod.* is a mod envelope with a destination (pitch, osc 2 pitch, osc mix,
    osc 2 amount, filter 2 cutoff), glide and legato play like a mono synth, spread pans the
    voices by key into a real stereo pair, drift detunes each voice by a slow seeded random
    amount, and chorus.* and delay.* are an in-device chorus and ping-pong echo. Two new
    instruments share the voice: the Mono Bass (one voice, legato, glide, the ladder with drive,
    a light chorus) and the Dual Layer (two complete poly synth layers with layer.mode stack or
    morph, layer.morph and layer.age; each end of the morph is one layer exactly). All three
    use the generic panel for now (the poly synth is seven rack units tall); a hand-drawn panel,
    a modulation matrix and per-voice layer splits are not in this version. The project format is
    unchanged.

  • Plugin presets, patch steps and plugin window geometry. The PARAMS pane of a plugin that
    offers presets has a preset bar: < and > load the previous or next preset (round the list),
    the name opens the list. A preset is loaded into the live plugin as one undo step, and undo and
    redo hand the state back to the plugin. VST3 presets are the .vstpreset files in the platform's
    preset folders (ATOMIK_VST3_PRESET_DIRS replaces them); a sandboxed plugin lists and loads
    them through new ListPresets and LoadPreset messages. A patch changed inside the plugin's
    own window is now an undo step too (stored at the next quiet capture, when the window closes and
    before an undo; a param gesture stays its own step). A plugin's window opens where the last
    window of the same plugin was, position and size, kept in ui-state.json and only on a screen
    that still exists. The plugin list of Settings shows ENABLED, DISABLED, UNSUPPORTED, COULD NOT
    LOAD or CRASHED for each plugin; a plugin whose process ended on its own stays CRASHED, also
    after a restart, until RETRY in its row clears it. Not in this version: CLAP presets, VST3
    program lists, presets in the browser, the mini toolbar of the plugin window (Automate, Remote,
    Screenshot), the per-plugin Windows DPI choice, and the panel screenshot.

  • Browser organisation: filters, history, info and favourite lists. The search field takes
    kind: (audio, wav, flac, folder, patch, clip, item, ...), cat:, author:,
    in: (a folder the file lies in) and tag: next to words, #tag and fav; all tokens must
    match. The path bar of the file browser has back and forward buttons over the last 64 places
    shown, and a right-click on it lists every folder above the one shown. The right-click menu of
    a row adds Show in Folder (the file selected in the system file manager), Edit Author, Edit
    Categories, and favourite lists: Add to a list, New list and, inside a list, Remove from it.
    The tree lists the named lists under Favourites and has Rename and Delete for each. Authors,
    categories and lists are saved in library.json, now version 2; a version 1 file opens as it
    was and is written as version 2 by the next save, and a file that cannot be encoded is reported
    instead of replacing the library with an empty one. A rename of a library item keeps its place
    in its lists. Not in this version: the persistent index and All Locations place, the preview
    level and waveform, .mid rows, device palettes with categories and tags, and import-time
    warp and placement preferences.

  • Comp rows: crossfades, silence, take level and offset, and a take menu. A cut between two
    audio takes in a comp can have a crossfade: the take before the cut runs on past it and the
    take after it fades in over it (equal power, two overlapping regions in the engine, no dip), up
    to the length of the segment after the cut and what is left of the take before it. A cut with
    no crossfade is the 5 ms dip as before, and such projects bounce bit for bit as they did. In
    the comp strip a drag across it silences the range, a drag of a cut moves it, and a crossfade
    has a handle on its tail; the strip's right-click menu sets the crossfade of the nearest cut
    (None, 1/32 to 1/4 note), silences a segment and deletes the takes the comp does not use. An
    audio take row now draws its waveform, and the right-click menu of a take row duplicates the
    take, moves it up or down (what plays does not change), deletes it, and for audio steps its
    level by 3 dB and its audio by 10 ms inside the file. New commands: DuplicateTake,
    MoveTake, DeleteUnusedTakes, SetCompSilence, SetCompXfade and SetTake, each one undo
    step. A comp segment saved with a crossfade has a fourth element (ticks); one without it is
    written as before, so the project format is unchanged (still version 39) and a file without
    crossfades opens in older builds. Copying takes between groups and songs, importing a file as
    a take, a razor tool and keys to step between take rows are not in this version.

  • Resampling. An audio track can record the output of a mixer strip instead of its inputs: the
    input menu in the track header lists Channel: name, Bus: name and Master: name after the
    inputs, and arming and recording then prints that strip. The engine copies the strip's output at
    the end of each batch, so the clip is sample-identical to what the mixer rendered, and it is
    placed by the strip's own delay (a strip behind a latent effect lands where you hear it on the
    timeline). Inputs and strips can be recorded in one take, each track with its own input gain and
    clip-safe. A track cannot record a strip it feeds (its own channel, or a bus or the master it
    plays into): that take records nothing and the message says to send the track's channel to an
    Audio I/O pair or pick another source. The choice is a new rec_source setting of the audio
    track (not a project format change; a project without it records the inputs as before).
    Recording a player's generated notes, Send to Track and the player stack header are not in this
    version.

  • Mix channels, parallel channels and sends that follow the bus. Create > Create Mixer
    Channel makes a channel with no instrument behind it, wired to the master, whose inputs are
    its Direct In: cable a track or an effect there. Mixer > Create Parallel Channel adds, for each
    selected strip, a channel fed from the strip's new parallel output (taken before the fader and the
    pan), named P1: name, played into the same bus as the strip. The name follows the strip's renames,
    removing the strip removes its copies, and soloing the strip leaves its copy audible. A copy can
    have copies; a compressed copy blended in matches the strip's own parallel compressor. Mixer >
    Delete Channel (and Delete in the mixer) removes the selected strips: a strip with no instrument
    goes with its copies, a strip an instrument feeds goes with the instrument and its track, asking
    first (choose it again to confirm) when the track holds clips. Mixer > Sends Follow Bus makes the
    post-fader sends of a strip that plays into a bus follow the bus fader and mute, through nested
    buses too; pre-fader sends are unchanged. It is on in a new project and off in a project saved
    before, which bounces exactly as before. The project format is 39: send_follow and parallels
    in the console, each written only when set.

  • Utility devices. The palette gains eight small devices. Gain Tool (gain, balance, width and
    mute, with an aux input to add or cross-fade in and CV on gain and balance), Stereo Tool
    (polarity, width with a bass bypass, balance, mono and mid/side encode and decode), Gate (a
    gate or 2:1 expander with hold, sidechain key filters and a gain-reduction CV out), Gate +
    Compressor (a gate then a compressor with input gain, makeup and mix), Sidechain Tool (pump
    from the song position, trigger from the hits of a key, or classic ducking from its level, with
    depth, attack, recovery time and curve, and a CV out for ducking other devices), Envelope Filter
    (a state-variable filter swept by an ADSR started by a gate CV, notes or the input level, with
    an envelope CV out), Spider Audio (four summing stereo merge inputs and a four-way split) and
    Spider CV (four trimmed summing CV inputs and two split-and-invert inputs). The six effects have
    the BYPASS switch. Their level, gain and time maths is platform-independent, so a bounce is
    bit-identical everywhere, and a pumping Sidechain Tool gives the same gain after a locate as
    playing through. The Sidechain Tool's curve is set by attack, time and curve knobs; there is no
    hand-drawn curve editor yet.

  • CPU meters, an automatic worker count, a free buffer size and a Big Meter. View > CPU
    Meters shows on every device's name plate the share of the audio time that device takes (a
    container shows the sum of what is inside it), so the heavy device is easy to find; the engine
    times its devices only while the switch is on, costs about 70 ns per device per 64-frame batch
    (half a percent of a callback for a hundred devices), and a bounce is bit-identical either way.
    Audio settings now start the number of render workers from the machine (one per physical core
    but the audio thread's own, at most 8; the Auto chip, the default for new settings, a file that
    chose a number keeps it), the Buffer size section has a Type a size field for any value from 16
    to 8192 frames, and its note keeps showing the buffer and the input and output latency of the
    running stream. View > Big Meter floats a larger meter for one pair of the Audio I/O sockets
    over the rack: VU (reaches 99 % of a steady tone in 300 ms, 0 VU at a reference level you can
    move), PPM (falls 24 dB in 2.8 s) or PEAK, a hold marker that stays 5 s or until you click the
    bar, and a clip lamp per channel that stays lit until you click it. Neither switch is saved.

  • Stems, AIFF export and a dry clip bounce. File > Export Stems as Audio Files writes one
    file per mixer strip (every channel, bus, FX return and the master) into a Bounced <song>
    folder, numbered in mixer order, with the same range and tail as Export Song, the same depth,
    dither and rate choices, and a progress bar with Cancel; a stopped export removes what it wrote.
    The stems are rendered in one deterministic pass of the same engine (a few strips per pass, so a
    long song with many strips does not need the memory of all of them), each strip is delayed by
    what the slowest path to the outputs adds on top of its own latency, so the files line up with
    each other and with the mix (and the channel stems add up to the master when nothing is sent
    to an effect), and CHANNELS can take the channels before their strips (the source's own sound,
    no fader, pan, insert or send). Every export has a FILE FORMAT choice, WAV or AIFF (AIFF-C for
    32-bit float), kept in export.json; the file takes the extension of the container. Track >
    Bounce Clips to New Track (Dry) renders the selected clips as the instrument plays them, before
    its effects and channel strip, into a new audio track. The MCP session_export has container,
    stems and stems_dry.

  • Templates, song information, project archives and a scratch folder. File > New from
    Template lists the projects of the new Templates folder (next to the library folder, shown with
    Show Template Folder; a project put there appears in the menu within a second). A template opens
    as an untitled song, so Save asks for a name and the template is never written; its audio plays
    at once and is copied into the project folder on the first save, and a plugin that is not
    installed keeps its stand-in as in any project. Save as Template adds a copy of the song under
    its title or file name (a free name, the song itself untouched), and Use Song as Default Song
    saves one as the Default Song that File > New and a start with no project open instead of the
    starter project (Reset Default Song goes back; Close still starts the starter project). File >
    Song Information has the title, author, e-mail, web address and notes of the song (the notes up
    to 10 000 characters): the title shows in the window title, it is one undo step, nothing is ever
    filled in from the system, and the MCP project_inspect and session_status list what is set.
    File > Export Project Archive writes the project and the audio it uses as one .atomikz file (a
    stored ZIP, so any ZIP tool opens it) on a worker with a cancel; Import Project Archive unpacks one
    into a new folder beside it and opens the project. Unpacking refuses an archive with a path that
    leaves its folder, a duplicate, an unknown file, a compressed or encrypted entry or an entry over
    the limits, before it writes anything, and a failure or cancel leaves no partial folder. The
    relink panel has a PROJECT FOLDER button for a project moved without its folder: the files come
    back by their content. Settings > Workflow has a Scratch folder for the audio of a song that has
    no folder yet (the temporary folder of the system by default). The Workflow tab's rows are a
    little closer together to make room. The project format is now 38: it adds the optional
    "info" root field; older projects load and bounce as before.

  • Note lane workflows. Drag a note lane by its label to another place among a track's lanes or
    onto another track's lanes (a line shows where it will land; hold Ctrl, or Alt on macOS, to
    copy it instead). Merge Note Lanes (Ctrl+R, also in the Track menu and the track header menu)
    puts everything a track plays on its top lane, one clip per stretch of sound, and removes the
    other lanes; the track sounds exactly as before, and it is one undo step. Explode Notes to Lanes
    (Track menu, clip menu) gives each pitch of the selected note clip a lane of its own, named after
    the pitch, and Extract Notes to a New Lane (the piano roll's Notes menu) does the same for the
    selected notes; the source clip keeps its controllers. Dub (Numpad3) adds a new lane to every
    armed note track and records the next pass on it, even while a take is running, from that tick
    on; Alt (Numpad6) does the same and mutes the lane of the last pass. The project format is
    unchanged.

  • Drawing and cleaning up automation, recording tempo. With the pencil, a drag across an
    automation clip writes a point per snap step that follows the pointer, thinned as you draw so a
    long stroke does not leave hundreds of points; a press without a drag still places one point.
    Shift puts the points exactly on the straight line from where you pressed, and Ctrl+Shift (Cmd+Shift
    on macOS) holds the pressed value up to the pointer as a flat range. One stroke is one undo step,
    and Escape puts the clip back. Edit, the clip menu and the track menu have Cleanup Automation with
    Normal, Heavy and Maximum (0.5 %, 2 % and 5 % of the parameter's range): it thins the selected
    automation clips, or every automation clip of the selected tracks, in one undo step. Interface
    settings has a new Automation thinning choice for the same three levels; it also sets how many
    points a recorded take keeps, so that amount is now a preference. The tempo lane header has an
    R button: with it lit, a take also records the tempo you set while it runs (dragging a tempo
    point, typing a tempo, tap tempo), and when it stops the tempo events inside the recorded stretch
    are replaced by a thinned, ramp-like series in one undo step. The take does not retime itself, and
    warped audio follows the tempo map as before. The project format is unchanged.

  • Note editing tools. The Notes menu of the piano roll (right click on the grid) has Legato
    (the selected notes are stretched to the start of the next one, with an overlap or a gap if you
    like), Join Notes (Ctrl+J: touching or overlapping notes of one pitch become one), Chop Notes
    (cut at the snap step, quarters, eighths, sixteenths or triplets), a Velocity submenu (set a
    value, scale by a percentage, ramp from the first to the last note or fade in and out, randomize),
    Alter Notes (each note, by chance, takes the pitch of another note of the selection), Randomize
    Notes (move pitches by up to some semitones) and Set Pitch, and Select Notes of the Same Pitch
    (a double click on the key column does the same). With nothing selected they work on the whole
    clip, and each is one undo step. The same velocity, alter and pitch tools are in the Note Tools
    submenu of the clip menu and then work on every note clip selected in the arrangement; audio
    clips are skipped. The random tools are repeatable: the result is a function of the settings, the
    clip and the notes, and each use is a new take. The velocity lane is now a pencil: drag over the
    empty part of it and every bar you pass takes the height of the pointer, Shift draws a straight
    ramp from where you pressed, and Alt only changes the selected notes; one stroke is one undo step.
    On a drum machine track the piano roll keys carry the names of the pad samples. Ctrl+J is also
    new in the roll; in the arrangement it still joins clips. The project format is unchanged.

  • Mute, Magnifier and Hand tools. The arrangement toolbar has three more tools in a second
    row of its corner: Mute (Y) toggles the clip you click, or all the selected clips when it is one
    of them; Magnifier (U) zooms in around the pointer on a click, out with Shift, and to a
    rectangle on a drag, across and down; Hand (I) scrolls the view in both directions when you
    drag and edits nothing. Holding the alternate-tool modifier pairs Magnifier with Hand and Hand
    with Magnifier (Select and Pencil still pair, and every other tool gives way to Select). The
    eraser also deletes by a rubber band: drag from an empty spot over clips and they all go in one
    undo step. The corner's M, S and MAN REC buttons were painted once per tool; they are painted
    once now. The project format is unchanged.

  • Console editing. The strips of the console can be selected and edited together. Left and
    Right select the next strip (Shift grows the range, the strip scrolls into view), Edit > Select
    All takes every channel and bus, and Delete removes the selected ones. A fader, a send level, a
    mute, a solo or a send switch of a selected strip moves on every selected strip: levels by the
    same number of dB (the offsets between the strips stay, and the whole group stops where the
    highest one reaches the top), switches to the state you clicked, a double-click resets them all.
    A drag of several faders is one undo step, and Escape puts them all back. Mixer > Copy Channel
    Settings takes the settings of the first selected strip (the strip menu also copies only the
    levels, the sends or the inserts) and Paste Channel Settings gives them to every selected strip
    in one undo step: the params of the copied sections, and an insert chain of new effects with the
    same settings (plugins are not copied). Reset Channel puts the selected strips back to fresh
    ones, keeping their output, and Clear Inserts empties their insert chains (the effects stay in
    the rack). The right-click menu of a name plate lists them. Left and Right used to scroll the
    strips: that is now Ctrl+Left and Ctrl+Right (Cmd on macOS). The project format is unchanged.
    Not yet: cut, copy, paste and duplicate of strips from the console, more than four inserts in
    the console, the RACK and SEQ jump buttons, and the strip and master additions in the roadmap.

  • Looped clips, and clip names and colours. Every clip has a loop handle in the upper right
    corner of its body (it shows while the clip loops, is selected or is under the pointer):
    dragging it to the right repeats what the clip shows, starting a loop of its current content
    when it had none, and dragging back shortens it. The repetitions are marked by bevelled seams.
    Audio clips loop too: each repetition plays the audio from the clip's source offset again, with
    its own fades, gain envelope and warp, cut at the repetition's boundary ticks so it is
    frame-exact whatever the tempo map does; a reversed clip and a take cannot loop, a looped
    clip crossfades with the clip before it only inside its first repetition, and it splits only
    where a repetition starts. The inspector's Loop Length works on audio clips. The clip menu
    gains Convert Loop > To a Single Clip / To Separate Clips (the lane plays exactly what it
    played), Make Loop Instance Independent (the repetition under the playhead becomes a clip of
    its own), Rename Clip... (also a double-click on the clip's header strip) and Clip Colour with
    Use Track Colour. A clip's name and colour replace the generated label and the track's colour,
    follow duplicate, copy and paste, the clip library, a split and a join, and are saved with the
    project and the clip file; the one-clip MIDI export is named after the clip, and
    project_inspect lists them and the loops under named_clips. Project format 37 gains the
    clip fields "name" and "color" (cosmetic, an older reader may drop them) and reads audio
    loops, which older readers refuse; no version bump (37 is unreleased). Not yet: looping an
    audio take, and converting an audio loop into one clip.

  • Track management. A track header can be dragged: the selected tracks (a press on one of
    several keeps the selection) move together to a place of the track list, into or out of a
    folder, in one undo step, with an accent line showing the place (indented by the folder depth)
    and no line where the place would cut another folder in two, where a track is frozen or where
    nothing would change; Escape cancels. With the copy modifier held the drop copies the tracks
    there instead. Edit > Duplicate copies every selected track (devices, console channels and
    clips, not armed) in one undo step and keeps the copies together after the last original.
    Dragging the bottom edge of a selected track's header resizes all the selected tracks by the
    same factor (Alt gives them one height), and Track Height > Minimise / Restore (Alt+Shift+M)
    shortens them to the least height and, pressed again, brings back the heights they had. Track >
    Delete Track and Device removes the selected tracks with their devices (the console channel and
    cables go with them, and one undo brings everything back). A track colour now also colours its
    device, so the rack and the console strip show it, in the same undo step. The project format
    is unchanged. Alt on a folder chevron collapses or expands every folder in one undo step. Not
    yet: dragging a folder row, a folder that mutes and solos its tracks by itself, an automatic
    colour for new tracks, a colour picker, and stacked bars for clips in tracks shorter than 32 px.

  • Rack editing. Moving, duplicating and pasting an effect or a note player re-routes it as if
    it had been created at its new place, in the same undo step: where it was, an insert chain
    closes up, a send/return slot is freed and the tracks that entered at a player enter at its
    successor; where it lands, the creation rules run (an effect below an insert joins that chain,
    below an instrument it goes to its channel, below the master it takes a send, a player feeds the
    device below it). Shift while dropping, or the Workflow setting Auto-route off, keeps the cables
    as they are; a device whose cables are not the ones the rules make is only moved. Dropping a
    device from the browser on the middle of a rack device of the same kind (instrument, effect or
    note player) replaces it: the new device keeps the key, so the track with its clips, lanes and
    armed state, the console channel, the sends, the cables that fit its sockets, the note entry and
    the place in an insert chain all stay; its params start at their defaults and automation lanes
    for params it lacks are dropped. Console devices, containers and devices of a frozen track are
    refused. Create > Create Player opens the browser for note players (also in both rack context
    menus), and Alt on the fold button folds or unfolds the whole column in one undo step. Cables
    are coloured by what they do (inserts, sends and returns, sidechain keys, audio, notes and
    control), and the cable display has two more modes, selected devices only and everything but the
    console's own routing, with a dot on the jacks of a hidden cable; K walks through all five.
    Edit shows what Undo and Redo will do ("Undo Move Device"), and session_status reports it as
    undo_label. The project format is unchanged. Not yet: the "+" handles between devices, the
    Create submenu, unfolding after hovering a cable drag, and replacing from the track header or a
    library item.

  • Restructuring the arrangement. Edit > Insert Bars at Locators opens the length of the loop
    range at the left locator and Remove Bars at Locators cuts the range out and closes the gap, each
    in one undo step: a clip that straddles the point is split, and the clips, take groups, markers,
    ranges, tempo and meter changes, the loop and the song End all move together (the tempo that
    follows a removed range carries on from its start). They are refused while a track is frozen, and
    a take group that straddles an edge of the range is refused too. Edit > Reverse Clips mirrors the
    notes of the selected clips as bars, Reverse Note Starts mirrors only where they start (the first
    note stays on the downbeat), and automation, controller points and audio clips reverse with them;
    two reverses give the clips back. Edit > Scale Tempo (also in the clip menu) plays the selected
    clips at 200, 50, 150, 125 or 75 percent of their tempo: clip starts scale from the earliest one,
    and lengths, loops, notes and automation scale with them. Audio clips are warped to follow, and
    one that plays backwards is refused. Edit > Chop Clips To cuts the selected clips into pieces of a
    bar, half a bar, a beat or 1/8 or 1/16 note from each clip's own start, playing the same.
    Pasting audio clips into a project that lacks their track makes an audio track for them in the
    same undo step. Not yet: the percent dialog and edge-drag scaling of Scale Tempo, a Workflow
    preference for the reverse mode, joining audio clips and draggable crossfade zones.

  • Light theme, application zoom and interface settings. Settings has a new Interface tab: the
    theme (dark, light, or whichever the operating system uses; a switch repaints every view at
    once and View > Theme does the same), the application zoom (75 to 200 percent for every window,
    also in View > Application Zoom, kept for the next start), the knob range (Normal, Precise or
    Very precise: how far a drag has to travel to sweep a knob or fader) and value tooltips (resting
    on any rack control shows its value). The defaults are how the app looked and felt before, and
    an older workflow.json loads with them. The theme and the zoom touch neither the project nor
    the sound.

  • Help and Window menus. Help > Keyboard Shortcuts (F1) opens the list of every command and
    its keys, Documentation and Report an Issue open the project's public pages, and About shows the
    version, the GPL-3.0-or-later notice and where the third-party licences come from. The Window
    menu brings the main window and a detached Rack or Mixer forward. A double-click on the divider
    between the rack and the song collapses the rack; the next one puts the split back.

  • Project sample rate and channel counts. File > New at Sample Rate starts a project at 44.1,
    48 or 96 kHz, and File > Convert Sample Rate moves the open project to another rate in one undo
    step: the audio it uses is resampled into the project folder (the originals stay, so undo brings
    them back), clips keep their place in the song, and fades, gain envelopes, warp markers and
    sampler zones follow the new frame counts. Audio > Input Channels and Output Channels set the
    interface channel counts (the settings note now points at the real menu). A change of rate or
    channel count puts the playhead back where it was and keeps playing, instead of going to the
    start. The 88.2 and 192 kHz rates are not offered yet.

  • Performance measurement. Every speed claim can now be re-measured with one command per
    crate: cargo bench -p atomik-render --bench render_batch (bounces of a generated rack, song,
    64-strip console, 200 and 2,000 automation lanes and a 100-track song), -p atomik-devices --bench process (every built-in device), -p atomik-dsp --bench blocks and -p atomik-model --bench document (save, load, validate, expand and an edit with its undo). Each case prints the
    median and the 99th percentile of 21 samples. The generated documents of the stress options moved
    to atomik_model::stress, with new ones for a song of any size and a console of gated,
    compressed strips. The live callback keeps an allocation-free histogram of its own time and of
    the level-barrier wait, and the end of an atomik-play --stats run prints its percentiles
    (cb_p50_us, cb_p99_us, cb_p999_us, cb_max_us, spins_p99). Opening a project logs where
    the time went (parse, build, devices, compile, submit, sync). A scheduled workflow, never run for
    a pull request, keeps the bench output, fails when the instructions of a bench grow by more than
    10 % over the committed baseline, and runs the release real-time-factor check. See
    docs/TESTING.md.

  • Combine and Uncombine: wrap devices in a container and unwrap them again. The new commands
    Combine and Uncombine (Edit menu and device context menu, Ctrl+Shift+G and
    Ctrl+Shift+U; rack.combine and rack.uncombine) put the selected devices into a new
    container, or dissolve a container, in one undo step. The cables between the devices stay
    inside, the cables to the rest of the rack go through the container's two audio inputs, two
    audio outputs and notes input (a notes cable becomes a full-range split), and the project sounds
    exactly as it did, bit for bit, for devices that use no random numbers. A device with a song
    track, a console channel or an FX return passes them to the container (only one such device per
    container; its automation lanes are dropped and a message says so). When the container has no
    socket for a cable (CV, a third audio input or output, a notes output, a second notes source),
    the command is refused and names each cable; the context menu dims the item and the key or the
    Edit menu shows the refusal. A device moves into a container by dropping it on the container's
    panel, and out of an open container by dropping it on Project in the breadcrumb or with
    Move Out of Container in the context menu. Every container gains a BYPASS switch in its
    name strip, like the effects: while it is on the inside is left out and the input goes straight
    to the output. Bypass cuts at once, with no crossfade. The project format is unchanged (bypass
    is an ordinary saved param). session_status and project_inspect list what is inside a
    container and whether it is bypassed.

  • Align Returns: latent effects on sends, sidechain keys and split paths line up. A new project
    setting, Mixer > Align Returns (undoable, saved in the project), delays every audio cable of
    a device so it lands with the slowest one. A send through an effect that reports latency now
    returns together with the dry channels (no comb filtering), a sidechain key from a latent source
    arrives with the signal it controls, and two paths of different latency that meet in one device
    are put back in step. The click waits for the latency of the audio, so it is heard where the
    music is. New projects have it on; projects saved before keep it off and bounce exactly as they
    did. When it is off, the status line says how many cables are out of step. A channel's
    latency adjust now reaches 480,000 samples (10 s at 48 kHz). Project format 37 gains the
    optional console field align_returns.

  • Transport bar: tap tempo, Rewind and Forward, locators, click level and Q Rec. The bar has
    a second cluster right of the readouts. Rewind and Forward move by bars and repeat while
    held, faster the longer they are held. TAP sets the tempo at the playhead from the average of
    your last 2 to 16 taps (a pause of 2 seconds starts over; one undo step per sequence; also the
    command Tap Tempo). POS, TIME and the new L and R locator readouts can be typed
    into with a double-click (5.1.0, 00:12.500; a locator is one undo step), and a go-to button
    sits by each locator. A click level slider sets the metronome volume and is remembered.
    Q Rec snaps recorded notes to any grid of the quantize panel (1/4 to 1/32 and triplets; old
    off, 1/8 and 1/16 settings still load), and QUANT applies the quantize panel's last
    settings to the selection. When the bar is too narrow for all of it (the recording-input strip
    and the clip inspector keep their room) the controls that do not fit move into a ... menu.
    The new Workflow preference Return to start on stop makes Stop go back to where playback
    started and a second Stop go to the start. The tempo nudge keys now edit the tempo in effect at
    the playhead, like the tempo readout. While recording, a translucent red clip grows with the
    playhead on each armed track, showing the notes played so far, and Delete throws away what
    was captured so far while recording goes on. The project format is unchanged.

  • MIDI Out device: play hardware synths from the sequencer. A new utility device, MIDI Out
    (atomik.midi-out), sends the notes of a track (or of a note player) and eight CV inputs, mapped to
    controllers with a number, scale and offset, to a MIDI output port. It has a channel, transpose,
    program and bank, and a latency offset in milliseconds (negative sends earlier) that lines a
    synth's audio up with the song. Right-click it and Choose MIDI Out Port, or leave the default, the
    new MIDI Out device port in Audio Settings > Surfaces. Messages are sent when their frame is heard,
    by a dedicated thread that polls every millisecond and spins for the last 0.3 ms; stop, locate and
    a loop wrap release every note the device started, and deleting the device, changing its port or
    closing the session releases them too, so no note hangs. A bounce never sends MIDI, and bounces
    with or without the device are identical. Project format 37: a MIDI Out device may carry
    "midi_out": { "port": name }, written only once a port is chosen; files without it differ from
    their version 36 file in the version line alone. The output scheduler and thread are shared with
    the MIDI clock output (below).

  • MIDI clock out and in, Song Position Pointer and an Options > Sync menu. Atomik now sends
    MIDI clock to drum machines and synths and can follow one. Clock out (Options > Sync > MIDI
    Clock Out, ports in Settings > Sync) sends 24 clocks per quarter note, exact across tempo ramps,
    with Start, Stop and Continue as the transport changes and a Song Position Pointer for a locate
    or a loop wrap; an offset in milliseconds shifts what leaves a port (one value for every port in
    the dialog, one per port in settings.json), the clock can keep running while
    the transport is stopped, and a locate while playing can send Stop, the position and Continue or
    the position alone. It runs on the MIDI output thread, so it works with no MIDI Out device.
    Clock in (Options > Sync > Follow MIDI Clock) takes the tempo (the mean of the last beat's
    clocks), Start, Stop, Continue and Song Position Pointer from a chosen input port: the song
    plays at the clock's tempo, the transport buttons say they are following, and a clock that
    stops coming stops the transport and releases every note. The status line shows the clock out
    and the measured tempo. Settings are in settings.json under "sync". Bounces never follow a
    clock and are unchanged. Not yet: the phase of the incoming clock is not tracked, so a sender
    whose tempo wanders can drift from the song, and audio clips are silent while following.

  • Several MIDI inputs at once, master keyboard modes and Manual Rec. Audio Settings > MIDI
    inputs lists every port with a switch: all the switched-on ports are open together (a keyboard and
    a pad controller), and a port can be set to feed mappings only so its notes play nothing. The
    list refreshes every second while the dialog is open, and Audio > Rescan MIDI Ports opens a
    switched-on controller that was plugged in later. settings.json gets midi_inputs; a file with
    the old single midi_input loads as that input, enabled. Notes from the ports are kept in order
    and never stamped more than two buffers ahead, so one port cannot hold back another. Workflow >
    Master keyboard is Standard (the keyboard follows the selected track) or Separated (it plays
    the track picked with the arrow on its arrangement header). The arrangement corner has MAN REC
    (selecting a track, or creating one, no longer arms it) and M and S buttons that clear every mute
    or solo in one undo step; they are also the commands Clear All Mutes, Clear All Solos and Manual
    Record Arming. session_midi_input takes the port a message comes from. No project format change.

  • An unplugged or stalled audio device is noticed, and a device that fails never becomes the
    setting.
    When no audio callback arrives for a quarter of a second (or four buffers, if longer)
    the status bar shows AUDIO STOPPED, and a driver that reports the device gone shows
    AUDIO DEVICE LOST; a toast says so once and points at Audio > Restart Audio. Audio Settings has a
    new choice, If the audio device is lost: offer the restart (default) or switch to the default
    devices by itself, keeping the chosen device in settings.json for when it is back. Stream
    errors are counted in the status bar. When the input and the output are different devices the
    dialog warns that their clocks drift apart, and shows the buffer and the input and output
    latency; the input overruns counter now counts the captured frames that were lost to that
    drift, and control stalled counts control messages that found a full queue. Audio settings
    that fail to open, at start-up or in Apply, fall back to the last configuration that opened (with
    a message) and are never saved. settings.json gets a device_loss object; no project format
    change.

  • Plugin processes that never outlive the app, and hung ones are replaced. A sandboxed plugin's
    process now ends with the app however the app ends (a job object on Windows, a watchdog thread
    in every child that also covers a child stuck inside a plugin call and a closed control
    channel). A plugin that answers no audio batch for three seconds while playing is stopped and
    reloaded from its last state by itself, twice in a row, then left CRASHED for you to decide;
    bounces are not affected. A plugin that is too busy to answer the interface (the parameter text
    of the PARAMS pane, pins, editor close) is no longer stopped: the last text stays up, a warning
    says it is slow, and only a plugin that stays silent for twelve requests in a row is stopped.

  • Fuzzing of the readers of untrusted files. fuzz/ holds cargo-fuzz targets for project
    files, patches, clip files, library items and the library database, Standard MIDI Files, audio
    files (the whole-file decoder, the WAV readers and the preview decoder) and the control channel
    of the plugin sandbox, with seed corpora made from the committed fixtures
    (scripts/fuzz-seed.sh). A scheduled workflow runs each target for five minutes every week and
    uploads a failing input; it never runs on a pull request, and the fuzz crate is outside the
    workspace, so the normal build and test do not need a nightly toolchain. New tests that run on
    every push cover the same ground on stable: truncated, corrupted and oversized audio, MIDI and
    project files (1 000 cases for MIDI) and an allocation bound for a lying WAV header.

  • Device patches. Every device panel (except the console devices) has a patch strip on the foot
    of its name plate: previous and next arrows, the patch name (click it to browse
    patches, below) and a save button. A patch of one device (.atomikpatch) now applies to a
    device that is already in the rack: drop it on the strip (the device takes the params, samples,
    patterns, curves, drum patterns, plugin state or container inside as one undo step, and keeps its
    name, place, cables and track; a patch for another type or of several devices changes nothing and
    says so), or step through the patches of the device's type with the arrows (natural name order,
    wrapping, each step one undo step). Save asks for a name with the system's save dialog (it
    confirms an overwrite), writes the device as a one-device patch with its samples, and shows the
    name on the strip. The device context menu has Copy Settings, Paste Settings (onto a
    device of the same type), Reset Device (the sound of a new device) and Save Patch; they
    are the edit.copy_settings, edit.paste_settings, rack.reset_device and rack.save_patch
    commands (no keys). A device that took a patch bounces bit for bit like one created from it.
    Project format 36: a device may carry "patch" after its "name" (the name of the patch it
    last took its sound from, display only), written only when set; a project without any differs from
    its version 35 file in the version line alone. See
    docs/DECISIONS.md.

  • Patch browsing. Browse on a device's patch strip (click the patch name, the device context
    menu or Ctrl+Shift+B, rack.browse_patch) aims the file browser at that device: an orange
    band names it, the list shows only folders and the patches for its type, and the patch name on the
    plate turns orange. Selecting a patch (a click, or the arrow keys in the list), Next Patch and
    Previous Patch (Ctrl+Right, Ctrl+Left in the rack, also in the context menu) and the
    patches picked from the pop-up that a right-click on the patch name opens (the patches of its
    folder, natural order) are heard at once but make no undo entry, and the device's engine node
    is not rebuilt, so held notes go on sounding with the new patch. Return (or a double-click on
    a patch, or pressing another device's Browse, or any other edit) accepts: the whole browse is
    one undo step. Escape puts the device back exactly as it was. The folder last browsed for
    each device type is remembered in ui-state.json (patch_folders), and the patches of a folder
    are read once, not at every step. The commands are rack.browse_patch, rack.patch_next,
    rack.patch_prev and rack.patch_pick; docs/MCP.md has a recipe to check it with session_key
    and session_pointer. See docs/DECISIONS.md.

  • Audio clip editor. Double-clicking an audio clip, Enter on a selected one or F8 opens
    the clip in an editor that replaces the arrangement (Esc closes it; Up and Down open the previous
    or next audio clip and keep the mode; double-click the title to rename the audio file, one undo
    step). Overview shows the clip with its warp markers. Slice edits them: double-click or
    I adds a marker pinned where the audio already plays (no sound change), dragging a marker
    stretches the audio around it, the alternate-tool modifier (or the Slide toggle) slides it
    along the audio, the constrain modifier (Shift) carries the markers after it along, the nudge
    keys move the selected marker, Delete removes it, Revert removes every marker, Split
    cuts the clip at each marker (one undo step) and To slicer makes a Loop Slicer that slices the
    clip at its markers (one undo step). Entering Slice mode on a clip without warp switches warp on
    at the song tempo. Keys: 1 Overview, 2 Slice (the mode is remembered).

  • Transient markers and the speaker tool. In the audio clip editor's Slice mode the transients
    of the clip (found on a worker thread, kept in memory per file and sensitivity) are drawn under
    the ruler; the SENS buttons change how many are found, a double-click or I near one puts
    the marker exactly on it (no sound change), and Add all puts a marker on every transient in
    one undo step. The Speaker tool (T, the SPK button next to Razor in the arrangement, and
    the SPEAKER toggle in the audio clip editor) plays the audio under the pointer exactly as it is in
    its file, unprocessed (no warp, fades or envelope; a reversed clip plays backwards) for as long as
    the button is held, at the clip gain. It uses the preview voice, so it is heard live and never
    reaches a bounce or export. No project format change.

  • Warp on import. Settings, Workflow, Warp on import (Off, Loops only by default, All
    files; "warp_imports" in workflow.json): an imported audio file that carries a tempo, or whose
    length is a whole number of bars (1, 2, 4 or 8) at a round tempo between 70 and 180 BPM, becomes a
    warped clip at its own tempo, as long as the bars it holds, so a loop follows the song tempo from
    the start; a one-shot, a file flagged as a one-shot and a long recording are left as they are. All
    files warps every file (one nothing is known about plays unstretched at the song tempo). Off
    imports exactly as before. The warp joins the undo step that adds the clip. The tempo is read from
    the acid chunk of a WAV file (tempo, beats, one-shot flag), with the smpl chunk and a tempo
    written in the bext description as further hints, by a bounded chunk scanner that never reads
    more than a few hundred bytes of a chunk and does not fail on a damaged file. See
    docs/DECISIONS.md.

  • Warp panel: Scale and Reset. Scale (25 to 400 percent) changes the playback speed of the
    warped clip: APPLY divides the source tempo by it and the panel reads 100 again. RESET (Reset
    to Unstretched Tempo) turns warp off and clears the markers of the selected clips, and resizes a
    warped clip so it plays the same stretch of audio at its own speed; one undo step.

  • The Atomik Rack logo is the application icon. The main window and the detached Rack and Mixer
    windows show it in the title bar, the taskbar and Alt-Tab (Windows and X11; macOS shows the Dock
    icon of the bundle), atomik.exe carries it so Explorer, the Start menu and a pinned taskbar
    button show it, the Windows installer and uninstaller use it, Atomik Rack.app has an .icns
    icon, and the .deb installs it in the hicolor theme and names it in the desktop entry. The
    README shows the logo. The master and the derived .png, .ico and .icns files are in
    assets/icon/; the make_icons example
    (cargo run --release -p atomik-app --example make_icons) regenerates them. A Windows-only build
    dependency, embed-resource, embeds the icon in the executable. See
    docs/RELEASING.md.

  • Save, Don't Save or Cancel. Closing, quitting, opening or creating a song with unsaved changes
    now asks Yes (save, then carry on), No (discard) or Cancel, instead of "Discard them?"
    with no way to save from the question. A song with no file yet asks where to save it first; a
    cancelled Save As or a save that fails stops the action and the song stays open.

  • File > Close (Ctrl+W) and File > Open Recent. Close ends the song and starts an empty one,
    after the same question. Open Recent lists the last eight songs you opened or saved, newest
    first, without duplicates; a song that is gone leaves the list with a message; Clear Menu
    empties it. The list is kept in recent.json next to settings.json. The commands are
    file.close, file.open_recent (the place in the list as the argument) and file.clear_recent.

  • Layer recording. Settings, Workflow, Recording over clips: Replace (takes) is what
    recording always did (a new clip, or the passes of a loop stacked as takes); Layer merges the
    take into the note clip under its start (the old notes stay, a new note replaces one with the same
    start and key, a controller you moved replaces the old values over the take), grows the clip when
    the take runs past its end, and puts every pass of a loop recording into one clip. A Layer take
    that starts before an existing clip plays over it instead of being hidden by it (an older clip
    that starts inside the take is trimmed to start where the take ends, or removed when it ends
    inside it). One undo step takes the whole take away.

  • Audio recorded over a clip becomes a take. Recording audio where a clip already is no longer
    stacks two plain clips (the later-starting one hid the other): the old clip and the new recording
    become the takes of one take group, the new take playing over the overlap and the old one
    everywhere else, in one undo step; a further recording over the group adds another take row.

  • Keep events in clip. Settings, Workflow, Notes outside a clip: a note drawn, moved or
    pasted past the end of its clip is silent; Keep leaves it (as before), Expand clip
    lengthens the clip to the next bar line, New clip moves the notes to a new clip on the bar. It
    is part of the same undo step as the edit (a drag is completed when you let go).

  • Note tails. A new project lets a note ring to its own end past the end of its clip, the loop
    end or the start of the next clip (the keys are released at the loop wrap and at stop). Project
    format 35
    : the song may carry "tails": true; a project saved before it has no flag and cuts
    every note at the end of its clip, loop pass or covering clip exactly as before, so it plays and
    bounces bit for bit as it did.

  • Open last project at start-up. A Workflow switch (off by default): the app starts with the
    song that was open last time, unless a project is named on the command line.

  • Autosave for every project. A changed project is copied to the recovery folder every few
    minutes (Settings, Workflow, Autosave: off, 1, 2, 5 by default, 10, 15 or 30 minutes), with or
    without plugins, by a background thread, so a frame never waits for it. After Atomik ends
    unexpectedly the next start shows a banner with OPEN RECOVERY. Unfinished audio recordings left by
    the crashed run come back as a Recovered take track in the project; the recording file is
    deleted only after you save.

  • A pre-count for recording. Settings, Audio, Pre-count (bars) (Off, 1, 2, 3 or 4 bars;
    Options > Pre-count, Ctrl+P in the standard key set, switches it on or off and remembers the
    length): when a recording starts from a stopped transport the click counts that many bars of the
    meter at the playhead, at the tempo there, before anything plays. The first beat of each bar is
    accented, the click sounds even with the metronome off, the transport bar shows COUNT and the
    beat of the bar (and PRE n while it is on), and nothing played during the count is recorded:
    the take and its clip begin at the position the count started from, bar 1 when you start there. A
    loop is counted in once, not at every lap; Stop cancels the count. With the pre-count off (the
    default) recording behaves exactly as before. Saved in settings.json as pre_count_bars.

  • An Options menu. The playback and recording settings in one place: Click, Pre-count,
    Input Quantize, Chase Notes (the selected track's note chase), Delay Compensation and
    Settings.... Every entry is the command it already was, so the Transport, Mixer and Audio
    menus keep theirs.

  • An Inspector for every kind of clip. View > Inspector (off by default, remembered) shows a
    strip under the arrangement's lanes with the selected clips' Position, Length, loop
    Offset and Loop length as segmented bar.beat.16th.tick fields that follow the song's
    meter. Press a part and drag, scroll over it (Shift: the next finer unit), or double-click to
    type: digits replace the part, +240 and -240 add or subtract ticks, 3.2.1.0 sets the whole
    field, Up and Down step while typing. With several clips selected a field shows a dash where they
    differ and an edit is relative: every clip moves by the change of the first clip's value, each
    clamped to its own range. Match gives every selected clip the first clip's length, offset and
    loop. One typed value, wheel notch or Match is one undo step; a drag is one. Audio clips have no
    offset or loop and keep those fields dimmed. The same switch shows a note strip under the
    piano roll: Note (the pitch as a name like C#3: drag, scroll, or type a name, a number or
    +n/-n semitones), Position, Length and Velocity (1 to 127) of the selected notes,
    relative on several notes and clamped note by note. While automation points are selected the
    arrangement strip shows their Position and Value (in the parameter's unit) instead,
    relative and clamped to the lane's range; a move that would put two points on one tick is not
    sent.

  • Piano Keys. View > Piano Keys (F4) shows a strip above the status bar with two octaves
    and a note, and plays with the mouse or the computer keyboard. A press plays the key with a
    velocity that follows the height of the click and a drag glides across the keys; Hold latches
    keys, Sustain keeps released keys sounding, VAR adds a small random change to each typed
    velocity, and the octave runs over ten octaves (C-1 to C8). In KEYS mode (the default) the
    strip, while it has the focus, turns the keyboard into notes:
    A W S E D F T G Y H U J K O L P ; ' are the keys from the strip's lowest C, Z and X move the
    octave, 1 to 0 set the velocity (1, 14, 28, 42, 56, 70, 84, 98, 112, 127; 98 on start) and
    Shift is the sustain pedal. The characters are the keys.note, keys.octave_up,
    keys.octave_down and keys.velocity commands of a new keys context, so Settings, Keyboard
    changes them; everything else keeps its command, and MOUSE mode leaves every letter a command.
    The notes reach the armed track (or the selected device) on the same live path as a MIDI keyboard,
    so a take records them, and no note stays on when the strip loses the focus, changes mode or is
    closed. Live input only: bounces and the project format are unchanged.

  • Stereo patching and a jack menu. Dragging a cable from a left jack (out_l, in_l) to a left
    jack of an audio socket now cables the right pair too when it exists and is free, in one undo step
    (the same for right to right; Alt at the release makes it one cable; mono jacks, CV and notes
    sockets and mismatched sides still make one). A right click on a jack on the back of the rack
    opens a menu: Connect to lists, per device in rack order, the jacks the cable rules allow (an
    input that is taken is starred and choosing it replaces its cable, one undo step), Disconnect,
    Scroll to Connected Device (across columns too) and, on an audio output, New Mixer
    Channel
    ; entries that cannot be chosen are greyed. Hovering a jack names the jack at the other
    end of its cable ("In L from Poly Synth > Out L"). The menu's entries run the new rack.jack
    command (Patch Jack, no key).

  • Performance controllers in the melodic instruments. The poly synth, wavetable synth, FM synth,
    grain sampler and sampler now follow the sustain pedal (CC 64: a released note keeps sounding
    until the pedal goes up, then releases at that moment), volume and expression (CC 7 and CC
    11, squared and smoothed so they never click), channel and key pressure (kept as a modulation
    source for the matrix to come) and the pitch-bend range: a new bend.range param (0 to 24
    semitones, default 2) that the registered parameter 0 (CC 101, 100, 6, 38) also sets. The sampler
    now plays pitch bend as well. Everything else sounds exactly as before. docs/DEVICES.md gains a
    MIDI chart of what each instrument does with each message, and a test checks it by rendering.

  • A log file, crash reports and Help > Export Diagnostics. Every session writes atomik.log in
    the logs folder of the config folder (rotated at 2 MiB, three files kept), with what the app and
    its libraries have to say; the messages that used to go to a terminal nobody sees are in it. A
    panic writes crash-<time>.txt next to it (message, thread, backtrace, version, OS and the audio
    and MIDI devices). The new Help menu has Export Diagnostics...: one text file with the
    settings, the plugin cache and journal, every counter, the last crash report and the end of the
    log, with your home folder written as ~. ATOMIK_LOG=debug raises the log level. See
    docs/ARCHITECTURE.md.

  • The status bar shows dropped work. When they are not zero it adds dropped events (note
    events that found a full buffer), record overflow (frames the audio recorder lost), plugin
    drops
    and late sandbox batches, and session_status reports them under overload. The same
    counters are written to the log when they grow.

  • Delete, mute and hold an automation lane. An automation lane header now has an M (mute)
    and an X (delete) button, and the track header menu has Delete Automation Lane, Mute
    Automation Lane
    (checked while muted), Set Static Value and Clear Static Value for the
    lane whose header you pressed last. Deleting removes the lane with its clips, write mode and fold
    in one undo step, and a track that held automation lanes alone goes with its last lane. A muted
    lane drives nothing, and the parameter keeps the value the lane gave at the playhead (the mute and
    that value are one undo step). A control's right-click menu has Clear Automation (the lane of
    that control) and Set Static Automation Value.

  • A static value for a lane. A lane with a static value gives it before its first clip, between
    its clips and after the last one, and for the whole song when it has no clip, so a one-bar clip no
    longer fixes the parameter for the rest of the song. Project format 36: an automation lane may
    carry "muted": true and "static": value after its "folded", written only when set; a project
    without them differs from its version 35 file in the version line alone and bounces bit for bit as
    before.

  • A lane picker with check marks, on automation tracks too. The + AUTO menu lists every
    parameter of the track's device, checks the ones that have a lane and removes the lane of a
    checked one when you click it; an automation track has the picker (a small +) next to its
    first lane's controls.

  • Auto-create lanes. A switch next to Record in the transport bar (Transport > Auto-create
    Lanes
    , transport.auto_create_lanes, session state) makes a take also record the parameters
    that have no lane yet: move a knob while it runs and its lane is added when the take ends, with
    the recorded clip, in the same undo step. A parameter that already has a lane records only when
    that lane is armed; a parameter a macro drives, an internal one and an audio track's get no lane
    (the macro one says why).

  • Override. Moving a control by hand while the song plays and no take runs used to be undone by
    the lane at the next audio batch. The lane now holds the value you set until you press the
    OVERRIDE lamp that appears in the transport bar (transport.clear_override), stop or locate;
    at most 32 lanes can be held at once, and the document and a bounce are untouched.

  • Alt-click a control to edit its automation. A click on a knob, fader or switch with the Edit
    automation
    role held (Alt, Option on macOS, remappable under Settings, Keyboard) shows its
    automation lane, adding it when it is missing, like the control menu's Edit Automation.

  • Trim the start of any clip, and resize several clips at once. Dragging the left edge of a note
    or automation clip moves its start and keeps its end (the content stays where it was in song time;
    growing a clip left past its first note shifts the notes, controller points or automation points
    right, a looped clip wraps its loop instead). With several clips selected the edge moves every one
    of them, and so does the right edge. A drag is one undo step. Delete Events Outside Clips
    (sequencer.delete_outside_events) removes the notes that start outside their clip's window and
    the automation and controller points outside it, keeping one point on each side so the curve at
    the edges is unchanged.

  • Split and cut several clips in one undo step. Split at Playhead, the razor and a razor
    click in the ruler now split every clip they cross as a single step (a split over twelve clips was
    twelve undo steps). Dragging the razor along a lane cuts the range out of the clips there; with
    the copy modifier held the clips stay and a copy of the range is placed right after it.

  • Nudge clips. Ctrl+Left and Ctrl+Right (Cmd on macOS) move the selected clips by one snap
    step, Ctrl+Shift by a beat and Ctrl+Alt by a tick, as one undo step; the group stops at
    tick 0.

  • Relative snap and more snap values. sequencer.set_snap_mode (absolute or relative)
    chooses whether a moved clip or note lands on a grid line or moves by whole steps and keeps its
    distance from the grid (the arrangement corner reads SNAP REL while it is relative). The snap
    selector gains 1/2, 1/128 and 1/2T (half, onetwentyeighth, half_triplet for
    sequencer.set_snap).

  • Constrain and copy-drag work on notes and clips. Holding Shift (the Constrain role, now
    listed in Settings, Keyboard) while dragging keeps a clip's start, so it only changes lanes, and
    moves a note along one axis; the modifier is read on every move, so it can be pressed after the
    mouse-down. Ctrl (the Copy role) drags a copy of the selected notes in the piano roll, as it
    does for clips, in one undo step.

  • More daily keys in the standard key set. X toggles the crossfade of the selected audio clips
    (equal power, or off when it is on), Alt+M fits the selected tracks to the window, Ctrl+E
    toggles the clip editor in the sequencer, Shift+Z zooms to the selection like Z, Ctrl+Alt+=
    and Ctrl+Alt+- zoom the time axis like Ctrl+= and Ctrl+-, and F toggles Follow in every
    context. Escape in the arrangement closes the open clip or editor (when no menu or drag is open;
    otherwise it clears the selection as before). Alt+Shift+Left and Alt+Shift+Right move the loop
    by one bar, Alt+Shift+Up and Alt+Shift+Down change its length by a bar (transport.loop_move,
    one undo step each, never before bar 1 and never under one bar). ! is All Notes Off
    (transport.all_notes_off): it releases every note on every device and on the Piano Keys. The
    legacy key set is unchanged.

  • Shift+click in the arrangement ruler sets the End marker at the snapped position.

  • A newer project can open in an older build when it only adds optional fields. A project file
    whose root says "compat" (the oldest version that can read it) and lists its "ignorable"
    fields opens with those fields skipped and a warning each; any other unknown field is still
    refused. The writer adds the two fields only when every change since compat is skippable, so
    files of format 36 are unchanged byte for byte.

  • "N items ignored while opening". Opening a project reports what the file had that the
    document does not, in a toast and the log: the height of a device that has no track, a comp clip
    that is not on its lane, an instrument of a version 1 file that could not get a mixer channel and
    the skipped fields of a newer file.

Fixed

  • A bypassed container can no longer close a loop. Bypassing a container whose output is cabled back to its own
    input, with something else fed from that output, made a saved file the loader refused ("would create a cycle").
    The bypass is now refused when it would do that, so a project that was saved always loads.
  • Device robustness. A NaN or infinite sample on an audio input of the channel strip, the master,
    the line mixer, the audio track or the stereo delay now reads as silence, so one bad source can no
    longer silence the mix (finite audio is unchanged bit for bit). Two sample map swaps of one device
    are spaced by 5 ms, so a quick third map no longer cuts the voices that are fading out. The built-in
    grain source is kept for the standard sample rates only. A device that cannot be wrapped in a bypass
    is an error instead of a panic, and Character reports a rejected voicing. Every registered device
    passes the parameter min/max sweep, and the instruments, reverb, mastering and Character have
    bounded-output property tests. DEVICES.md lists the overflow and restart policies.
  • A fade or a gain envelope point can no longer run past its audio clip. Adding or changing an
    audio clip, or stripping silence, refuses a fade or an envelope point longer than the clip. A
    project saved by an earlier version that has one loads with it clamped to the clip and a warning
    naming the clip; the sound is the same, since the player already clamped it.
  • Combine says what it cannot do, and no longer stops at a mixer strip. Choosing Combine on a
    selection that includes a mixer strip (a channel, a bus or the master) or an audio track used to
    be refused as a whole. Those devices can never go inside a container, so they now stay in the
    rack with a note and the rest of the selection is combined; a selection made only of such
    devices is still refused, naming the first. A container has one song track, one mixer channel
    and one FX return, so two or more selected devices that each have one are refused with a
    message naming them ("Combine keeps one track and one mixer channel: ... each have ...;
    combine them separately"). The Edit menu now enables Combine only when the model would take the
    selection, as the context menu does, so a refused multi-selection is dimmed and a shortcut
    shows the reason in the status line. The project format is unchanged.
  • Insert and Remove Bars at Locators moved some things wrongly. A tempo or meter change that
    starts exactly on the left locator stayed behind while the music after it moved, so the opened
    bars took the new tempo or the new bar length and the following bars no longer sat on bar
    lines; now it moves with the music (the song's first tempo and meter stay). A loop that starts
    on the locator but is not the locator range moves too. Remove Bars shortens a note that would
    ring on into the removed bars (with note tails on) so it ends where the cut starts. An
    automation curve stays continuous across an insert and joins with the value from the end of the
    range on a remove, and automation-only tracks and device lanes move like the rest (tests now
    cover all of it).
  • The Stereo Tool's MONO switch is the last stage. It used to come before the Mid/side mode,
    so with Mid/side set to encode the output was the mid on the left and silence on the right.
    Now the two outputs are the same (L + R) / 2 of whatever the mode produced, in every mode
    (once the 10 ms ramp has settled they are bit-identical); a render test checks left equals right
    with MONO on, and a panel test that MONO is a front toggle on the mono param.
  • The drum generator's Generate always wrote the same pattern and Randomise did nothing. The
    seed only jittered velocities, and only when the density was not zero, so at the default
    density the steps never changed. Now every press of GENERATE picks a new seed (written to the
    Random seed param in the same undo step as the pattern), and the seed varies the rhythm at any
    density inside the chosen style: ghost notes, extra kicks on weak sixteenths, hat, open hat and
    percussion variations, dropped weak hits, accents and sometimes a short fill at the end of the
    pattern. The kick on the one, the strong kicks and the backbeats stay, and the same seed with
    the same params still writes the same pattern. RANDOMISE now draws the style, density,
    variation, accent and the pattern's swing as well as the seed, then writes the pattern, all in
    one undo step. Saved projects store the written patterns and load as they were saved.
  • A patch dropped on a device loads into it instead of adding a new device. The drop used to
    load only on the small patch strip of the name plate; anywhere else on the panel it inserted a
    new device. Now a patch for the device's own type loads into the device wherever on its panel
    it lands (the panel is outlined while the file hovers, instead of the insertion line), from the
    file browser or the desktop. A patch for another type is inserted right below the device under
    the pointer, as before.
  • Clicking a drum machine pad plays the pad when the notes are cabled in. A pad, sample key or
    slice pad click sent its note to the top of the track's player stack, so a drum generator in
    front of the drum machine swallowed it and nothing sounded. The click now goes to the device
    that owns the pad.
  • Nudge and track move keys no longer use Ctrl+Alt. Graphics drivers can take Ctrl+Alt with the
    arrow keys on Windows (they rotate the screen), so the app may never see them. The
    tick nudge of clips and notes is now Ctrl+Shift+Alt+Left and Right (Cmd+Shift+Opt on macOS), and
    Move Track Up and Down are Ctrl+Shift+Alt+Up and Down. Ctrl+Left and Right (the snap step) and
    Ctrl+Shift+Left and Right (one beat) are unchanged and now have tests that drive the real key
    path.
  • A track moved up or down never vanishes into a collapsed folder. The move keys used to put
    the track inside a collapsed folder, where it was hidden; it now hops over the whole folder. A
    track at the edge of an open folder leaves it in one press, above the folder or below its last
    track, and a track above an open folder moves into it.
  • Join Notes joins across a gap. Ctrl+J in the note editor (and the Join Notes menu item) merges the
    selected notes of one key into one note from the first start to the last end, where it used to
    do nothing unless the notes touched. Make Legato, which stretches each note to the next one,
    has a key of its own, Ctrl+Shift+J.
  • The Select tool never creates a clip by dragging. A plain drag on an empty lane is the rubber
    band, across lanes and tracks, like the piano roll's (Shift or Ctrl adds to the selection, a
    plain band replaces it). A click on empty lane area clears the clip selection (an empty
    automation lane still takes the point). Clips come from the Pencil tool, from holding the
    alternate-tool key (Alt) over the Select tool, or from a double-click on the lane.
  • Delete on a lane deletes the lane. With an automation lane header picked, Edit > Delete (and the
    Delete key) removes that lane alone, as one undo step; an extra note lane goes the same way, and
    a track is only removed when its own header is picked.
  • A click on an empty automation lane draws. With the Select tool, a click without a drag on
    empty lane area adds a clip over the bar clicked with a point at the pointer, as one undo step;
    a click inside a clip still adds a point there.
  • The followed automation lane can be folded. The lane that follows the selected parameter is
    kept open, but its fold chevron now folds it; it stays folded until another parameter is followed
    or the lane is unfolded.
  • Joining clips no longer makes muted notes audible. The notes of a muted clip used to be
    folded into the audible clip a Join made. A join now leaves muted clips where they are (muted
    clips on their own still join into a muted clip), and a looped clip is unrolled instead of being
    refused, so the joined clip plays what the clips played.
  • Closing a project with many sandboxed plugins is quick. The plugin processes are asked to
    end together and waited for on one shared deadline, so slow ones cost about a second in total
    instead of up to three and a half seconds each.
  • A misbehaving plugin process cannot exhaust the app's memory. Replies and notifications from
    a plugin process are bounded before they are read (1 MiB of JSON, state blobs only on the
    state, 4 KiB log lines, editor sizes up to 16 384 pixels), a burst of parameter edits reaches
    the app as the last value per parameter, and the scanner's output is read to its end, so a
    file that makes the scanner print more than 16 MiB fails at once as "too large" instead of
    after the scan timeout.
  • The plugin audio block is private. Its file has a random name, is created exclusively with
    mode 0600 on Unix, and files left by an app that crashed are removed at the next start.
  • A hostile or corrupt file can no longer make the program run out of memory. A WAV header that
    claims billions of samples no longer sizes an allocation (a 44-byte file that said so used to be
    asked for gigabytes, and running out of memory aborts the program with unsaved work); an audio
    file holds at most 2^30 samples in memory (4 GiB, about 3 hours of 96 kHz stereo) and says "audio
    too long" past that; a project, patch, clip or library item file over 256 MiB is refused before
    it is read, with a message that names its size (set ATOMIK_MAX_PROJECT_MIB to open a larger
    one); and a Standard MIDI File keeps at most about two million events per track and eight million
    in all (a longer one is refused with a message).
  • NaN and infinite samples in an audio file become silence. An import stores them as zero and
    says so in the toast ("2 invalid samples (NaN or infinite) replaced with silence"); a bounce of a
    project whose bundle holds such a file is finite and lists the count in its warnings; the
    streaming reader does the same. A file without such samples reads bit for bit as before.
  • Audio files above 4 GiB stream. The seekable reader of long recordings and imports reads RIFF
    and RF64 files with 64-bit offsets (it used to stop at the 32-bit limit of its WAV library), and a
    data size that the file cannot hold is cut to the file instead of failing later.
  • A command that does not fit the document is refused, not fatal. Every edit now checks what it
    names before it changes anything, and a step that does not fit leaves the document and its undo
    history as they were with an error, where it used to abort the program with unsaved work. The app
    also catches a panic inside a command, an undo or a redo: it says "Internal error, document
    restored" and writes a recovery snapshot.
  • Pasting or duplicating a track past the song End moves the End out. Only a single clip did; a
    pasted or duplicated track left the End short and a bounce stopped early. A MIDI import follows
    the same rule instead of carrying its own copy.
  • Quantize at the last tick keeps every note inside the song. Two notes pulled onto the same
    last tick used to push one past the end of the timeline, a note no edit would accept and no file
    could hold. The quantize now moves it to the nearest free tick before, and refuses a result a clip
    edit would refuse.
  • A project that holds a number that is not finite is refused before it is written. Save checks
    the document first and says what is wrong, rather than writing a file that cannot be read back.
  • No config folder no longer means no recovery. When the environment has no config folder (no
    APPDATA or HOME), the plugin cache, the plugin journal, recovery snapshots and logs now use a
    folder in the temp directory for the run, and a toast says settings are not saved.
  • A bug in one device no longer takes the app down. A device that panics while rendering is
    silenced and skipped, everything else keeps sounding, the status line shows
    ENGINE FAULTED: <device> and a toast points at Audio > Restart Audio. Stopping the audio no
    longer aborts the app when a slow driver does not answer within five seconds (it reports an
    error), and a computer that refuses to start the extra render threads falls back to fewer. A
    bounce or export that hits a rejected edit or a failing device now fails with a message (and a
    non-zero exit code for atomik-render) instead of aborting, and never writes silence into the
    file. The release profile now says panic = "unwind" explicitly, with a test that no profile
    turns it off.
  • settings.json and ui-state.json can no longer be left truncated. They are written to a
    temporary file and renamed. A file that cannot be read is kept as .bad and Atomik starts with
    the defaults and says so.
  • Play and Stop no longer wait on a parked retirement. Transport commands travel on a lane of
    their own that applies even while the engine holds its control queue for the UI to collect
    retired plans, the retirement queue is four times larger, and the status line counts the batches
    the control path stood still.
  • A note off is never the note that is dropped. The last slots of a device's note input and of
    the live MIDI queue are kept for note offs and All Off, so a dense controller lane or a pile of
    chords that overflows a batch cannot leave a note hanging. Nothing changes below the overflow line,
    so existing bounces are bit-identical.
  • A record tap whose stop was refused is stopped on the next frame instead of recording on
    behind the finished take.

Changed

  • Faster and steadier continuous integration. Coverage no longer runs on every pull request: it runs on pushes
    to main, nightly, by hand and on a pull request that carries the coverage label, and it now also checks a
    floor for each crate (scripts/coverage-floors.txt) and prints a table in the job summary. A change to documents
    only skips the build and test jobs. Only main saves the build caches. The test plugin libraries are built once
    by the workspace build instead of by a nested cargo build in each test binary (the nested build stays as the
    local fallback). The live deadline test is strict off CI, retries only on CI and reports its attempts. The export
    cancel test and the child shutdown tests no longer depend on how fast the machine is, and the locator test draws
    with the Pencil tool. A weekly job keeps the cargo build --timings report.
  • Stricter device descriptors and a safer model API. A device descriptor whose stages skip a
    number, start above 0 or use 255 is refused when the type is registered. A plugin whose layout is
    refused leaves nothing behind, Registry::get reports the descriptor of a plugin type instead of
    a placeholder constructor, and a tempo or meter map is always built non-empty. Document::undo
    and redo no longer take a registry, and Document::begin_gesture ends a drag's merge group by
    itself when it goes out of scope.
  • The rack navigator is a miniature of the real rack. The strip at the right edge of the rack
    no longer shows colour blocks: every device is drawn as a scaled-down picture of its own panel
    (plate, name, knobs, faders and displays as they stand, a folded panel folded), so you can tell
    the devices apart and find the one you want at a glance. Text too small to read becomes a bar
    and very small details are left out; when the rack is so tall that a panel would be only a few
    pixels high the strip falls back to a flat block of the device colour. Clicking and dragging
    move the view exactly as before, and the viewport rectangle and the selection outlines stay on
    top. The miniature is recorded once per panel change, not per frame, and the live meters and
    scopes do not make it redraw during playback (the strip keeps its 136 px width).
  • Spider Audio and Spider CV are now Audio Split/Merge and CV Split/Merge. Only the names
    shown in the browser, the panels and the documentation change; the device ids are the same, so
    saved projects and patches load as before.
  • The application icon sits on a black background. The window, taskbar, Explorer, installer,
    Dock and Linux icons are regenerated from the logo on opaque black so they read on any
    taskbar.
  • Saving no longer freezes the window. File > Save and the file picked for Save As write the
    project beside the window: the plugins' states are collected first (all at once, so a project with
    many plugins waits for the slowest one), then the project text is built, the audio is copied and
    the file is written on a worker while "Saving..." shows in the status line. You can keep editing;
    a change made meanwhile stays unsaved afterwards, and undoing back to the saved state is clean. A
    save that fails is reported and leaves the earlier file untouched. The saved file is
    byte for byte what it was.
  • Plugins load together and an idle project stays quiet. Opening a project starts the processes
    of up to eight sandboxed plugins at the same time instead of one after the other (they still
    attach in document order). With a plugin loaded and nothing playing, the app looks at its
    plugins ten times a second instead of sixty and sleeps in between. ui-state.json is written
    atomically and at most every two seconds instead of at every click, keymap.json is checked when a
    window gets the focus or a menu opens instead of four times a second, and the plugin scan uses as
    many scanner processes as half the cores (two to eight).
  • Idle effects cost less. The EQ's 16-band analyser runs only for panels on screen (its output
    is unchanged, the default-settings EQ costs about 5 times less), the compressor and the gate skip
    their log10/powf while at rest, delay lines wrap with a mask, and a bypassed effect stops two
    seconds after the bypass is fully engaged (see Effect bypass in DEVICES). The two-second rule can
    change the tail heard when an effect is switched back on.
  • A bigger drum machine panel that shows what is loaded. The pad grid now takes the width and
    height of the panel instead of a small corner of it, with the 14 pad knobs and the master level
    in two columns at the right and the readout and the EDIT, SAMPLE and TO CH buttons under the
    grid. A pad with a sample is lit in the accent colour and shows the sample's file name (without
    the extension) on up to two lines, with the pad number small in a corner; an empty pad is dark
    and says "empty". A file dragged over a pad lights that pad.
  • The cursor shows what a drag does. While files are dragged out of the file browser the cursor
    is the copy cursor over a place that takes them and the not-allowed cursor over every other
    place. A device moved in the rack, a clip, a track or a note lane moved in the sequencer show
    the closed hand (the copy cursor while the drop copies), and the not-allowed cursor while the
    pointer is over a pane that takes nothing. A device palette row dragged out shows the copy
    cursor over the rack. The plate of a device that can be dragged shows the open hand.
  • Importing audio holds about one copy of it, and big projects open about four times faster. An
    import used to copy the audio five times (every check copied the buffer, and a file already at
    the project rate was cloned by the resampler); it now peaks at about 1.03 times the decoded size
    at 44.1 and 48 kHz instead of 3.2 times, and a file's declared length sizes the buffers once.
    WAV files are written and read in 64 KiB blocks (a minute of stereo reads about five times
    faster), and a streamed asset reads ahead 4,096 frames, so playing it costs one read per block
    instead of one per chunk. Opening a project no longer builds a heap path for every note and
    point and judges a rack's thousands of cables as one set: a 200 000-note project opens in 78 ms
    instead of 291 ms, with 1.3 allocations per note instead of 6.3, and the 2 000-note bench
    project in 7.7 ms instead of 39 ms. The project writer streams each note and point into the
    output. File bytes, content hashes, asset ids and load error messages do not change. Comparing
    tags no longer allocates, and the planners of Strip Silence, split, comp rows and clip growth
    compile the tempo map once instead of once per cut.
  • The arrangement draws playback from cached layers. The lanes with their clips, notes and
    waveforms, and the track list, are recorded into display lists that stay between frames, so a
    frame in which only the playhead moved draws the playhead line, the ruler flag, the marker
    strip and the tempo lane over them instead of walking every clip again, and the GPU keeps the
    encoding of the same lists. A moving track meter re-records the track list alone. Any edit,
    scroll, zoom, selection, hover, tool, drag, theme, scale or size change records both layers
    again, and what is drawn is exactly what it was.
  • Live rendering leaves a core to the audio thread. The app and atomik-play start at most as
    many render workers as the machine has cores minus one, and the audio thread, when it waits for
    a worker, yields its core after a short spin instead of spinning on without end (a worker that
    was preempted, or shares the core, now gets to run). Bounces are unaffected and stay
    bit-identical at every worker count and block size.
  • Idle automation costs nothing per batch. A lane is sent to its device only when its value
    changed (plateaus, the stretch before the first point and after the last), and after a locate,
    a loop wrap, a transport change or any edit. A bounce with 200 lanes renders 16 percent faster
    and one with 2,000 lanes 9 percent faster. A repeated Mono or Legato mode on the FM synth no
    longer drops the keys still held, and a repeated voice limit no longer stretches a steal fade.
    Sockets that a cable overwrites are no longer cleared first, and a device whose latency cannot
    change (Device::variable_latency) is not asked for it every batch.
  • Rack, console and workflow commands no longer slow down with the size of the song. A copy
    of the document, which every command makes to plan its undo step, shares the song and the notes
    of its clips instead of copying them: adding a device, an audio track or a channel, connecting a
    cable or pasting devices took 7 to 15 ms on a song of a million notes and now takes 40 to 230
    microseconds whatever the song holds (cargo bench -p atomik-model --bench commands). Undo
    works on the step itself instead of a copy of it, and names for new devices are found without
    scanning the rack once per candidate. Quantizing a pile of notes on one tick no longer walks the
    pile for each note.
  • Drawing does less when nothing moved. Text is shaped once and kept in a bounded cache keyed
    by the string, size, weight and letter spacing, so a label drawn every frame costs a lookup
    (warm shaping of 300 labels is over 1,000 times cheaper than cold); a waveform column is read
    once per paint instead of about six times (paint_channel takes a third of the time); the
    arrangement and the piano roll repaint for a moving playhead only when its line crosses a pixel
    (or a take ghost or tempo readout under it changes); and the controls that follow automation
    flatten the lanes once per document change and skip the pass while the document, the playhead
    and the play state are unchanged. The pixels drawn are identical.
  • The undo history is bounded. A project keeps the latest 1,000 undo steps and about 512 MiB of
    what they hold; older steps are forgotten, the latest is always kept, and the audio only
    forgotten steps used leaves the project folder at the next save. Saved files, undo results and
    bounces are unchanged.
  • A clip made by a click is one snap step long. A double-click on an empty lane and a pencil
    click create a clip as long as the snap step (a bar with snap off or at Bar) where they made a
    bar. The Constrain role is wired (arrangement and piano roll) and listed in Settings, Keyboard.
  • Modifier roles that nothing read are no longer listed, and the ones that have a gesture now
    follow their remap.
    Settings, Keyboard lists only the roles a gesture acts on (a remap of the
    others stays in keymap.json). Fine adjust now decides which modifier makes a knob or fader
    drag, wheel notch or arrow key a tenth as far in the rack and the mixer, Reset parameter which
    click resets a knob or fader there, and Copy while dragging which modifier makes an
    arrangement clip drag drop a copy (on macOS the default is now Opt, as the role table says,
    instead of Cmd). Constrain is not listed until a gesture uses it. The Modifier roles section of
    docs/KEYBOARD.md says which role does what and that AltGr on many Windows layouts is Ctrl+Alt,
    the default of Disable snap.
  • A cable picked up from an input is cut when you let go, not when you press. Pressing a
    connected input used to disconnect it at once, so there was no way back; now the cable is drawn as
    the one you hold and the project changes only at the release: dropped on another input it moves
    (one undo step), dropped on nothing it is cut, dropped on its own input or cancelled with Esc
    it stays untouched.
  • The File Browser moves to F9 in the standard key set (View, File Browser), freeing F4 for
    the Piano Keys; the Atomik legacy set keeps F4 for the file browser and puts the Piano Keys on
    F9. On macOS the alternatives are Cmd+Opt+4 (Piano Keys) and Cmd+Opt+9 (File Browser). The
    one-time notice of the moved keys names both.
  • session_command and session_status follow the new question. The unsaved-changes request of
    session_command is now confirm_save (was confirm_discard; confirm_save_open for a project
    picked in the library); confirm: true answers Don't Save. session_status lists recent_files.
  • Moving the pointer over the app costs next to nothing. The document carries a revision number
    that changes with every edit, undo, redo and data sync; the unsaved-changes mark ( * in the
    title) is compared once per change instead of once per input event, the sequencer and the piano
    roll read the document again only when it changed, and a pointer move that changes nothing no
    longer repaints any window. A hover that changes what is shown, or a drag, still repaints, and
    only the window it happens in. Large songs no longer slow the pointer down.
  • The ruler's locator clicks follow the platform. On Windows and Linux Ctrl+click sets the
    left locator and Alt+click the right one; on macOS Opt+click still sets the left and
    Cmd+click the right.
  • Keys moved in the standard key set. Group Tracks is Ctrl+Shift+T (was Ctrl+Shift+G), Move
    Track Up and Down are Ctrl+Alt+Up and Ctrl+Alt+Down (were Alt+Up and Alt+Down, which the
    file browser's parent folder keeps), and Reset Track Heights is Alt+Z (was Shift+Z). The
    one-time notice of moved keys names Group Tracks too. The legacy key set keeps its keys.
  • The project reader is driven by one field table, and the module is split by area
    (crates/model/src/project): adding a field is one table row. A saved project of every released
    format version from 13 on is kept in crates/model/tests/fixtures and checked to load and resave
    canonically. Load, batch and missing-asset failures have their own error kinds (Load,
    BadBatch, MissingAsset), so a toast no longer calls a project error a patch file error. Saved
    files are byte for byte what they were.
  • Documents match the code again. The architecture, testing, devices and extending guides and
    the security policy are corrected (the format version, the crate table with a new unsafe
    column, the VST3 editor and sandbox statements, the golden files, the allocation guard coverage,
    the plugin scope of the security policy). Tests check the crate table against the Cargo.toml
    files, that every function the guides cite exists, and the command count the architecture guide
    quotes. The long documents are hard-wrapped at 100 columns, and the continuous integration job
    checks the wrapping and the links of the Markdown files.
  • Test builds now catch a device that takes a lock or makes a blocking call inside process
    (docs/EXTENDING.md); release builds contain none of it. docs/TESTING.md has a recipe for a
    scheduled hardware run.

Signing: Windows not signed, macOS ad-hoc signed only, SHA256SUMS is not signed. A build that is not signed makes the system warn on first launch; see the README for the first-run steps. Verify the downloads against SHA256SUMS.

Full changelog: v0.3.0-rc.1/CHANGELOG.md