FaderFrame

A multitrack recording, editing, mixing and mastering environment written in Rust — Linux first, Wayland native, GTK 4 native; Windows and macOS builds come from the same code.

FaderFrame aims to be a professional DAW: graph-based routing with buses, aux sends, folder buses and sidechains, hard-realtime multicore audio processing with automatic plugin delay compensation, MIDI and virtual instruments with a key, a chord track and MIDI effects, modulators and parallel effect containers, automation, CLAP/VST3 hosting (LV2 on Linux, Audio Units on macOS), an analogue-console-style mixer with modelled preamps, console summing and cue mixes for the performers' headphones, a full set of stock devices (circuit-modelled ones among them: an optical leveller, a FET compressor, a tape machine, a guitar rig), mastering meters, Mix Intelligence (masking, phase, width, dynamics, levels and a health check across the whole mix, measured and explained, with experiments to audition), A/B listening against reference tracks or earlier steps of the undo history, surround, object-based (ADM BWF) and IAMF masters with binaural monitoring, album delivery down to CD and vinyl masters, video for working to picture with time-locked tracks, lead sheets, scratch pads, project templates, and dockable, detachable editors.

Status: in active development (version 0.40.0). Most of a working DAW is there; see docs/ARCHITECTURE.md for what comes next.

What's new in 0.39

• The phone and web remote says when the firewall is in the way. A firewall that drops what it does not allow — ufw, on by default on Omarchy, or firewalld — left a phone's page loading for ever, while the remote worked on the computer itself (its own connections pass every firewall). FaderFrame now reads the firewall's settings: when it blocks the remote's port, a notice says so as the remote starts, and Preferences → Remote shows the command that lets in devices on your network only — that port, over TCP, from your local network — with a Copy button. The settings are read again every few seconds, so the note goes, with a notice, once the port is open. See A phone or tablet cannot open the remote.

0.38

