RushDAW 🎛️

A web-based DAW, inspired by BandLab, for writing songs, mixing, recording, and mastering. It's a Python package: the Python side runs a small local server, and the studio runs in your browser using the Web Audio API.

Installation

python3 -m pip install .          # from the source folder
# or, once it's on PyPI:
python3 -m pip install rushdaw

Start it:

rushdaw                 # opens http://localhost:8765 in your browser
rushdaw --port 9000 --no-browser
python3 -m rushdaw      # alternative

If port 8765 is busy: when RushDAW is already running there, rushdaw just opens it in the browser; when another program uses it, the next free port (8766, 8767, …) is used. With an explicit --port, a busy port gives a clear error instead.

ffmpeg is installed automatically through the imageio-ffmpeg dependency, so you don't need to install it yourself to export MP3/MP4.

Features

Keyboard shortcuts

Space play/stop · Ctrl/Cmd+Z undo · Ctrl/Cmd+Shift+Z (or Ctrl+Y) redo (also the ↶ Undo / ↷ Redo toolbar buttons; up to 100 steps per opened project, a whole slider/knob drag is one step, audio of undone recordings is kept; while typing in a text field the field's own undo is used) · Multiple selection: Shift/Ctrl/Cmd + click clips / regions to add or remove them (Ctrl/Cmd+A = every clip of the selected track); drag any selected clip to move them all; right-click → Merge (or Ctrl/Cmd+J) joins the selected regions of one track into one region – every pad / note stays exactly where it was, gaps stay empty; selected audio clips are mixed into one audio clip (gain and fades baked in); MCP: merge_regions · Ctrl/Cmd+C / X / V copy / cut / paste the selected clip(s), track (layer) or drum part – several clips keep their spacing and their tracks · R record · Home/Enter back to start · S split · Ctrl/Cmd+D duplicate · Delete remove clip · M metronome toggle · Fine grid: the ruler shows bar, beat and small grid ticks; with Snap on, moving / resizing regions and clips, multi-selection drags, ruler clicks and loop edges snap to the small ticks (1/16 note at normal zoom, 1/8 or 1/4 note when zoomed out – the current grid is shown next to Snap), so a region moves note by note instead of jumping; Snap off = free placement · Shift + drag on the ruler sets the loop region · double-click a Drum/Synth lane to add a pattern region.

Mute / solo. Muted tracks are silent. When any track is soloed, every soloed track plays and all other tracks are silent (shown dimmed in the track header, lane and mixer). Mute wins over solo. The same rule applies to playback, Download, export and MCP (get_project shows each track's audible). Download on the project list renders the last saved revision: each project card shows its saved mute / solo (e.g. "Solo: Drums, Bass · Muted: Guitar"), and the revision's mute/solo summary is stored in SQLite (revisions.mix, also in MCP list_projects / list_revisions). Choosing "Don't save" when leaving the editor discards unsaved mute / solo too.

Long notes are one note, never a loop. Lengthening a MIDI note (not drums) makes ONE longer note: guitar, bass and piano ring and decay naturally (the real recording, no loop – a held note dies away like the instrument); vocal/choir, strings and synths sustain evenly ("luuuuu", not "luu-luu-luu"): sustained recordings loop over their steadiest ~1.2–2.2 s section instead of a 0.5 s slice, rebuilt as a granular sustain: 120 ms grains taken at random places of the steadiest section, aligned to whole pitch periods, so the choir's own vowel drift no longer repeats every loop ("oooo", not "ou-ou-ou") and the level stays even, in playback and in Download/export, and detuned synth layers sit low enough not to beat.

One pitch = one voice. A note on a pitch ends where the next note of the same pitch starts and duplicates play once (piano roll, playback and MCP set_notes all follow this). Held ensemble recordings (choir, voice, strings) are auto-tuned per recording at load and never round-robin, so a sung note stays one voice.

MIDI regions are linear, not loops. Each MIDI region (drum, guitar, bass, synth) stores its own pads/notes for its whole length: a pad sounds exactly where it is placed and nothing repeats, so deleting one pad deletes only that pad. Extending a region (drag its right edge, Length in the Editor, or right-click → Extend by 1 empty bar) adds empty bars; shortening cuts the end. Both edges resize: drag the left edge to resize from the start (shrinking cuts the first steps, extending adds empty steps in front; every pad/note keeps its position in the song; audio clips reveal/hide the start of the recording). MCP: update_clip(trim_start_beats=…). Copy/paste, Ctrl/Cmd+D duplicate and S split create independent copies. The Editor shows the whole region with bar numbers (B1, B2, …), Region n/m · bar x with ◀ ▶, + Empty bar, ⧉ Duplicate region and Apply to all regions. Older projects are converted automatically (looping regions are written out once, so they sound the same).

Right-click menus. Right-click an empty spot of a lane: MIDI tracks → Add empty bar / 2 / 4 bars here, Add copy of the selected region here, Paste here; audio tracks → Add audio here (import file)…, Record here, Paste here. Right-click a region/clip → edit, extend / shorten by a bar, duplicate, split at playhead, delete. Double-clicking an empty spot of a MIDI lane also adds an empty bar.

Data storage

All data stays on your computer in ~/.rushdaw/ (change with rushdaw --home PATH or RUSHDAW_HOME):

~/.rushdaw/
├── db.sql                          # SQLite – important metadata only
└── file/
    └── <project_id>/
        ├── rev-0001.rushdaw        # full project snapshot (tracks, notes, FX, embedded audio)
        ├── rev-0002.rushdaw
        └── ...

• db.sql table projects: id, name, bpm, time signature, created/updated time, latest revision, deleted time (soft delete).
• db.sql table revisions: project, revision number, note, file name, size, SHA-256, track count, time.
• Project content (including audio) is not stored in the database. It lives in the .rushdaw files, written atomically.
• Deleting a project only moves it to the Trash. Its files and history stay on disk.

MCP (edit projects from an AI agent)

RushDAW includes an MCP server (Model Context Protocol) so AI assistants and agents can read and edit projects, tracks (layers), drum pads, notes and effects. The transport is HTTP + SSE only.

The API key is optional. Without --api-key MCP is off and the DAW works normally. To turn MCP on, start with a key (or set RUSHDAW_API_KEY):

rushdaw --api-key "my-secret-key"
# MCP:  http://localhost:8765/sse  (HTTP+SSE transport, header 'Authorization: Bearer <api key>')

• GET /sse opens the event stream. The first event, endpoint, gives the URL to post to: /messages?session_id=....
• POST /messages?session_id=... takes JSON-RPC messages and answers 202 Accepted. The responses arrive as message events on the SSE stream.
• Both endpoints require Authorization: Bearer <api key> (otherwise 401).

Example client config:

{
  "mcpServers": {
    "rushdaw": {
      "type": "sse",
      "url": "http://localhost:8765/sse",
      "headers": { "Authorization": "Bearer my-secret-key" }
    }
  }
}

Every MCP edit is saved as a new revision (MCP: … in History), so it can always be restored. An editor open in the browser reloads automatically when MCP changes the project. If you have unsaved changes, it shows a warning instead.

Uploading to PyPI

python3 -m pip install build twine
python3 -m build                 # creates dist/rushdaw-0.1.0.tar.gz and .whl
python3 -m twine check dist/*
python3 -m twine upload dist/*   # requires a PyPI API token

Bump version in pyproject.toml and src/rushdaw/__init__.py for every release. If the name rushdaw is already taken on PyPI, change name in pyproject.toml.

Development

python3 -m pip install -e .
python3 -m unittest discover -s tests

Architecture

• src/rushdaw/server.py – standard-library HTTP server (static UI + /api/export, /api/info)
• src/rushdaw/export.py – converts the WAV mixdown to other formats with ffmpeg
• src/rushdaw/storage.py – SQLite metadata + .rushdaw revision files
• src/rushdaw/model.py – server-side project model (mirrors the web UI data)
• src/rushdaw/mcp.py – MCP tools + JSON-RPC (served over HTTP+SSE by server.py, bearer auth)
• src/rushdaw/static/ – the DAW UI (HTML/CSS/JS, Web Audio engine, offline rendering for export)

Third-party sounds

The guitar, bass, piano, strings and choir recordings in src/rushdaw/static/samples/ come from the FluidR3_GM SoundFont by Frank Wen (MP3 renders from midi-js-soundfonts), licensed under Creative Commons Attribution 3.0. See src/rushdaw/static/samples/NOTICE.txt.

Vocal MIDI (voice: "hooo" / "haaa")

Click + Vocal MIDI to add a sung-voice layer played from the piano roll. Drag across pads to make one long, sustained note (same as guitar/bass).

• Presets: Choir Aah (default), Choir Ooh, Choir Ohh – real recorded choir (FluidR3_GM, sustain-looped for long notes); Solo Hoo, Solo Haa – single voice by formant synthesis (engine voice; no free solo-voice recordings). Older choir tracks are upgraded to the recordings automatically.
• Editor controls: Vowel (Aah / Eeh / Iih / Ohh / Ooh), Voices (1 = solo, 2-6 = choir), Breath, Vibrato, Attack, Decay, Sustain, Release.
• New track starts with the "Choir Space" effect chain (EQ, Chorus, Reverb), visible and editable in the Effects tab.
• New effect Vocal Formant (vowel a/e/i/o/u, formant shift, mix) turns any layer into an "aah"/"ooh" sound.
• MCP: add_track type=vocal, set_synth with engine: voice, vowel, voices, breath, vibrato; add_effect type=formant.

Natural drums: recorded kit, velocity and feel

• Drum tracks play a recorded acoustic kit (MuldjordKit, CC-BY 4.0): 3 velocity layers x 3 different hits per part, so repeated hits never sound identical. Editor → Kit: Acoustic (recorded) (default) or Synth kit. Tune / Decay / Volume per part still work.
• Velocity per pad and note: choose the velocity for new pads (Accent 100%, Normal 80%, Soft 60%, Ghost 30%); right-click or Alt+click a pad/note to cycle it. Softer pads are drawn dimmer and play a softer recording (ghost notes, accents).
• Feel per layer: Humanize (random timing in ms; drums add a drummer feel: snare slightly behind, hats slightly ahead), Swing, Push / lay back. New drum tracks start with Humanize 6 ms.
• MCP: set_drum_pads velocity (1-127), pattern strings x = 100%, o = soft, g = ghost, set_notes note velocity, update_track humanize_ms / swing / push_ms.

Development rule: UI and MCP stay in sync

Every feature that changes project data in the browser must also be available through MCP in the same change (Python model src/rushdaw/model.py + tool in src/rushdaw/mcp.py + a test). tests/test_mcp.py enforces it: ModelSyncTest compares presets / drum kit / constants between app.js and the Python model, and test_every_ui_clip_setting_has_an_mcp_param fails as soon as app.js writes a new clip/region field that has no MCP parameter.