A live rack for Linux: plug in instruments, wire them up, play.
kabelsalat turns your computer into a live setup like the ones built with AUM on the iPad: synths and effects sit in a rack, connected by patch cables that you can see and grab, and everything you play goes straight to the speakers. Several setups ("rigs") can sound at once, each played from its own keyboard or controller.
Open the app and play with your laptop keyboard, the on-screen keyboard, or any USB MIDI keyboard — devices are found while the app runs, just plug them in. Starter setups (F5–F7, Shift+F5–F7) give you a cathedral pipe organ, a jazz or rock tonewheel organ, an ambient pad, a synth lead or a guitar rig with one key. They use a handful of free plugins (Aeolus, setBfree, Surge XT, Guitarix); a setup whose plugins are missing is greyed out in Sessions with an Install button.
Every rig is a kind of instrument: piano, e-piano, jazz organ, pipe organ, synth, bass, wind or drums. kabelsalat knows it from the plugin (setBfree is an organ, AVL Drumkits are drums, Starbreath is a wind) or from the sound you load (a Surge XT "Winds/Flute" makes the rig a wind). You can also mark a rig as a type yourself; the mark is saved with the session. The left rail, the Plugins browser, the demo phrase and the agent all use the same type.
The on-screen keyboard (V) turns into the instrument the active rig is:
- Piano: damper and soft pedals, touch velocity from where you hit the key (soft at the top, loud at the bottom), sustained notes marked in teal.
- Jazz Organ (setBfree): the nine drawbars, JAZZ/ROCK/GOSPEL/FLUTE registrations, Leslie STOP/SLOW/FAST, swell pedal, percussion, and two stacked manuals on MIDI channels 1 and 2. Drag across the keys for a glissando.
- Pipe Organ (Aeolus): division tabs, the stop jamb, six pistons, tremulant, couplers (II/I, III/I, …) and the swell pedal.
- Synth: pitch-bend and modulation wheels, the patch's own macro knobs and an X/Y pad over the first two, scale highlight and FOLD (only the scale's notes as keys), arpeggiator switch, sustain and velocity.
- E-Piano: damper, touch velocity and a tremolo wheel.
- Bass: a four-string neck beside the keys that shows where each held note lies, and that you can play.
- Wind: a breath control that sends CC 2, CC 11 or aftertouch, and Y-BREATH: how far down the key you play sets the breath.
- Drums: sixteen pads on the General MIDI drum notes in place of keys.
Keys sound for as long as you hold them, and the chord you hold is named in the
header. The agent can read and switch all of this too (get_keyboard_state,
set_keyboard_mode).
EXPAND (Shift+V) turns the whole window into the instrument, without the rack (Esc or DOCK brings it back), and the instrument moves as you play:
- Piano: the open case shows strings, dampers and hammers. A note's hammer rises and its string swings, and the dampers lift with the sustain pedal.
- Jazz Organ: a tone generator whose wheels light up for every pulled drawbar of the notes you hold, full-length drawbars with the registration written out ("88 8000 000"), preset keys, the rotary speaker spinning up and down, one or two manuals and the swell shoe.
- Pipe Organ: a pipe front where each sounding note's pipe speaks, every division's drawknobs at once, couplers, tremulants, thumb pistons, and swell shutters that open with the swell shoe.
- Synth: a display with the patch and a scope, the patch's macro knobs, a large X/Y pad, and full-height pitch and mod wheels.
- E-Piano: a tine per key that lights and swings while its note sounds, the tremolo wheel and the sustain pedal.
- Bass: a full neck to fifteen frets, with each held note on the string and fret a bassist would use.
- Wind: the breath column and an air column that shortens as the note rises and fills with the breath you give it.
- Drums: a kit seen from above, where you hit each drum and cymbal (harder in the middle), next to a 4×4 pad bank.
Press Tab to turn the rack around and patch on the back. Drag from jack to jack to connect, drag a plug to move it, pull it off to unplug. The cables sag and swing, and light up when signal flows through them.
+ Rig adds an independent setup with its own synth and output — for example
bass on one keyboard and pads on another. All rigs play together; switch the one
you are looking at with 1–9. Any installed CLAP or LV2 instrument works
(Surge XT, Dexed, Vitalium, …), and each unit shows which instrument and sound
it has loaded. Every rig row in the Left Rail (Q) has a ▶ demo button
that loops a live musical phrase suited to its sound (keys, bass, lead, pad,
organ, drums, or wind with CC 2 and aftertouch breath) on the engine clock at
the session tempo — turn knobs, swap sounds or add effects and hear them right
away without a MIDI keyboard (play_demo / stop_demo for agents).
Press F12 (or click Setlist) to organize a gig into songs and parts (Verse, Chorus, Solo) over the loaded rigs. Every rig stays loaded; each part says which rigs take new notes, with per-rig key range, transpose, level and stored knob values, and each song can set its own tempo and time signature. Switching parts never cuts held notes or reverb tails — outgoing rigs keep sounding until you release the keys or sustain pedal, while new notes play the next part from the same audio block on. Step parts from the top bar, with PageUp / PageDown (Shift+PageUp / Shift+PageDown for songs — works with page-turner pedals), or bind a hardware MIDI foot-switch CC. Add song from session pulls a saved session's rigs into the gig as a new song, and the assistant and MCP agents can read, build and step the setlist.
Press F9 (or B) to open Plugins, organized by what each unit does
rather than by plugin format: Instruments, Effects, MIDI FX,
Utilities and the Install catalog. Narrow Effects by subcategory
(Delay & Reverb, EQ & Filter, Dynamics, Drive & Amp,
Modulation, Pitch & Spatial, Multi-FX) or filter by format
(Built-in, CLAP, LV2). Add an instrument as a New rig alongside
your existing rigs or layer it into the active rig, insert any effect onto the
active rig or straight onto the Master FX bus, and filter the mixer's
+ insert picker by the same effect categories. The assistant and MCP agents
search the same taxonomy with list_plugins.
Plugins → Install lists 23 hand-picked plugins that are known to work in
kabelsalat, and Install fetches one for you: the Arch package where there is
one, otherwise a pinned release or a build from source into ~/.clap or
~/.lv2. Synths: Surge XT, Dexed, Vitalium, Odin 2, OB-Xf (Oberheim), the
Juno-style Ultramaster KR-106, Six Sines (FM), JC303 (TB-303), YANES (chiptune)
and Cardinal (modular). Keys and organs: setBfree, Aeolus, Unsampled Piano
(physically modelled acoustic grand piano), OneTrick KEYS (lo-fi modelled
piano). Bass and drums: OneTrick CHONK, OneTrick CRYPTID (FM drums),
AVL Drumkits (sampled kits). Winds: Starbreath, modelled flutes, reeds and
brass for a wind controller (freeware, x86-64 only). Effects and MIDI tools:
Floe (sample libraries), Guitarix, Dragonfly Reverb (Hall, Room, Plate and Early
Reflections CLAP reverbs), Airwindows Consolidated (hundreds of Chris Johnson's
studio processors in one CLAP effect) and the x42 MIDI filters (chord, strum,
mono legato, CC remap). A card says when a plugin has no build for your CPU, and
links its source code and website. See docs/PLUGINS.md for
which plugins have been tested, what works, and what is still untested.
A MIDI strip sits between your keys and the instrument and changes the notes
on the way: the built-in MIDI transpose, or any installed LV2 MIDI plugin
(note transposers, filters, arpeggiators — pick one in Plugins and press
Add MIDI strip). The strip shows the plugin's own main controls, they can be
learned from a hardware knob like any other, and a note released while you turn
a knob never hangs. The assistant can add strips too (list_midi_fx, add_node
with kind midi_fx).
Plug a guitar (or a microphone) into your audio interface and press ⇧F5: the Guitar rig loads Audio In → Scream → Delay → Reverb → Amp → Cabinet → Master. The Audio In unit picks any input by name, has a gain knob, a live level meter, a MON switch for monitoring through the rig, and a built-in tuner (note and cents) on its face. The stomps, amp and cabinet are the Guitarix LV2 plugins from the Plugins browser (install the Guitarix card). Monitoring goes through the same low-latency path as everything else; a missing input says so instead of falling back to the laptop microphone.
Every source gets its own channel strip: a fader in dB with a 0 dB detent (double-click for exact unity), a held peak and a clip light, plus pan, mute and solo. Each strip lists the effects on its cable chain as insert slots — add, bypass, reorder or remove them — and the master has inserts that run on the whole mix before the limiter. Every source and insert slot has a quick parameter knob beside it (defaulting to the plugin's first main control or an effect's mix; right-click to reassign, double-click to reset). Rename a strip, give it a colour, drag it to reorder or collapse it; names, colours and quick knob assignments are saved with the session.
Master to a loudness. Beside Master out, the Loudness column takes a
target: −14 LUFS (Spotify, YouTube, Tidal), −16 (Apple Music), −8 (club), or
any value in 1 LU steps. Play your loudest passage first; picking a target
then trims the level in front of the master limiter by what is missing, and
the true peak is held under −1 dBTP. The column shows the loudness before,
the loudness now, the true peak and the trim. Match measures what you
played since and corrects the trim; if the limiter has no more to give, the
readout says so and asks for more master VOLUME. The target is saved with
the session. The assistant and MCP agents do the same with
set_master_target and read the numbers with get_master_target.
Parallel paths stay in phase. When a signal splits and meets again, and one path runs through a unit that takes time (the Limiter waits 5 ms to catch peaks, and a hosted plugin reports its own latency: a look-ahead compressor, a linear-phase EQ), the other paths of that sound wait for it, so a dry sound and its processed copy add up cleanly instead of sounding hollow. Only paths that carry the same sound wait: a latent effect on the pad never makes the piano beside it late. When a plugin changes its latency while you play (you turn its look-ahead up), the paths are back in phase a moment later. A bypassed unit keeps its delay, so switching it in and out never shifts anything in time. A strip that sounds late says by how much, in milliseconds under its fader: what its plugins report plus what keeping it in phase adds.
+ Aux bus under the mixer's master strip adds a bus: a channel that nothing is cabled into. Every rig bus and every source strip gets a SENDS row for it. Turn the row's knob to send some of that signal to the bus (double-click: off or 0 dB) and click PRE to tap it before the strip's fader, so the send keeps its level when the fader moves. Put a reverb or a delay on the bus as an insert and several rigs share it. The bus has its own fader, pan, mute and solo and returns to the master past the rig faders; soloing it leaves only the returns. Right-click a send knob to bind it to a hardware controller, like the faders. Sends are saved with the session.
The backing track in your browser sits in the same mixer. Under System
audio every other app that is playing gets its own strip, named after the
app and what it plays, with a live meter, a volume fader and a mute button, so
you can turn YouTube down under your rig without leaving kabelsalat. At
Master out a menu lists your sound cards: pick your audio interface instead
of the laptop speakers and the sound moves there at once, without a dropout.
The choice is remembered for the next start, and System default hands the
sound back to the system's output. The assistant and MCP agents do the same
(list_app_streams, set_app_stream, list_audio_outputs,
set_audio_output). This needs PipeWire with its Pulse layer (pactl,
parec).
Every rig bus and every aux bus has an output menu under its name:
Master out, or one of your sound cards. A bus on its own card plays there
only and leaves the main mix. Put the metronome in a rig of its own and send
that rig's bus to the headphones, and the click never reaches the PA. For a
monitor mix, send your rigs pre-fader into an aux bus and give that bus the
headphones. The bus keeps its fader, pan, mute, solo and inserts. Up to four
cards besides the master's can play at once. The choice is saved with the
session. While its card is unplugged a bus is silent and its menu reads not
available; it never falls back to another output, and it plays again when
the card returns. A second card runs on its own clock, so a bus there can
arrive a few milliseconds apart from the master. The assistant and MCP agents
do the same (set_bus_output, get_bus_outputs). This needs PipeWire
(pw-cat, pactl).
One top bar holds the session, the rigs and the views. The session pill
on the left (● Untitled ▾, teal once saved) opens a small popover to save,
load or delete sessions and start from a template (Ctrl+O). While the
left rail is closed, the bar shows the rigs as compact pills: the active one
as 1 · Lead with a live level bar, the others as numbers with an activity
dot, and + adds a rig.
Press Q (or the rail button left of the session pill) to open the left rail. Its Rigs tab lists every rig with its MIDI input, level and a ⋯ menu (rename, save as or replace from a rig preset, MIDI input, delete), its channels in their mixer colours and their plugin chains (CLAP, LV2 and built-in); filter with ALL, CHANNELS and PLUGINS. Clicking an entry switches to that rig and selects the unit in the rack or scrolls and flashes its strip in the mixer. The Library tab keeps sessions, rig presets and starter templates in one place.
Beside your rigs, DSP shows how much of each audio buffer the engine needs
to render your rack. It turns amber from 70 % and red above 90 %, and counts
the dropouts (xruns) the sound card reported. Click it for Engine info:
sample rate and buffer, inputs and outputs, late blocks and xruns, the
latencies kabelsalat measures, and the render time of every instrument and
effect, most expensive first, so you see which unit to swap when the load
climbs. Adjust the audio Buffer size (64–2048 frames, default 256) live
with − / + in Engine info or from Settings → Audio — smaller lowers latency,
larger prevents xruns — and the choice is remembered across restarts. The
assistant and MCP agents read and adjust the same engine settings
(get_engine_info, set_buffer_size).
The MIDI matrix decides which keyboard plays which rig. Each connection can be shaped: only some keys (keyboard splits), another MIDI channel, transposed, or only loud notes.
The metronome follows the time signature you pick: beats per bar and the note that counts as one, under Settings → Session, or the chip on the metronome that steps through 4/4, 3/4, 6/8, 5/4, 7/8 and 2/4. The first beat of each bar clicks higher, the count-in lasts whole bars, and recording and a synced backing track start and stop on the bar lines of that signature. Plugins you host are told it too, and it is saved with the session.
Switch on MIDI Clock Send in the matrix view and kabelsalat becomes the master clock: 24 clocks per beat plus Start and Stop go to the MIDI outputs you wire (drum machines, synths) and to a virtual port other apps can connect to. A sync offset and three latency modes (none, output, input) line the clock up with what you hear.
Right-click any knob, turn a knob on your MIDI controller — bound. The knob shows its CC number and follows your hardware from then on.
The mixer learns the same way. Right-click a fader, a pan field, or a mute or solo button on a source strip, a rig bus or the master, then move a fader or press a button on your controller. A learned fader shows its CC beside the dB readout, and every learned control gets a blue outline. Mute and solo follow the button: on while it is latched (CC value 64 or more), off when it is released. Right-click a learned control to limit a fader's range, learn it again or clear it. The bindings are saved with the session and stay with their rig when you add or delete rigs.
A whole hardware instrument maps in one step with an instrument profile. Pick
it for the instrument's port in the MIDI matrix (Nord Electro 2, Akai EWI 4000s
and Akai EWI 5000 are built in; more are MIDI Guide CSV files in
~/.config/kabelsalat/instruments/): the Nord's drawbars, rotary switch,
percussion and drive move the organ, while an EWI forwards CC 2 breath as
channel pressure alongside CC 2 so both breath-CC and aftertouch wind patches
respond (and the EWI 5000 is matched automatically by its USB port name). The
assistant and MCP agents do the same with list_instrument_profiles and
set_device_instrument: "the Nord is on the second port".
REC records exactly what you hear into a WAV file in ~/Music/kabelsalat/.
After stopping you can play the take back or open its folder; SYNC starts
and stops the recording with the transport. For stems, press R on a rig's
bus strip in the mixer: every armed rig records its own post-fader WAV, named
after the rig, into the same take folder as the master mix (ARM under
Master out). Pressed while the transport rolls, REC starts and stops on the
next bar; stopping the transport keeps recording so reverb tails are not cut.
Ask the assistant (or an MCP agent) to play a WAV file and it mixes into the master like AUM's FilePlayer: loop restarts it seamlessly, sync plays it at the transport tempo from its original BPM (a "120 bpm" in the file name is picked up; speed changes, pitch follows, no time-stretch), beats sets the loop length in beats so an aligned loop never drifts off the metronome, and offset shifts the start. With sync on and the transport rolling, it starts on the next bar line.
The built-in assistant (bring your own OpenRouter key, entered under Settings → Agent → API key) can set things up for you: "add a reverb to this rig", "split the keys at C4", "load a warm pad". One key reaches every model: Settings → Agent → Models picks the chat model, the decisions model and the listening model, or takes any OpenRouter model id. While it works, the assistant says what it is doing ("Planning the next step · after Load sound"), and when it listens to your sound a bar shows how long it still records, in the dock, on the top bar's button and on the rack's hint line. Don't want it? Switch Assistant off on the same page and it leaves the top bar and the dock. Everything an agent changes lights up in the rack, and Ctrl+Z undoes the whole request in one step. External AI agents (Claude, …) can drive the running app through the built-in MCP server; the top bar shows when one is connected and pauses it with one click.
Press ? in the app for every shortcut.
AppImage (recommended) — download the latest release for your machine:
- kabelsalat-x86_64.AppImage (most PCs and laptops)
- kabelsalat-aarch64.AppImage (ARM: Raspberry Pi 4/5, Asahi, Snapdragon)
chmod +x kabelsalat-*.AppImage
./kabelsalat-*.AppImageOlder versions and the other packages are on the releases page.
Text fields read the keyboard directly, not through an input method. To
write Chinese, Japanese or Korean, start it with KABELSALAT_IME=1.
It runs unsandboxed, so it finds the CLAP/LV2 plugins installed on your system
and gets realtime audio priority like a native install. Install the plugins
from your distribution (surge-xt for the default synth).
Arch / Omarchy (builds the package with a launcher entry and icon):
git clone https://github.com/ssalentin/kabelsalat.git
cd kabelsalat/packaging
makepkg -siRecommended: surge-xt-clap (the default synth). Optional: dexed-clap,
lv2-plugins.
Flatpak / tarball — also attached to every release. The Flatpak runs in a
sandbox: no realtime audio priority yet and kabelsalat mcp --attach from the
host cannot reach it; see docs/PACKAGING.md.
From source — needs Rust (rustup), alsa-lib, lilv, and PipeWire or ALSA:
git clone https://github.com/ssalentin/kabelsalat.git
cd kabelsalat
cargo run --releasePull requests are welcome! Start with CONTRIBUTING.md and
issues labelled
good first issue
or help wanted.
Changes are listed in CHANGELOG.md; planned work is in the
issues and milestones, and
how it is built in docs/ARCHITECTURE.md.
- Engine: Rust, a lock-free and allocation-free render path on a realtime thread (rtkit), 256-frame buffer (≈ 5.3 ms at 48 kHz). Hardware MIDI reaches the engine from its own thread, so sound never waits for a UI frame. A zero-latency master limiter sits before the master saturation.
- Plugins: CLAP via clack (scanned out of process, so a crashing plugin cannot take the app down), LV2 via lilv on a loader thread. Plugin editors are native egui panels — no floating plugin windows.
- Graph and rigs: every rig is a graph of nodes and cables; rigs are merged
into one engine graph and mixed per rig. Routing changes always release held
notes first (checked exhaustively by the
verify-held-notestest). - UI: egui/eframe, physics-simulated cables, follows the Omarchy desktop theme, native fractional HiDPI.
- Agents:
kabelsalat mcp(headless) orkabelsalat mcp --attach(drives the running app) exposes the same control plane the UI uses — every UI action has an agent tool.kabelsalat send '<json>'is a one-shot CLI client. - Testing: a unit suite (
cargo test --bin kabelsalat) plus CLI self-tests that run real plugins (record-test,rig-mix-test,cc-map-test,transport-test, …).analysis-testchecks the engine by what it sounds like: a note's pitch, brightness and aliasing from its spectrum, the master's crackle, routing proven with noise, and delay compensation by cross-correlation. Rules learned from real bugs are kept in AGENTS.md. - Platforms: developed and tested on Asahi Linux (Arch, ARM64); x86_64 Linux builds the same way.
Kabelsalat is German for "cable salad" — the tangled mess behind every desk. This app turns it into something you want to look at.
- AUM (Kymatica) — the live workflow this brings to Linux
- Reason (Reason Studios) — the rack flip: front to play, back to patch
- GarageBand (Apple) — instant sound, no manual needed
- Surge XT — reference instrument
- clack, Maolan — Rust plugin hosting
- Element, Carla — the Linux hosts that showed the gap
MIT © Sebastian Salentin and contributors.
