• The pitch editor follows the playhead (Follow Playhead) as the piano roll does (#39).
• Colours are chosen in a resizable window of FaderFrame's own, sized for the custom-colour editor: GTK's dialog cut its colour plane off on some desktops (#40).

0.37

• Undo tree and Audio Bisect: steps undone stay as branches in the History view, any step can be heard A/B against the mix as it is, and Edit → Audio Bisect finds the edit that made the mix worse by listening — A or B, a step at a time, without touching the project.
• Codec monitor and platform previews (Audio → Listen → Codec Monitor): hear the mix through Opus at a bitrate of your choice, or at the loudness Spotify, Apple Music, YouTube, Tidal, Amazon Music or Deezer play it (YouTube's Opus as it is, the others' codecs emulated with Opus), with the decoded true peak, overs and the codec's difference to listen to; Preview on Platforms from the Render window.
• Mix scenes (View → Mix Scenes): console snapshots stored, recalled, crossfaded, morphed and compared, with safe tracks and scopes, from MIDI, control surfaces and OSC too.
• Delivery QC: stems null-tested against the mix (and a shared processing stem that makes them null), QC reports as PDF and JSON against loudness specs (EBU R128, ATSC A/85, streaming, CD and more).
• Self-freezing (Preferences → Audio → Self-freeze): while the machine struggles, tracks you don't touch play from a disk cache of their chain; faders, pans and sends stay live and plugins stay loaded.
• New devices: restoration (De-noise with a learned noise profile, De-click, De-hum, De-clip, De-reverb), Convolution Reverb (your impulse responses or eight built-in spaces), Multiband Dynamics, Vocoder, Pitch Correct, and three instruments: Wavetable, FM (DX7 banks read) and Granular.
• Audio editing: stem separation (vocals, drums, bass and the rest, with the X-UMXL model, downloaded once), Align Timing of doubles to a guide, Capture Audio (Ctrl+Alt+C: what was played before you pressed Record), Strip Silence, clip envelopes for volume and pan, slicing to Drum Sampler pads or Sampler keys, a device's own A/B and undo in its window's header, Hardware Insert Mono → Stereo, batch processing of files (File → Batch Processing…) and a media browser that previews in the project's tempo and key (View → Browser, Ctrl+Shift+B).
• MIDI and notation: a score editor (View → Score), articulation and drum maps with a map editor, microtonal tuning (Scala files, MTS, MPE; Audio → Tuning), MIDI 2.0 resolution in clips (and MIDI 2.0 ports on macOS), polyphonic lead sheets with grand staves, notes, markers and sections locked to time, comping vocals by their words, gear changes for each song in show mode.
• Spatial audio and picture: Ambisonics (AmbiX, first to third order) with head-tracked listening on headphones, 360° video, A/V calibration with a camera, panning that follows an object in the picture.
• Working with others and other programs: live collaboration over the network (File → Collaborate…), merging project versions, DAWproject, MusicXML and AAF interchange, ARA 2 plugins, Lua scripts and macros (the Scripts menu), a phone and web remote (Transport → Phone and Web Remote…), adaptive music for games (exports for FMOD and Wwise), AES67 network audio, several audio interfaces at once, and screen readers in the remaining views.

0.36

• Mix Intelligence answers right after a change: applying a proposal analyses again by itself. The tracks the change reached are rendered first, alone and in pieces side by side, so their findings — and their phase and timing pairs — are back in about half a second; the master and buses follow from one render of the whole mix, which measures everything exactly (the quick look is never kept). Undo and redo of an applied proposal analyse again too; after an undo everything comes from the cache.
• Undo for each applied proposal: an Undo button beside it and at the top of its finding takes it back — undone when it was the last step, else taken back alone as a step of its own, with later edits kept. The badge follows the history: Checking while the tracks are measured again, Applied, or Resolved when the analysis no longer finds the problem (the finding stays listed, with its Undo). Ctrl+Z and redo move the badge too.
• Faster analyses: the phase and timing pairs read their excerpts from the signals the main render already measured instead of rendering the mix a second time — the demo analyses in 1.7 s (was 2.6 s), a four times larger project in 2.5 s (was 3.6 s).
• Renders running side by side no longer share a streamed audio file (copied tracks playing one recording could read pages another render had just freed).

0.35

• Mix Intelligence, complete: everything the first milestone left open.
  • Much faster: the mix is rendered once, with every track, bus and return captured where it reaches its destination, instead of one render per track; the analysis runs on several threads, and after an edit only what it affects is measured again. The demo analyses in 2.6 s instead of 20 s, a four times larger project in 3.6 s instead of 54 s, and an unchanged project again in a tenth of a second. Bus and master compressors now react to the whole mix, and buses and returns can be named in findings.
  • Copies are not masking: two tracks carrying the same audio — a copy panned or set apart, through an EQ, slightly later, a stereo recording split in two, one source processed two ways — are reported as the same audio (with what the copy adds, +6 dB in mono for equal copies), not as masking each other, judged section by section and channel by channel. Separately recorded takes are still checked.
  • Phase and timing: polarity flips, comb filtering from small offsets, cancellation that changes with frequency, flams and loose doubles — with the track's delay and polarity as experiments to audition and apply. Longer offsets are treated as musical.
  • Stereo width per band and mono collapse, dynamics (crest factor, PLR, loudness range, transient-to-sustain, possible transient flattening, level jumps), a health check (DC offset, overs and flattened peaks between devices, devices that silence or do nothing with their CPU cost, bypassed devices) and comparisons with a reference track (loudness-matched; spectrum, sections, stereo and mono; handed to A/B listening and EQ Match).
  • Mix Intelligence and A/B listening share one listening gain; the real level change of an experiment and the gain used only to compare fairly are shown apart.

0.34

• Mix Intelligence (View → Mix Intelligence; first milestone): deterministic mix analysis with no AI, model or network. Each track is rendered offline as it sounds in the mix (or its clips before any device), and explicit, documented rules find:

  • spectral masking between pairs of tracks over time ("Bass may mask Pad at 355 Hz–1.4 kHz, for 7 s in the Verse");
  • level problems (true peak, overs, a track over full scale, loudness jumps between sections);
  • mono fold-down losses.

  Every finding shows its measurements, a separate severity and confidence with the terms they came from, the rule's method and limitations, and a few conservative experiments (an EQ cut, a dynamic cut, a level change). An experiment can be auditioned A/B, loudness-matched, and is applied only on Apply, as one undo step. Track roles (kick, bass, lead vocal …) are set by you, never guessed from names.

• A/B listening: hear the mix as it was at an earlier step of the undo history beside the mix as it is (the History view's A/B), without undoing anything, loudness-matched. A Reference view loads reference songs, plays them along the song or looping, matches their loudness, compares spectra and sends a reference to an EQ's EQ Match. Ctrl+Alt+A flips.

• Time-locked tracks (a track's menu or the Inspector → Time Base): a time-locked track's clips, automation and frozen render stay on their samples when the tempo changes, as dialogue and effects must stay with the picture. ADR cues are always locked to the picture.

• Track delay and Auto-Align: every track has its own delay, later or earlier, to a fraction of a sample (Inspector). Auto-Align Microphones… (track menus) measures the delay and polarity between microphones of one source — a kit's close, overhead and room microphones, a cabinet's, a bass's DI and microphone — and sets them in one undo step.

• 2A Leveler: an optical leveller in the LA-2A's manner. Its valve make-up amplifier and transformers are modelled, and its optical cell releases fast after a short burst and slowly after long, hard levelling. Compress and Limit, Mix, an external key, a stereo link, 11 presets.

• Tape Machine: recording to tape and back, modelled physically — magnetic hysteresis with AC bias (over- and under-biased too), three tape formulations, NAB/IEC EQ at 3¾–30 ips, the head bump, wow and flutter at a studio machine's figures, optional hiss. 13 presets.

• Guitar Station: three new pedals — Red Squeeze (after the MXR Dyna Comp), Juicer (after the Orange Squeezer) and Carbon Echo (after the MXR Carbon Copy bucket-brigade delay) — and two new amplifiers with both their channels, the Tweed Lux (Fender 5E3 Deluxe) and the Seattle 100 (Soldano SLO-100). Pedal rigs moved into a "Pedals" preset group.

Since 0.23 (0.24–0.33)

• Ripple editing per track, on selected tracks or across the project with the timeline, automation moving along.
• Third-party plugin GUIs under FaderFrame's editor header on Linux, Windows and macOS; LV2 plugin UIs (embedded or floating).
• A count-in of its own (Transport → Count-in); Stop stays where the playhead is heard; automation menus grouped by device with a search field.
• A start window (recent projects, a new or template project, the demo); the arranger's zoom and scroll saved with the project; themes of your own (View → Theme → Edit Themes…).
• Take lanes of any height, each take auditioned on its own; a click on a lane comps only the section under it (#20).
• Drum notes drawn as diamonds in the piano roll (Automatic, Bars or Diamonds).
• Stuck notes fixed: opening a plugin editor or bypassing, removing or moving a MIDI effect while it plays (#27).
• Renderer choice (Preferences → General → Renderer), macOS start-up and Apple-silicon fixes (#25), dragging clips no longer runs out of file descriptors (#18), the TAP pad no longer maximises the window (#21).

Screenshots

They show the demo session (--demo, or Preferences → General → On start-up): eight bars in A minor whose audio is generated, so it needs no files (the vocals, picture and drum-sampler shots add imported files). The main set is in the default Studio skin.

Arranging, editing and recording

The Editing workspace: markers, the Intro and Verse sections, the key and the chord track above the tracks, the arpeggios in a folder, and in the bottom dock the pad's modulators — an envelope follower that ducks it under the drums and a synced LFO that moves it across the stereo field. Beside the transport are the Q (input quantize) and the "i" (Inspector) buttons:

Snap to Objects: the Bassline dragged in Slip mode (where nothing else attracts it) lands on the start of the Pad and Melody clips at bar 5; the guide line names what it caught. Above it the edit toolbar, with Objects and Samples (snap to samples) on:

A scratch pad: the Verse copied into a pad of its own ("Verse Idea" — its clips, section, key and chords) to try something without touching the song. The switcher in the arranger's corner shows the pad in the accent colour, the ruler is tinted, and its menu goes back to the song, makes new pads or brings this one into the song:

Recording from bar 1 with a two-bar pre-roll: what lies before the project's start is counted in — the counter runs up from −1.1 with COUNT-IN under it and the ruler shows a badge — and playback and the take begin on bar 1. The Transport menu holds the stop behaviours, aborting a take, the Play Start Marker and check marks for every switch:

The MIDI workspace with the piano roll editing the lead synth's melody, the key and the chords above the notes and the scale highlighted:

Clips: the plucks' harmony and the drum loop's hits converted to MIDI on new tracks under them, and the pad's clip effects (a compressor, a saturator and a reverb rendered into the audio it plays):

Vocals: a sung phrase in the pitch editor, its notes corrected to the key (their sung positions faintly behind them, the vibrato halved), and a speech clip transcribed into the Lyrics lane above the tracks (both imported into the demo):

Mixing

The Mixing workspace: a preamp on the bass, inserts, sends to an echo and a reverb aux, a MIDI track's strip (it plays the arpeggiating synth), the drum bus's parallel-compression container and a true-peak limiter on the master:

The Inspector (F11, or the "i" in the header bar) on the left with the selected bass track — its routing, track settings, devices (with their latency and gain reduction) and its channel strip — and the Channel Overview in the bottom dock: input → American 312 preamp → Compressor → Saturator → channel → sends → output:

Folders that are buses and groups: the Arpeggios folder sums its tracks (BUS in its header, its strip a FOLDER BUS in the Inspector) and its G switch makes them one for editing and arming:

A cue mix for the performers' headphones: the bar over the strips switches the mixer between the main mix and Cue 1 (Copy Main Mix, pre-fader taps, TALK latched); every fader, pan and mute now sets the track's send to the cue mix, framed in its colour — a track that reaches the master through a bus is off by the console rule (the drums go through the drum bus) — and the master section is the cue mix's own, on outputs 3–4 with its click:

A multi-output instrument: the Drum Sampler on the lead synth's track plays its pads (loaded with six samples, its editor on the right) into its outputs, and Create Output Tracks gave every output a track of its own in one step — Lead Synth Main and Out 1–8, in a folder under the instrument, routed where it went (its own track now only carries the instrument):

Surround and objects: the master as a 7.1.4 bed, the tracks placed in its room (the small rooms in the mixer strips, their meters showing every channel), the lead synth as an object, and the Surround Panner with the pad behind the listener and up high:

Devices

Device editors: the EQ (dynamic and spectral bands, analyser), the Synth (three decks of sections under its oscillator, filter and envelope displays — LFO 2, the mod envelope, the modulation matrix, the wheels, chorus, delay and reverb among them), the Program EQ and the Parallel Squash container on the drum bus:

The Compressor on the bass (its transfer curve and the gain reduction over the signal), the true-peak Limiter on the master with its loudness readouts, the Reverb and the Delay (Echo):

Mastering and delivery

The Mastering workspace with the Tools view (EBU R128 loudness, levels, phase and spectrum):

The album: the demo's sections as songs, analysed, with what delivery will make of them (levelling, limiting) and the CD and vinyl masters a click away:

After every render and album export, a report measured from the files as written:

Picture and performance

Picture: a movie in the arranger's Video lane above the demo (a filmstrip of the clip) and the video window in the bottom dock, frame-exact against the sound — the time burnt into the picture (10.440 s) and the overlay's project timecode (00:00:10:11 at 25 frames a second) agree:

The clip launcher: the demo's clips sent to it in four scenes, the Verse playing (green, each clip's loop progress under its name) and the Chorus waiting for the next bar (yellow). The letters are launch modes (G gate, T toggle, R repeat, L legato), the chevrons follow actions. Record to Arrangement is on: every loop played to its end is already written into the arrangement above, where the tracks that play the launcher are dimmed:

Setting up

Preferences → Audio (here on the silent dummy device with a pretend eight-channel interface): the devices, sample rate, buffer size and channels, then what runs — the stream, the latencies (recordings move back by the input and output latency) and where each channel goes. With PipeWire or JACK it also offers a second device to play on or record from:

The plugin browser with favorites in categories of your own, a plugin's details and its realtime check:

Skins

Nine skins, switched live (View → Theme or Preferences → General → Theme): Studio, Vintage Console (walnut cheeks, enamel panels, skirted knobs, plasma bar-graph meters), Daylight (light), Midnight, Frost, Fjord (dark slate and petrol panels with coral and old-gold light, calm contrast for long sessions), Neon, High Contrast and Lumen:

Themes of your own: View → Theme → Edit Themes… starts from a built-in skin and changes any of its 56 colours, applied as you edit; they are JSON files in the settings' themes folder and appear after the built-in skins.

Lumen, the newest skin, is drawn with light instead of hardware: ink planes stepped by luminance, halo knobs with glowing value arcs, pill faders and buttons that light from within, fine gradient meters with a bloom, clips as translucent cards, a glass transport display in tabular figures and one cyan-to-violet accent:

What works today

• GTK 4 application, native on Wayland, HiDPI/fractional scaling via GTK. Optionally the analysers, the EQ and the devices' faces are drawn on the GPU (vello on wgpu; Preferences → General → Drawing): the mastering tools went from 26 to 55 frames a second, and the frames go to GTK without a copy through the CPU — as dmabufs on Linux (60 frames a second), as shared D3D12 textures on Windows.
• Arranger (virtualised): tracks, audio clips with waveforms, MIDI clips, move/split/delete, snapping, zoom down to single samples with the grid drawn at every zoom where clips snap (how strongly: Preferences → Editing → Grid lines), loop range (dragged or resized while playing without a glitch), playhead, console-style track headers with mute/solo/arm/monitor, volume, pan and meters (the wheel over the headers turns their faders and knobs and never scrolls; a held scrollbar stops the view following the playhead). Clicking a clip selects it and moves the playhead to the (snapped) click; Shift-click selects from the last clicked clip, Ctrl-click toggles one, Ctrl-drag draws a rectangle, Ctrl+A selects every clip shown, and moves, trims, fades and gain changes apply to every selected clip. Splitting (S, or B with a range) keeps every piece selected, so aligned drums split again without reselecting.
• Snap to Objects (on by default; Edit menu, the edit toolbar's Objects, Preferences → Editing): a drag within 8 pixels of a clip edge on any shown track, a marker, a section, the loop, the edit selection, the Play Start Marker or the stopped playhead lands on it, before the grid, with a guide line naming what it caught; automation points, tempo points, chords and piano-roll notes snap the same way. Alt bypasses all snapping; in Slip mode only objects attract.
• Clipboard: Ctrl+C/X/V/D copy, cut, paste and duplicate the edit range (with its automation) or else the selected clips — with everything they hold, by value, so a paste works after the source track is gone. Paste goes to the playhead (the edit cursor without Link Timeline) on the selected track, the other copied tracks following on the tracks below that take their kind of clip; Shuffle inserts and pushes, the other modes replace what is under the paste; the insertion point moves to the end, so repeated pastes lay copies end to end. Shortcuts follow the editing context — the editor last worked in, never a text field or a toolbar.
• Global lanes under the ruler (click a lane's title, or View → Lanes, to show or hide lanes): markers (double-click to add, drag to move, double-click to rename, click to jump there), the arranger lane for song sections (drag to create Intro, Verse, Chorus …; resize, rename, recolour, loop or select a section), the key (drag to set a key over some bars, drag a key change), the chords (drawn, typed or found in the music; Delete All Chords), time signature changes, the tempo map (drag points up and down or sideways, type values, steps or ramps), and, when there is something to show, the and the . The ruler carries the loop, the Play Start Marker and, while counting in, a badge.

Building

Requirements: Rust 1.92 or newer (rustup), GTK 4.14+ and GStreamer (1.24+ on Linux, where video uses its dmabuf formats; 1.18+ on Windows and macOS — with its base and good plugins; the bad ones add the H.264/H.265 parsers and hardware decoders video uses) with pkg-config.

Linux additionally needs the development files of JACK (jack.pc; libjack itself is loaded at run time, so FaderFrame starts without it), ALSA and PipeWire, and libclang (the PipeWire bindings are generated at build time):

Distribution	Packages
Arch / Manjaro	gtk4 pkgconf pipewire-jack (or jack2) alsa-lib pipewire clang cmake gstreamer gst-plugins-base gst-plugins-good gst-plugins-bad
Debian / Ubuntu (24.04+)	libgtk-4-dev pkg-config libjack-jackd2-dev libasound2-dev libpipewire-0.3-dev libclang-dev cmake libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev gstreamer1.0-plugins-good gstreamer1.0-plugins-bad
Fedora	gtk4-devel pkgconf-pkg-config pipewire-jack-audio-connection-kit-devel alsa-lib-devel pipewire-devel clang-devel cmake gstreamer1-devel gstreamer1-plugins-base-devel gstreamer1-plugins-good gstreamer1-plugins-bad-free

macOS (Apple Silicon or Intel): brew install gtk4 pkgconf cmake gstreamer.

Windows: in an MSYS2 UCRT64 shell, pacman -S mingw-w64-ucrt-x86_64-gtk4 mingw-w64-ucrt-x86_64-pkgconf mingw-w64-ucrt-x86_64-gcc mingw-w64-ucrt-x86_64-rust mingw-w64-ucrt-x86_64-cmake mingw-w64-ucrt-x86_64-gstreamer mingw-w64-ucrt-x86_64-gst-plugins-base mingw-w64-ucrt-x86_64-gst-plugins-good mingw-w64-ucrt-x86_64-gst-plugins-bad.

Plugin GUIs embed natively everywhere: X11 windows on Linux (through XWayland), Win32 windows on Windows, Cocoa views on macOS. CI builds and tests all three platforms.

ASIO (Windows) is opt-in: cargo build --release --features faderframe-app/asio compiles Steinberg's ASIO SDK (downloaded by asio-sys, or taken from CPAL_ASIO_DIR; bindgen needs LLVM — CI checks the backend with the MSVC toolchain). The SDK's licence — Steinberg's proprietary one or GPLv3 — then applies to that binary, which is why the default builds leave it out.

cargo build --release
cargo run --release -p faderframe-app -- --demo   # starts with the demo session

The binary is target/release/faderframe:

faderframe [--backend auto|pipewire|jack|system|asio|dummy] [--sample-rate HZ]
           [--buffer-size FRAMES] [--threads N] [--empty | --demo]
           [--import FILE]... [PROJECT.ffproj]

Without --empty, --demo or a project, FaderFrame opens what Preferences → General → On start-up says (the last project by default). system is ALSA, WASAPI or CoreAudio. JACK clients connect to the PipeWire graph directly when pipewire-jack is installed; the native PipeWire backend needs no JACK at all.

Packages

packaging/ builds installable packages; the Release workflow builds all of them for a v* tag and attaches them to the GitHub release.

Platform	Package	How
Linux	portable tarball (GTK and GStreamer bundled; runs in place, install.sh installs it)	cargo build --release && packaging/linux/tarball.sh
Linux	Flatpak (GNOME 51 runtime)	flatpak-builder --user --install build-dir packaging/flatpak/io.github.BurningTreeC.FaderFrame.yml
Linux	system install from source (binary, desktop entry, AppStream, MIME type, icon)	cargo build --release && sudo packaging/linux/install.sh /usr/local
macOS	FaderFrame.app in a DMG (GTK and GStreamer bundled, ad-hoc signed)	brew install gtk4 adwaita-icon-theme librsvg pkgconf gstreamer && packaging/macos/bundle.sh
Windows	installer (Inno Setup) and portable zip (GTK and GStreamer bundled)	in MSYS2 UCRT64: packaging/windows/bundle.sh

The release tarball is built on Debian 13 and bundles GTK 4.22. Every ELF in the package is checked to require no newer than glibc 2.41, so it runs on Debian 13 and newer distributions. The Flatpak carries its complete runtime for older distributions. Source builds use the requirements listed above.

Video needs nothing installed with a package: the Linux tarball, the macOS and the Windows packages carry GStreamer with the plugins video uses (a system's GStreamer cannot be mixed with the bundled GTK libraries); the Flatpak takes it from the GNOME runtime. The Linux tarball also carries an LGPL build of FFmpeg's post-production decoders (ProRes, DNxHD/DNxHR, MPEG-2, DV, FFV1, JPEG 2000 and others) and its MXF demuxer, through GStreamer's libav plugin; no package carries FFmpeg's H.264 or H.265 decoders, so those go through the hardware (VA-API on Linux, through your graphics driver).

The macOS app is signed ad hoc, not notarised, so Gatekeeper stops it the first time. On macOS 15 and later, try to open it once, then allow it in System Settings → Privacy & Security → Open Anyway (earlier versions: right-click → Open). Or clear the download's quarantine flag: xattr -dr com.apple.quarantine /Applications/FaderFrame.app. The Windows installer and zip are not signed either: if SmartScreen stops the installer, choose More info → Run anyway.

Portable mode. With a folder named FaderFrame Data next to the program, FaderFrame keeps everything it would put into your profile in there — settings, plugin caches, presets, recordings of unsaved projects — and also loads CLAP and VST3 plugins from its Plug-Ins/CLAP and Plug-Ins/VST3. The Linux tarball and the Windows zip come with the folder, so they run from a USB stick as they are; on macOS put the folder next to FaderFrame.app (after moving the app out of the download folder, which macOS runs from a read-only copy). Preferences → General shows where the data goes. Video proxies and frame indexes are the exception: they take gigabytes per hour of picture, so they go to the computer's cache folder even then.

Shortcuts

Key	Action
Ctrl+N	New project (from the default template, if one is set)
Ctrl+O / Ctrl+S / Ctrl+Shift+S	Open / save / save as
Space	Play / stop
Home	Return to start
L	Toggle loop
Shift+R	Record
Ctrl+Space / Ctrl+Shift+Space	Abort the take being recorded / abort it and record again from where it began
Ctrl+P	Punch in/out
J / K / L (with picture in the project)	Shuttle reverse / stop / forward (K held with J or L: a frame back or on)
T	Show / hide the take lanes of the selected take folder
A	Show / hide automation of the selected tracks
Alt+wheel	Track height (all tracks)
Ctrl+Z / Ctrl+Shift+Z (or Ctrl+Y)	Undo / redo
F2 / F3 / F4	Toggle bottom dock / show mixer / show piano roll
F11	Inspector
F8	Performance meter
F12	Tools (loudness, level, phase, spectrum)
Ctrl+1 … Ctrl+5	Workspaces
Ctrl+T / Ctrl+Shift+T	New audio track / new instrument track
Ctrl+I	Import audio files
Ctrl+Shift+R	Render / export
Ctrl+Shift+C	Capture MIDI (what was played last becomes clips)
Ctrl+Alt+S	Save a version of the project
Ctrl+Shift+P	Command palette
Ctrl+,	Preferences
Ctrl+wheel / Shift+wheel	Zoom / scroll horizontally
Shift or Ctrl while dragging	Fine adjustment
Alt while dragging	Disable snapping
Ctrl+E	Show / hide the edit toolbar
K (or keypad 7)	Metronome on / off
Alt+1 … Alt+4	Edit mode: Shuffle, Slip, Spot, Grid

View → Keyboard Shortcuts… changes any command's shortcut. Editing keys go to the editor you last worked in (the arranger, piano roll, event list, pitch or spectral editor …), never to a text field being typed in or a toolbar; text fields keep their own Ctrl+C, Ctrl+V, Ctrl+A and Ctrl+Z.

Development

cargo fmt --all -- --check
cargo clippy --workspace --all-targets
cargo test --workspace                 # or: cargo nextest run --workspace
cargo run -p faderframe-bench --release -- --tracks 128 --block 64 --rate 96000
python3 scripts/third_party_licenses.py --check
cargo deny check licenses bans sources

The workspace has 68 crates and over 2,100 tests; about 60 of them are opt-in (--ignored): they need something from outside (an installed plugin, a model, real MIDI or audio hardware) or measure speed. See docs/ARCHITECTURE.md for the design, crate responsibilities and invariants.

License

FaderFrame is released under the MIT license. Third-party components and their licenses are listed in THIRD_PARTY_LICENSES.md.

Troubleshooting

After a crash: the report and the log

When FaderFrame crashes, it writes a crash report and keeps a log of the run. Those two files usually say what went wrong.

The quick way. Start FaderFrame again. If the last run didn't close properly, a window appears: FaderFrame closed unexpectedly last time (started … UTC). Show Report opens the crash report: the file to send. Show Log appears instead when there is no report (see No crash report?). Open Folder opens the folder with all reports and logs. The window appears only once, at the next start; if you closed it, find the files by hand as described below.

What to send. All files are in a folder named Crash Reports. The names hold the start time (UTC) and the process number, so files from the same run match:

File	What it is
crash-20261021-095712-46264.log	The crash report. FaderFrame version, system, GTK version, where it crashed (backtrace) and the last 150 lines of the log.
session-20261021-095712-46264.log	The log of that run, from start to crash. Same time and number as the report.
crash-…-plugin-sandbox-….log	A plugin crashed in its sandbox. FaderFrame itself kept running.
crash-…-check-plugin-….log	A plugin crashed during a plugin check.
running-<number>	A marker FaderFrame writes while it runs. You don't need to send it.

Please send:

1. The crash-….log and the session-….log with the same time and number.
2. What you were doing just before. For example: "pressed Play", "changed the Audio System from PipeWire to JACK in Preferences → Audio", "opened plugin X".
3. Whether it happens every time or only sometimes.

Report problems at https://github.com/BurningTreeC/faderframe/issues.

Privacy: logs contain file paths, including your user name, project names and plugin names. Look through them before posting them publicly.

Copy the files soon. FaderFrame keeps the newest 20 crash reports and only the newest 8 session logs. Older ones are deleted at start-up, so after eight more starts the log of a crashed run is gone.

Where the files are

How FaderFrame is installed	Crash Reports folder
Portable (Linux tarball or Windows zip with a FaderFrame Data folder next to it)	FaderFrame Data/Data/Crash Reports inside the FaderFrame folder
Linux (installed with install.sh, a distribution package, or built from source)	~/.local/share/faderframe/Crash Reports (or $XDG_DATA_HOME/faderframe/Crash Reports)
Linux Flatpak	~/.var/app/io.github.BurningTreeC.FaderFrame/data/faderframe/Crash Reports
macOS	~/Library/Application Support/faderframe/Crash Reports (portable: FaderFrame Data/Data/Crash Reports next to FaderFrame.app)
Windows (installer)	%LOCALAPPDATA%\faderframe\Crash Reports
FADERFRAME_DATA_DIR set	<that folder>/Data/Crash Reports

A crash report's first lines also name the log file of its run, with its full path. To open the folder from a terminal:

# Linux, newest files first
ls -lt ~/.local/share/faderframe/"Crash Reports" | head
# Linux portable: in the FaderFrame folder
ls -lt "FaderFrame Data/Data/Crash Reports" | head
# macOS
open ~/Library/Application\ Support/faderframe/Crash\ Reports

:: Windows (Win+R, or a command prompt)
explorer "%LOCALAPPDATA%\faderframe\Crash Reports"

No crash report?

If there is a session-….log from the time of the crash but no crash-….log, the system ended FaderFrame, so it had no chance to write a report. Common causes:

• Memory ran out (Linux's out-of-memory killer).
• A realtime time limit was reached. On Linux, audio threads that get realtime priority from RealtimeKit (rtkit) have a CPU-time limit, and the system kills a program whose realtime thread goes past it. FaderFrame normally catches this first: it puts the thread back to normal priority and the log says "… ran realtime past the time limit without a break". Giving your user realtime rights removes the limit (see Realtime rights on Linux).
• The computer froze, restarted or lost power.

Please send the session-….log of that run. On Linux, also send what the system logged around that time:

journalctl -b --since "15 minutes ago" | grep -i -E 'faderframe|out of memory|oom|killed process|rtkit' > faderframe-system.txt

Change "15 minutes ago" to cover the time of the crash. If the computer restarted since then, use journalctl -b -1 (the previous boot) instead of -b.

FaderFrame stops responding (a freeze, not a crash)

If the window stops responding and the system offers to force-quit it, don't force-quit yet. A freeze writes no report by itself. While it hangs, save where every thread is.

On Linux, with gdb installed (sudo apt install gdb, sudo pacman -S gdb, …):

gdb -p "$(pgrep -o -x faderframe)" -batch -ex 'thread apply all bt' > faderframe-freeze.txt 2>&1

(pgrep -o picks the oldest process named faderframe: the program itself, not its plugin helpers.) If gdb says ptrace: Operation not permitted, run the same command with sudo in front. Then close FaderFrame and send faderframe-freeze.txt together with the session-….log of that run.

On macOS, open Activity Monitor, select FaderFrame, and choose ⋯ → Sample Process. Then save the sample and send it.

A complete native backtrace (Linux, optional)

When FaderFrame crashes on a fatal signal (a segmentation fault or an abort), it writes its report and then lets the system handle the crash. Where the system keeps core dumps, this adds a complete backtrace of every thread.

Arch, Fedora and openSUSE have systemd-coredump set up already. On Debian, Ubuntu, Linux Mint and LMDE, install it once:

sudo apt install systemd-coredump

After the next crash:

coredumpctl list faderframe              # the crashes the system kept
coredumpctl info faderframe > faderframe-coredump.txt   # the newest one

Send faderframe-coredump.txt together with the crash report.

More detail in the log

If the crash is hard to pin down, start FaderFrame from a terminal with a more detailed log. Then make the crash happen again. The session-….log of that run will hold the extra detail, which also appears in the terminal.

# Linux portable: in the FaderFrame folder
RUST_LOG=debug ./faderframe
# Linux installed
RUST_LOG=debug faderframe
# macOS
RUST_LOG=debug /Applications/FaderFrame.app/Contents/MacOS/FaderFrame

# Windows (PowerShell)
$env:RUST_LOG = "debug"; & "$env:ProgramFiles\FaderFrame\bin\faderframe.exe"

A debug log grows quickly, so stop as soon as the crash has happened. Afterwards, start FaderFrame normally again, without RUST_LOG.

Realtime rights on Linux

Audio runs best when your user may give threads realtime priority and lock memory. FaderFrame's log says at start-up when it can't lock memory:

memory not locked: the memory-lock limit is 8192 KiB (unlimited for members of the realtime or audio group …)

Without these rights, FaderFrame asks RealtimeKit for realtime priority. RealtimeKit grants it with limits: a low priority, a limited number of threads per user, and a CPU-time limit per thread. Also, without memory locking, audio memory can be swapped out. Expect more dropouts under load.

To check your limits, run this in a terminal (ulimit -r is the realtime priority, ulimit -l the memory you may lock, in KiB):

ulimit -r -l

A realtime priority of 0 means no realtime rights. To grant them:

Debian, Ubuntu, Linux Mint, LMDE (and most other distributions):

sudo tee /etc/security/limits.d/95-audio.conf <<'LIMITS'
@audio   -  rtprio     95
@audio   -  memlock    unlimited
LIMITS
sudo usermod -aG audio "$USER"

Arch Linux:

sudo pacman -S realtime-privileges
sudo usermod -aG realtime "$USER"

Then log out and back in (a restart is surest). ulimit -r -l should now show a realtime priority above 0 (95 with the file above, 98 with Arch's package) and unlimited, and the "memory not locked" line is gone from FaderFrame's log. While FaderFrame runs, this shows the limits it really got:

grep -E 'realtime|locked' /proc/"$(pgrep -o -x faderframe)"/limits

Realtime rights let your programs run ahead of everything else on the system, so a program that hangs at realtime priority can make the desktop sluggish. That is the usual trade-off on audio workstations.

A phone or tablet cannot open the remote

The page keeps loading and then gives up: most often the computer's firewall drops the connection. On the computer itself the remote still works — its own connections pass the firewall — so the address answering there proves nothing. When ufw or firewalld blocks the port, Preferences → Remote shows a Firewall row with the command that lets in your network only. With ufw (on by default on Omarchy) it looks like this — your network interface, your network and the remote's port (8642 unless you changed it):

sudo ufw allow in on enp4s0 from 192.168.178.0/24 to any port 8642 proto tcp comment 'FaderFrame remote'
sudo ufw status numbered    # the rule is there

That lets in only devices on your network, on that port, over TCP, on the interface the computer is on that network with (not a VPN's). The remote answers IPv4 only, so no IPv6 rule is needed; and when the remote is off, nothing listens on the port. To close it again: sudo ufw delete allow in on enp4s0 from 192.168.178.0/24 to any port 8642 proto tcp. Don't forward the port on your router: nothing needs to reach it from the internet.

If the firewall lets it in and the page still doesn't load:

• The phone must be on the same network, not a guest Wi-Fi (a FRITZ!Box's guest network, for example, is kept apart from the computers).
• A VPN app on the phone can keep it from local addresses.
• Preferences → Remote's Status names the address to open; it changes when the computer gets another address on the network.

Options to narrow a problem down

Each of these turns off one part, so you can see whether the problem goes away with it. The audio system, buffer size and processing threads take effect with Preferences → Audio's Apply button; the other Preferences options take effect at once. Command-line options and environment variables apply to one start. For example: FADERFRAME_NO_MIDI=1 ./faderframe.

Audio

• Silent dummy device: faderframe --backend dummy. If the problem is gone, it lies in the audio path (device, audio system or plugins).
• Another audio system: Preferences → Audio → Audio system (PipeWire, JACK or ALSA on Linux), or --backend pipewire|jack|system.
• A larger buffer: Preferences → Audio → Buffer size, or --buffer-size 1024. This helps with dropouts under load.
• Fewer processing threads: Preferences → Audio → Processing threads → 1 (audio thread only), or --threads 1.
• Render ahead off: Preferences → Audio → Render ahead → Off.
• Stuck notes or a burst of noise: Transport → Panic resets every device.

Plugins

• Plugins in their own processes: Preferences → General → Plugins, "Run each plugin in its own process" (on by default; CLAP and VST3, plus Audio Units on macOS). A crashing plugin then stops only itself, and its track plays on dry.
• Check a plugin: the plugin browser's Check button plays a plugin under measurement and lists what it does wrong on the audio thread.
• An empty project: faderframe --empty shows whether the problem comes with the project's plugins or content.

Graphics, MIDI and video

• Drawing on the GPU off: Preferences → General → Drawing, or FADERFRAME_GPU_PAINTER=0. Try this for crashes or wrong pictures that could come from the graphics driver.
• Software rendering: Preferences → General → Renderer → Software (from the next start), or GSK_RENDERER=cairo for one start. GTK then draws without the graphics driver. When the last run crashed inside the driver (for example Mesa's libgallium), FaderFrame switches to Software by itself and says so; choose Automatic there to go back. Automatic is Software on Intel graphics up to Haswell (GMA, Ironlake, Sandy Bridge, Ivy Bridge, Bay Trail, Haswell, Cherry View): Mesa's crocus driver for them crashes under GTK's renderer. Choose OpenGL to use the chip anyway.
• No GPU frame sharing: FADERFRAME_GPU_DMABUF=0 (Linux; Windows: FADERFRAME_GPU_SHARE=0).
• No zero-copy video: FADERFRAME_VIDEO_DMABUF=0 (Linux).
• MIDI hardware closed: FADERFRAME_NO_MIDI=1.

Realtime (Linux)

• Don't ask RealtimeKit: FADERFRAME_RTKIT=0. FaderFrame then doesn't ask RealtimeKit for realtime priority for its own threads. PipeWire still asks for its own.
• Let the CPU sleep deeply: FADERFRAME_CPU_LATENCY=0. Where the system lets it (/dev/cpu_dma_latency writable, e.g. Arch's realtime group), FaderFrame keeps the CPUs out of deep sleep states while it runs. This turns that off.

If one of these makes the problem go away, please say which in your report.