diff --git a/.gitignore b/.gitignore
index 2269967..e50f305 100644
--- a/.gitignore
+++ b/.gitignore
@@ -89,4 +89,8 @@ backend/app/priors/grooves/*.json
 # Raw MIDI datasets must never be committed (song-transcription corpora are
 # copyrighted; keep the repo data-free).
 *.mid
-*.midi
\ No newline at end of file
+*.midi
+
+# Source WAVs downloaded by scripts/build_velocity_samples.py. Only the converted
+# MP3s under frontend/public/samples/ are committed; the bulky source cache is not.
+.sample-cache/
\ No newline at end of file
diff --git a/DATA_LICENSES.md b/DATA_LICENSES.md
index 626b7ba..cab8740 100644
--- a/DATA_LICENSES.md
+++ b/DATA_LICENSES.md
@@ -60,6 +60,36 @@ artifacts derived from permissively-licensed (CC-BY, public-domain) sources, and
   set bundled at `frontend/public/samples/piano/` (the Tone.js-hosted subset) is
   derived from this work. https://archive.org/details/SalamanderGrandPianoV3
 
+## Bundled instrument samples (`frontend/public/samples/`)
+
+These are the audio one-shots the app plays. Samples are **data**, licensed
+separately from the GPL-3.0 code. **Everything shipped now has a confirmed license:**
+
+| Set | Source | License | Notes |
+|---|---|---|---|
+| **Piano** (`piano/`) | Salamander Grand Piano (Alexander Holm) | **CC-BY 3.0** | Attributed above. Clean to ship. |
+| **Vibraphone** (`melodic/vibraphone/`) | **VCSL** — Versilian Community Sample Library | **CC0 / public domain** | Velocity-layered (soft/hard mallets) via `scripts/build_velocity_samples.py`. No attribution required; kept here as courtesy. https://github.com/sgossner/VCSL |
+
+Every other instrument is **synthesized** in the app (no shipped samples), so there is
+nothing else to license. A **Samples / Synth toggle** in the transport bar switches
+between the sampled voices above and full synthesis.
+
+> **Removed for licensing (2026-07-23).** The following sets were deleted because their
+> redistribution rights were **not confirmed** — see `docs/LICENSE_AUDIT.md`:
+> - **MusyngKite** (all `bass/` + 7 `melodic/` voices: electric pianos, clavinet,
+>   accordion, drawbar organ, nylon guitar, string ensemble). The redistributor labels
+>   it CC-BY-SA 3.0, but the soundfont's original author says it is "free to use but
+>   **not meant to be redistributed**… or used for commercial purposes." Those voices
+>   now synthesize.
+> - **Tone.js drum samples** (`drums/`). No LICENSE on the source repo; and the app
+>   already synthesizes its drum kit, so the samples were unused. Deleted.
+>
+> **Adding samples back cleanly:** use `scripts/build_velocity_samples.py` with a
+> confirmed **CC0 / public-domain** (VCSL) or **CC-BY** (with attribution) source only.
+> Note that University of Iowa MIS, despite being widely called "free," carries **no
+> explicit license grant**, so it is *not* used here. VCSL is acoustic/orchestral and
+> does not cover the electric/synth voices, which is why they remain synthesized.
+
 ## Note on the GPL and data
 
 The GPL-3.0 covers this project's source code. It does **not** attempt to license
diff --git a/docs/LICENSE_AUDIT.md b/docs/LICENSE_AUDIT.md
new file mode 100644
index 0000000..2c30380
--- /dev/null
+++ b/docs/LICENSE_AUDIT.md
@@ -0,0 +1,106 @@
+# License compliance audit — 2026-07-23
+
+A full pass over everything GenreGrid ships, to confirm we (a) respect third-party
+licenses and (b) correctly assert our own (GPL-3.0). Companion to
+[`DATA_LICENSES.md`](../DATA_LICENSES.md), which covers mined corpora and priors.
+
+**Scope:** bundled audio samples, frontend (npm) and backend (pip) dependencies,
+fonts/icons, and our own license declaration + source headers.
+
+---
+
+## Verdict
+
+| Area | Status |
+|---|---|
+| Our license declaration (GPL-3.0) | ✅ after fixing one metadata mismatch |
+| Frontend npm dependencies | ✅ all GPL-3.0-compatible |
+| Backend pip dependencies | ✅ all GPL-3.0-compatible |
+| Fonts | ✅ none bundled (system font stacks) |
+| Icons | ✅ first-party |
+| Piano samples | ✅ Salamander, CC-BY 3.0 (attributed) |
+| Vibraphone samples | ✅ VCSL, CC0 |
+| **Drum samples** | ✅ unconfirmed license + **unused** — deleted |
+| **Bass + melodic samples** | ✅ MusyngKite removed — those voices now synthesize |
+
+**Result: the app ships no asset with unconfirmed redistribution rights.** Remaining
+sampled voices are piano (CC-BY 3.0) and vibraphone (CC0); everything else synthesizes,
+toggleable via the transport bar's Samples / Synth control.
+
+---
+
+## 1. Our own license (GPL-3.0)
+
+- `LICENSE` at repo root is the full GPL-3.0 text. ✅
+- Every frontend `src/**/*.{ts,vue}` and backend `backend/app/**/*.py` file carries the
+  GPL header granting "version 3 … or (at your option) any later version." Only empty
+  `__init__.py` package markers lack it (no copyrightable content). ✅
+- **Mismatch (fixed):** `frontend/package.json` declared `"license": "GPL-3.0-only"`, but
+  the source headers grant **or-later**. Corrected to `GPL-3.0-or-later` so the metadata
+  matches the actual grant. The backend has no package metadata license field to set.
+
+## 2. Frontend dependencies (npm)
+
+49 production dependencies, by license: MIT (39), ISC (3), BSD-2-Clause (1),
+BSD-3-Clause (1), Apache-2.0 (1), 0BSD (1), BlueOak-1.0.0 (1), Python-2.0 (1). All are
+permissive and **GPL-3.0-compatible**. The only `UNLICENSED` entry is our own root
+package (`genregrid-frontend`), not a third party.
+
+Dev-only dependencies additionally include a few MPL-2.0 packages (build tooling); MPL-2.0
+is GPL-compatible and, regardless, dev tooling is **not distributed** in the packaged app.
+
+_Re-check: `cd frontend && npx license-checker-rseidelsohn --production --summary`._
+
+## 3. Backend dependencies (pip)
+
+fastapi, starlette, httpx (BSD-3), pydantic, mido, uvicorn, python-multipart, idna,
+pytest, pytest-asyncio (MIT/BSD). All permissive and **GPL-3.0-compatible**.
+
+## 4. Fonts & icons
+
+- **Fonts:** none bundled — the UI uses system font stacks, so nothing to license. ✅
+- **Icons:** `frontend/public/icon.{png,ico}` are first-party GenreGrid artwork. ✅
+
+## 5. Bundled audio samples
+
+Samples are **data**, licensed separately from the GPL code. Detail in
+[`DATA_LICENSES.md`](../DATA_LICENSES.md → "Bundled instrument samples").
+
+- ✅ **Piano** — Salamander Grand Piano, **CC-BY 3.0**, attributed.
+- ✅ **Vibraphone** — **VCSL, CC0**, velocity-layered (migrated 2026-07-23).
+- ✅ **Drums** (`samples/drums/`, 8 kits) — from Tone.js `audio` repo, which has **no
+  LICENSE file** (unconfirmed rights on vintage drum-machine samples). The app plays a
+  **synthesized** kit (`makeSynthKit`); `getDrumKit`/the sampled kits had **no callers**.
+  **Deleted** (dead weight — zero sound impact), along with the dead code.
+- ✅ **Bass** (6 sets) **+ Melodic** (7 sets: electric pianos, clavinet, accordion, drawbar
+  organ, nylon guitar, string ensemble) — from gleitz `midi-js-soundfonts` → **MusyngKite**.
+  The redistributor labels it CC-BY-SA 3.0, but the soundfont's original author states it is
+  "free to use but **not meant to be redistributed** … or used for commercial purposes" —
+  so our redistribution rights are **not confirmed**. **Deleted; those voices now synthesize.**
+
+### How the MusyngKite removal was done
+
+Goal: ship **no** MusyngKite-derived audio, achieved as follows:
+
+1. Deleted all MusyngKite sample sets. Sampled voices are gated behind confirmed-license
+   allowlists (`SAMPLED_VOICES`, `SAMPLED_BASS_VOICES`); voices not on them synthesize.
+2. Added a **Samples / Synth toggle** (`sampleMode`, persisted) so users can A/B the sampled
+   voices against full synthesis — and the seam a future "bring your own samples" feature uses.
+3. Removed `scripts/download_samples.py` (it only fetched the now-banned sources).
+
+**Sources considered and rejected for re-sourcing:**
+- **University of Iowa MIS** — widely called "free," but the site carries **no explicit
+  license grant** (same ambiguity as MusyngKite), so it is *not* used.
+- **Freesound** — many CC0 samples exist, but the API requires auth unavailable in the
+  automation environment; a manual, per-sample CC0 curation pass remains a future option.
+
+Confirmed-clean, direct-download sources that *were* usable: **VCSL (CC0)** and **Salamander
+(CC-BY)** — which only cover piano + vibraphone among GenreGrid's voices.
+
+---
+
+## Maintenance
+
+Re-run this audit when adding any dependency, sample set, font, or icon. Never bundle audio
+without a confirmed CC0 / public-domain / CC-BY (with attribution) license. Keep the repo
+free of any asset whose redistribution rights are unconfirmed.
diff --git a/docs/custom-instruments-design.md b/docs/custom-instruments-design.md
new file mode 100644
index 0000000..ef8ebaa
--- /dev/null
+++ b/docs/custom-instruments-design.md
@@ -0,0 +1,156 @@
+# Design: User-uploaded custom instruments
+
+**Status (2026-07-23): MVP IMPLEMENTED (needs desktop runtime testing).** Design for
+letting users add their own samples, map them to notes/velocities, and pick which
+instrument plays each part. Fleshes out the Phase 2 roadmap item "Custom soundfont /
+SF2 upload + per-part instrument picker."
+
+**Shipped (T1 + T2 tier):** pure mapping core (`customInstruments.ts`, unit-tested),
+library store (`useCustomInstruments.ts`), Electron storage IPC + preload (list/save/
+remove/read under `userData/instruments/`, played back as blob: URLs — no custom
+scheme, per the Linux Web-Audio note below), engine integration (every part resolves a
+custom instrument first in `useMidiPlayer.ts`), and the Instruments panel UI + a 🎹
+transport-bar button. **Not yet done:** velocity-layer preview, SF2/SFZ import (T4),
+auto pitch-detection, per-style-override UI, web/OPFS storage. **Untested at runtime**
+(automation can't launch Electron / play audio) — needs a desktop pass: import a file,
+assign it to a part, play, and delete.
+
+## Why now
+
+The July 2026 license pass removed the MusyngKite bass/melodic samples, so 13 voices
+now synthesize (see [`LICENSE_AUDIT.md`](LICENSE_AUDIT.md)). Letting users bring their
+own samples both restores instrument realism **and sidesteps the licensing problem** —
+user-supplied audio is the user's to use, nothing we ship. It also builds directly on
+the two seams already in place: the `LayeredSampler` **manifest format** and the
+**registry** (`voiceFor(styleId, part)`) that resolves each part to a voice id.
+
+## Core concept
+
+> A **Custom Instrument** is just a `LayeredSampler` manifest + its audio files, given a
+> voice id, that the user can select for any part.
+
+**Every part/voice is user-samplable — no exceptions.** Chords, melody, arpeggio, bass,
+pads, and counter-melody can each be driven by a user instrument, including the voices
+that currently synthesize. There is no "these are sampled, those are synth-only" split at
+the user level: the per-part picker offers a user instrument for *any* part, and a user
+instrument can replace a built-in voice entirely. (Custom drum *kits* use a pitch→one-shot
+mapping rather than a chromatic range, so they get a dedicated editor in a later phase, but
+they are still in scope as user-uploadable.)
+
+Nothing new in the audio engine — `LayeredSampler` already plays a `velocity.json`
+manifest (note → file(s), velocity layers, round-robins). A custom instrument is that
+same structure, sourced from user files instead of `/samples/`. The registry's job
+("what voice does this part use?") gains a third answer: built-in sample set, synth
+family, **or a user instrument**.
+
+---
+
+## Key decisions (with options + recommendation)
+
+### 1. Upload format & note mapping — *how do files become a playable instrument?*
+
+The hard part of "easy and manageable" is note/velocity mapping. Recommend a **tiered**
+approach so the easy case is trivial and quality scales up, all producing one manifest:
+
+| Tier | User does | We do | For |
+|---|---|---|---|
+| **T1 — one shot** | Drop **one** audio file | Map it across the keyboard, pitch-shifted (single-zone `Tone.Sampler`) | Casual: "make an instrument from this sound" |
+| **T2 — named files** | Drop files named by note (`C4.wav`, `A#3.wav`, `Fs3…`) | Parse note from filename → multi-zone manifest | Better realism, minimal effort |
+| **T3 — velocity/RR** | Files with velocity/RR suffix or in `soft/`,`hard/` subfolders (our pipeline's convention) | Build layered manifest | Full dynamics — matches `build_velocity_samples.py` output |
+| **T4 — soundfont** | Upload `.sf2` / `.sfz` | Parse zones/velocity splits → manifest (+ decode samples) | Import existing libraries |
+
+- **Recommendation:** ship **T1 + T2** as the MVP (covers "easy and manageable" and
+  reuses the manifest 1:1), then **T3** (already produced by our own pipeline), then
+  **T4** last (SF2/SFZ parsing is the heaviest — needs a parser + sample decode; SFZ is
+  text-simple, SF2 is binary and benefits from a lib like `soundfont2`).
+- A drag-drop **zip or folder** import wraps T2/T3 (one gesture, many files).
+- **Optional polish:** auto pitch-detection (detect fundamental) to relax the filename
+  requirement in T1/T2 — nice, not required for MVP.
+
+### 2. Assignment model — *which instrument belongs to which part?*
+
+- **Option A — Instrument-first (recommended):** the user creates a named, reusable
+  instrument ("My Rhodes") in a library, then assigns it to parts via a **per-part
+  instrument picker**. One instrument, usable across styles/parts.
+- **Option B — Part-first:** the user opens a part ("Bass") and uploads for it directly.
+  Simpler mental model but not reusable; leads to re-uploading the same sound per style.
+- **Recommendation: A.** It matches the registry (voices are reusable identities) and
+  makes the per-part picker a pure selection surface. The picker for each part
+  (chords / melody / arpeggio / bass / pads / counter-melody) offers: **Synth · Built-in
+  sample · [user instruments…]**, extending today's `sampleMode` toggle from a global
+  2-way switch into a per-part source choice.
+
+### 3. Storage & serving — *where do the files live and how does Tone load them?*
+
+Uploaded audio is **user data**, never bundled. `Tone.Sampler` needs a fetchable URL.
+
+- **Electron (primary):** store under `app.getPath('userData')/instruments/<id>/` with a
+  `manifest.json` per instrument + a top-level `index.json`. Serve to the renderer via a
+  **custom protocol** (`protocol.handle('gginstr', …)`) → stable, cacheable URLs
+  (`gginstr://<id>/<file>`) that `LayeredSampler` fetches like `/samples/…`. Cleaner than
+  IPC-read → object URLs, and respects `contextIsolation` + CSP (add the scheme to CSP).
+- **Web build (fallback):** **OPFS** (Origin Private File System) for the bytes + object
+  URLs, or IndexedDB blobs. Same manifest shape.
+- **Recommendation:** custom protocol in Electron; OPFS in the browser. Both hand
+  `LayeredSampler` a URL, so the engine is storage-agnostic.
+
+### 4. Persistence of assignments
+
+A small user settings object (persisted like `sampleMode`): a default per-part
+instrument map, with optional per-style overrides. Resolution order at play time:
+**per-style user override → global user default → registry `voiceFor` → synth fallback.**
+
+---
+
+## Data model
+
+```ts
+interface CustomInstrument {
+  id: string            // uuid; also the voice id and storage folder
+  name: string          // "My Rhodes"
+  kind: 'melodic' | 'bass' | 'drums'
+  manifest: LayeredSamplerManifest   // note → file(s), velocity layers, RR
+  createdAt: number
+}
+// index.json: CustomInstrument[] (without the audio bytes)
+
+interface InstrumentAssignments {
+  defaults: Partial<Record<PlayerPart, string>>              // part → instrument id
+  perStyle?: Record<string /*styleId*/, Partial<Record<PlayerPart, string>>>
+}
+```
+
+## Integration points (all already exist)
+
+- **Engine:** `LayeredSampler` (`layeredSampler.ts`) — unchanged; loads a user manifest
+  by base URL. `loadLayeredSampler` already fetches `velocity.json`; a user instrument
+  supplies the same shape.
+- **Resolution:** extend the `voiceFor(...)` consumers in `useMidiPlayer.ts` to first
+  consult `InstrumentAssignments`, then fall through to the registry, then synth.
+- **Mode:** generalize `sampleMode` (`useMidiPlayer.ts`) — 'synth' | 'samples' stays as
+  the global default; the per-part picker overrides it per part.
+- **UI:** a new **Instruments** drawer/panel (library CRUD + upload + mapping preview)
+  and a compact per-part picker on `PartCard.vue` / the transport.
+- **Electron:** custom protocol registration + an IPC surface for import/list/delete
+  (reuse the `save-temp-file` basename-hardening pattern for uploaded filenames).
+
+## Phased delivery
+
+1. **MVP** — Instruments library (list/add/delete) + T1 (one-shot) & T2 (note-named)
+   import + Electron protocol storage + per-part picker wired into playback. Piano/
+   vibraphone remain the built-in sampled voices; users fill the rest.
+2. **Velocity layers (T3)** + a light mapping preview (mini keyboard, hear each zone).
+3. **SF2/SFZ import (T4)** — start with SFZ (text), then SF2 via a parser.
+4. **Polish** — auto pitch-detection, per-style overrides UI, export/share an instrument
+   as a zip (round-trips with `build_velocity_samples.py` output).
+
+## Open questions / risks
+
+- **Formats to accept:** wav/mp3/ogg/flac? (Web Audio decodes all; storage size varies —
+  maybe transcode-to-ogg on import to bound footprint.)
+- **CSP:** the custom scheme must be allowed for media without weakening the existing
+  localhost-only policy.
+- **Large libraries:** memory/CPU if a user loads many big multisamples — lazy-load per
+  style, cap total decoded buffers.
+- **Drums:** custom drum *kits* map pitch→one-shot, not a chromatic range — likely a
+  separate, later editor from the melodic flow.
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 926338b..6d51396 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -3,9 +3,11 @@
 A living, prioritized roadmap from the July 2026 project survey. Check items off as
 they land; add new findings under the right phase so nothing gets lost.
 
-**Status legend:** `[ ]` todo · `[~]` in progress · `[x]` done · `[-]` won't do / obsolete
+**Status legend:** `[ ]` todo · `[~]` in progress · `[x]` done · `[-]` won't do / obsolete ·
+`[→]` moved to another phase
 
-_Last updated: 2026-07-23 — Phase 1 complete (see Done log)._
+_Last updated: 2026-07-23 — Phase 1 complete; Phase 2 nearly done (limiter, per-style FX,
+loudness norm, velocity-layer engine landed; multi-velocity sample sourcing open)._
 
 ---
 
@@ -43,17 +45,61 @@ _Last updated: 2026-07-23 — Phase 1 complete (see Done log)._
 
 ## Phase 2 — Sound polish
 
-- [ ] **Master bus glue/limiting** — master is a unity `Gain` (a `DynamicsCompressor`
-  renders silence on Linux Electron), so a full arrangement can peak/clip with nothing
-  catching it. Add a Linux-safe JS soft-clip / look-ahead limiter.
-  → `frontend/src/soundfonts/loader.ts:39`
-- [ ] **Velocity layers / round-robins in sample sets** — ~4 MB total, ~one mp3 per
-  note-zone; wide pitch-shifting sounds synthetic. More velocity layers = fastest
-  realism gain. → `frontend/public/samples/`
-- [ ] **Loudness normalization across styles** — target an LUFS level per style so
-  perceived volume doesn't jump between styles.
-- [ ] **Per-style FX presets** — reverb/chorus/delay are currently shared and fixed.
-  → `frontend/src/soundfonts/loader.ts` (buses)
+- [x] **Master bus glue/limiting** — added a Linux-safe soft-clip limiter on the master:
+  a `WaveShaper` (static transfer curve, not a `DynamicsCompressor` — that renders silence
+  on Linux Electron) that's transparent below −4.4 dBFS, bends through a gentle quadratic
+  knee, and holds peaks under a −0.13 dBFS ceiling. Wired into all three master paths (live
+  `masterOut → limiter → dest`, offline WAV render, and the live MediaRecorder tap now reads
+  post-limiter). New pure-math unit tests cover the transfer curve.
+  → `frontend/src/soundfonts/loader.ts` (`makeMasterLimiter`), `useMidiPlayer.ts`
+- [~] **Velocity layers / round-robins in sample sets** — _engine done + vibraphone; broad
+  sample coverage gated on finding confirmed-CC0 sources._ Built `LayeredSampler`
+  (`layeredSampler.ts`): a drop-in over `Tone.Sampler` that plays a different sample per
+  velocity range (real dynamics, not just gain) + cycles round-robins, driven by a per-instrument
+  `velocity.json` manifest. Backward-compatible; wired into the piano/bass/melodic loaders (offline
+  WAV path is synth-only, untouched). Reproducible pipeline (`scripts/build_velocity_samples.py`,
+  `soundfile`+`lameenc`) fetches CC0 WAVs → trimmed mono mp3 + manifest. **Vibraphone** migrated
+  to VCSL CC0 (soft/hard layers). Broad coverage is blocked because no confirmed-CC0 library
+  covers the electric/synth voices — see the licensing work below.
+  → `frontend/src/soundfonts/layeredSampler.ts`, `scripts/build_velocity_samples.py`
+- [x] **License compliance pass** (added scope) — full audit (`docs/LICENSE_AUDIT.md`) of samples,
+  npm + pip deps, fonts/icons, and our own GPL declaration. Findings/fixes: deps all
+  GPL-3.0-compatible; fixed `package.json` `GPL-3.0-only`→`-or-later` to match the source headers;
+  **removed all MusyngKite-derived samples** (ambiguous license) and the unused/unlicensed Tone.js
+  drum samples. Those voices now synthesize. Added a **Samples / Synth toggle** (`sampleMode`,
+  persisted) in the transport bar to A/B sampled vs synth — the seam a future "bring your own
+  samples" feature plugs into. Net: the app ships no asset with unconfirmed redistribution rights.
+- [x] **Loudness normalization across styles** — per-family master trim (`MASTER_TRIM_DB`)
+  applied on the pre-limiter master when a style starts, so perceived volume doesn't jump
+  between genres (hot electronic mixes pulled down, sustained pads nudged up). Ramped, not
+  stepped. A true per-style LUFS target would need offline measurement; these are hand-tunable
+  starting points. → `frontend/src/soundfonts/fxPresets.ts`, `loader.ts` (`setMasterTrimDb`)
+- [x] **Per-style FX presets** — the shared melodic-bus chorus/delay + reverb are retuned
+  per style family (`MELODIC_FX_PRESETS`) instead of being fixed: ambient/cinematic get a long
+  lush tail, electronic more movement, trap/drill tight & dry, lo-fi wobbly. Applied live by
+  mutating the shared nodes' params; the reverb IR is only regenerated when decay changes.
+  → `frontend/src/soundfonts/fxPresets.ts`, `loader.ts` (`applyMelodicFxPreset`)
+- [ ] **Re-source clean samples for the synth-only voices** — after the July 2026 license
+  pass, 13 voices (all 6 basses + Rhodes/DX7/clavinet/accordion/drawbar organ/nylon guitar/
+  string ensemble) synthesize because their MusyngKite samples were removed. Restore real
+  samples from **confirmed CC0 / CC-BY** sources only, via `scripts/build_velocity_samples.py`
+  (add each voice id to `SAMPLED_VOICES` / `SAMPLED_BASS_VOICES`). Blocked on sourcing: VCSL
+  (CC0) doesn't cover them, and Iowa MIS has no explicit license; a manual Freesound-CC0
+  curation pass (needs API auth) or another PD library is required. Prioritize the **basses**
+  (most audible downgrade). The engine + Samples/Synth toggle already support them the moment
+  a legal set + `velocity.json` exists. → `docs/LICENSE_AUDIT.md`, `DATA_LICENSES.md`
+- [~] **User-uploaded custom instruments** (SF2/samples) + per-part instrument picker
+  _(promoted from Phase 4; MVP built, needs desktop runtime testing)_ — users add their own
+  samples, mapped to notes/velocities, and pick which instrument plays **each** part; also
+  sidesteps the licensing gap above (user audio is theirs). Design + status in
+  **[`custom-instruments-design.md`](custom-instruments-design.md)**. **Shipped (T1 one-shot +
+  T2 note-named tiers):** pure mapping core (`customInstruments.ts`, +15 tests), library store
+  (`useCustomInstruments.ts`), Electron storage IPC (`userData/instruments/`, played as blob:
+  URLs — no custom scheme, avoids the Linux Web-Audio silence bug), per-part resolution in
+  `useMidiPlayer.ts`, and the Instruments panel + 🎹 transport button. **TODO:** runtime-test on
+  desktop (import/assign/play/delete), then velocity-layer preview, SF2/SFZ import (T4), auto
+  pitch-detection, per-style overrides, web/OPFS storage.
+  → `soundfonts/customInstruments.ts`, `composables/useCustomInstruments.ts`, `components/InstrumentsPanel.vue`, `electron/main.ts`
 
 ## Phase 3 — Performance & refactor
 
@@ -77,7 +123,7 @@ _Last updated: 2026-07-23 — Phase 1 complete (see Done log)._
   frontend control yet. Low effort.
 - [ ] **Non-4/4 time signatures** (6/8, 3/4, 7/8) — currently hardcoded `numerator=4`.
   → `backend/app/services/midi_writer.py:162`
-- [ ] **Custom soundfont / SF2 upload** + per-part instrument picker.
+- [→] **Custom soundfont / SF2 upload** — _promoted to Phase 2 (Sound polish)._
 - [ ] **Surface WAV/offline-audio export more prominently** — already implemented
   (OfflineAudioContext + render queue); just under-discovered.
 - [ ] **Tempo automation & mid-song modulation** — partial today (`chorus_key_shift`).
@@ -98,5 +144,31 @@ _Last updated: 2026-07-23 — Phase 1 complete (see Done log)._
   - Tests: +3 (traversal rejection, CORS allow/deny). Suite 131→134 green; ruff clean;
     frontend `vue-tsc` + vitest clean.
 
-**Phase 1 complete.** Next up: Phase 2 (sound polish) — master limiter is the natural
-first step and pairs well with the now-local piano.
+- **2026-07-23 — Phase 2 sound polish (in progress):**
+  - Master soft-clip limiter added (Linux-safe `WaveShaper`, not a `DynamicsCompressor`):
+    transparent below −4.4 dBFS, gentle quadratic knee, hard ceiling at −0.13 dBFS.
+    Applied consistently across live playback, the offline WAV/stem render, and the live
+    MediaRecorder export (which now taps the post-limiter node). Tests: +5 (transfer-curve
+    math).
+  - **Per-style FX presets** + **cross-style loudness normalization** landed. Shared melodic
+    FX (chorus/delay/reverb) retuned per style family; pre-limiter master trimmed per family
+    so genres sit at an even level. Applied when a style starts. Tests: +4.
+  - **Velocity-layer / round-robin infrastructure** landed: `LayeredSampler`, a manifest-driven
+    (`velocity.json`), backward-compatible drop-in for `Tone.Sampler`, wired into all three live
+    sample loaders. Tests: +8. Reproducible sample pipeline added
+    (`scripts/build_velocity_samples.py`). **Vibraphone** migrated to VCSL CC0 with soft/hard
+    velocity layers (superseding the ambiguously-licensed MusyngKite set).
+  - **License compliance pass** (`docs/LICENSE_AUDIT.md`): audited samples, npm/pip deps,
+    fonts/icons, and our own GPL declaration. Deps all GPL-compatible. Fixed `package.json`
+    license (`GPL-3.0-only`→`-or-later`). **Removed all MusyngKite samples** (ambiguous
+    license) + unused/unlicensed Tone.js drum samples + dead `getDrumKit` code + the
+    `download_samples.py` fetcher. Removed voices synthesize; added a persisted **Samples /
+    Synth toggle** in the transport bar. Iowa MIS was evaluated and rejected (no explicit
+    license). Net: no shipped asset has unconfirmed redistribution rights.
+  - Frontend suite 12→29 green; `vue-tsc` + eslint + production build clean.
+
+**Phase 1 complete.** Phase 2 (sound polish) mostly done: limiter, per-style FX, loudness
+normalization, the velocity-layer engine, and the license compliance pass all landed.
+**Open Phase 2 items:** re-source clean samples for the 13 synth-only voices (basses first),
+and custom soundfont / SF2 upload (promoted from Phase 4) — both now tracked as explicit
+items above.
diff --git a/frontend/electron/main.ts b/frontend/electron/main.ts
index b5ce47b..98f92de 100644
--- a/frontend/electron/main.ts
+++ b/frontend/electron/main.ts
@@ -406,6 +406,69 @@ ipcMain.handle('log-renderer-error', async (_, entry: { timestamp: string; conte
   }
 })
 
+// ── Custom instrument storage ────────────────────────────────────────────────
+// User-uploaded instruments live under userData/instruments/: an index.json listing
+// each instrument (id, name, kind, LayeredSampler manifest) plus a per-id folder of
+// audio files. The renderer reads bytes back via 'instruments-read' and plays them as
+// blob: URLs (see useCustomInstruments.ts) — deliberately no custom URL scheme, which
+// the Linux Web Audio path renders silent. See docs/custom-instruments-design.md.
+interface StoredInstrument { id: string; name: string; kind: string; manifest: unknown; createdAt: number }
+
+function instrumentsDir(): string {
+  const dir = path.join(app.getPath('userData'), 'instruments')
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+function readInstrumentIndex(): StoredInstrument[] {
+  try { return JSON.parse(fs.readFileSync(path.join(instrumentsDir(), 'index.json'), 'utf-8')) } catch { return [] }
+}
+function writeInstrumentIndex(list: StoredInstrument[]): void {
+  fs.writeFileSync(path.join(instrumentsDir(), 'index.json'), JSON.stringify(list, null, 2))
+}
+// Resolve a renderer-supplied relative file name strictly within `baseDir`, rejecting
+// any traversal/absolute path that would escape it.
+function safeJoinWithin(baseDir: string, rel: string): string {
+  const resolved = path.resolve(baseDir, rel)
+  if (resolved !== baseDir && !resolved.startsWith(baseDir + path.sep)) throw new Error('unsafe path')
+  return resolved
+}
+
+ipcMain.handle('instruments-list', async () => readInstrumentIndex())
+
+ipcMain.handle('instruments-save', async (_, { inst, files }: { inst: StoredInstrument; files: Array<{ name: string; data: number[] }> }) => {
+  const id = path.basename(String(inst.id))   // our own uuid; basename defends regardless
+  const dir = path.join(instrumentsDir(), id)
+  for (const f of files) {
+    const dest = safeJoinWithin(dir, f.name)
+    await fs.promises.mkdir(path.dirname(dest), { recursive: true })
+    await fs.promises.writeFile(dest, Buffer.from(f.data))
+  }
+  const index = readInstrumentIndex().filter(i => i.id !== id)
+  index.push({ ...inst, id })
+  writeInstrumentIndex(index)
+})
+
+ipcMain.handle('instruments-remove', async (_, id: string) => {
+  const safeId = path.basename(String(id))
+  await fs.promises.rm(path.join(instrumentsDir(), safeId), { recursive: true, force: true })
+  writeInstrumentIndex(readInstrumentIndex().filter(i => i.id !== safeId))
+})
+
+ipcMain.handle('instruments-read', async (_, id: string) => {
+  const safeId = path.basename(String(id))
+  const dir = path.join(instrumentsDir(), safeId)
+  const out: Array<{ name: string; data: number[] }> = []
+  async function walk(rel: string): Promise<void> {
+    for (const entry of await fs.promises.readdir(path.join(dir, rel), { withFileTypes: true })) {
+      const childRel = rel ? path.join(rel, entry.name) : entry.name
+      if (entry.isDirectory()) await walk(childRel)
+      else out.push({ name: childRel.split(path.sep).join('/'), data: [...await fs.promises.readFile(path.join(dir, childRel))] })
+    }
+  }
+  try { await walk('') } catch { /* no such instrument */ }
+  return out
+})
+
 // Build a 32×32 solid purple drag icon from raw RGBA pixels
 function makeDragIcon(): ReturnType<typeof nativeImage.createFromBuffer> {
   const size = 32
diff --git a/frontend/electron/preload.ts b/frontend/electron/preload.ts
index acddcf1..7f65bde 100644
--- a/frontend/electron/preload.ts
+++ b/frontend/electron/preload.ts
@@ -38,4 +38,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // the in-app error log panel.
   logRendererError: (entry: { timestamp: string; context: string; message: string; stack?: string }): Promise<void> =>
     ipcRenderer.invoke('log-renderer-error', entry),
+
+  // User custom-instrument storage under userData/instruments/ (see
+  // useCustomInstruments.ts + docs/custom-instruments-design.md).
+  instruments: {
+    list: () => ipcRenderer.invoke('instruments-list'),
+    save: (inst: unknown, files: Array<{ name: string; data: number[] }>) =>
+      ipcRenderer.invoke('instruments-save', { inst, files }),
+    remove: (id: string) => ipcRenderer.invoke('instruments-remove', id),
+    read: (id: string) => ipcRenderer.invoke('instruments-read', id),
+  },
 })
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 7664592..37ee4ad 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -7,7 +7,7 @@
     "": {
       "name": "genregrid-frontend",
       "version": "0.1.0",
-      "license": "GPL-3.0-only",
+      "license": "GPL-3.0-or-later",
       "dependencies": {
         "@tonejs/midi": "^2.0.28",
         "electron-updater": "^6.8.9",
diff --git a/frontend/package.json b/frontend/package.json
index b07462b..a9abbe5 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -2,7 +2,7 @@
   "name": "genregrid-frontend",
   "private": true,
   "version": "0.1.0",
-  "license": "GPL-3.0-only",
+  "license": "GPL-3.0-or-later",
   "description": "Genregrid — A Midi Loop Generator",
   "author": {
     "name": "TwDover",
diff --git a/frontend/public/samples/bass/acoustic_bass/A1.mp3 b/frontend/public/samples/bass/acoustic_bass/A1.mp3
deleted file mode 100644
index 7d90a78..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/A2.mp3 b/frontend/public/samples/bass/acoustic_bass/A2.mp3
deleted file mode 100644
index c3a3243..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/A3.mp3 b/frontend/public/samples/bass/acoustic_bass/A3.mp3
deleted file mode 100644
index ae751fe..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/C2.mp3 b/frontend/public/samples/bass/acoustic_bass/C2.mp3
deleted file mode 100644
index 21f94f2..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/C3.mp3 b/frontend/public/samples/bass/acoustic_bass/C3.mp3
deleted file mode 100644
index 25aa8f8..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/E2.mp3 b/frontend/public/samples/bass/acoustic_bass/E2.mp3
deleted file mode 100644
index 033fe66..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/E3.mp3 b/frontend/public/samples/bass/acoustic_bass/E3.mp3
deleted file mode 100644
index 1f09a78..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/G2.mp3 b/frontend/public/samples/bass/acoustic_bass/G2.mp3
deleted file mode 100644
index d18ae06..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/acoustic_bass/G3.mp3 b/frontend/public/samples/bass/acoustic_bass/G3.mp3
deleted file mode 100644
index 0783685..0000000
Binary files a/frontend/public/samples/bass/acoustic_bass/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/A1.mp3 b/frontend/public/samples/bass/electric_bass_finger/A1.mp3
deleted file mode 100644
index 16aedc4..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/A2.mp3 b/frontend/public/samples/bass/electric_bass_finger/A2.mp3
deleted file mode 100644
index d93d8ed..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/A3.mp3 b/frontend/public/samples/bass/electric_bass_finger/A3.mp3
deleted file mode 100644
index 3f30f7d..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/C2.mp3 b/frontend/public/samples/bass/electric_bass_finger/C2.mp3
deleted file mode 100644
index 139ce21..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/C3.mp3 b/frontend/public/samples/bass/electric_bass_finger/C3.mp3
deleted file mode 100644
index 4a7075b..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/E2.mp3 b/frontend/public/samples/bass/electric_bass_finger/E2.mp3
deleted file mode 100644
index 0a366c3..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/E3.mp3 b/frontend/public/samples/bass/electric_bass_finger/E3.mp3
deleted file mode 100644
index 3ed9e69..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/G2.mp3 b/frontend/public/samples/bass/electric_bass_finger/G2.mp3
deleted file mode 100644
index 56de683..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_finger/G3.mp3 b/frontend/public/samples/bass/electric_bass_finger/G3.mp3
deleted file mode 100644
index 664eb9d..0000000
Binary files a/frontend/public/samples/bass/electric_bass_finger/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/A1.mp3 b/frontend/public/samples/bass/electric_bass_pick/A1.mp3
deleted file mode 100644
index 718561e..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/A2.mp3 b/frontend/public/samples/bass/electric_bass_pick/A2.mp3
deleted file mode 100644
index 272b60c..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/A3.mp3 b/frontend/public/samples/bass/electric_bass_pick/A3.mp3
deleted file mode 100644
index 6287961..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/C2.mp3 b/frontend/public/samples/bass/electric_bass_pick/C2.mp3
deleted file mode 100644
index 73902c5..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/C3.mp3 b/frontend/public/samples/bass/electric_bass_pick/C3.mp3
deleted file mode 100644
index 72fd2ce..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/E2.mp3 b/frontend/public/samples/bass/electric_bass_pick/E2.mp3
deleted file mode 100644
index 5bf9ad5..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/E3.mp3 b/frontend/public/samples/bass/electric_bass_pick/E3.mp3
deleted file mode 100644
index f7b4819..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/G2.mp3 b/frontend/public/samples/bass/electric_bass_pick/G2.mp3
deleted file mode 100644
index 8c27abe..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/electric_bass_pick/G3.mp3 b/frontend/public/samples/bass/electric_bass_pick/G3.mp3
deleted file mode 100644
index 9fafcaa..0000000
Binary files a/frontend/public/samples/bass/electric_bass_pick/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/A1.mp3 b/frontend/public/samples/bass/fretless_bass/A1.mp3
deleted file mode 100644
index 533a827..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/A2.mp3 b/frontend/public/samples/bass/fretless_bass/A2.mp3
deleted file mode 100644
index c687dcc..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/A3.mp3 b/frontend/public/samples/bass/fretless_bass/A3.mp3
deleted file mode 100644
index 6393d5e..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/C2.mp3 b/frontend/public/samples/bass/fretless_bass/C2.mp3
deleted file mode 100644
index 78105de..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/C3.mp3 b/frontend/public/samples/bass/fretless_bass/C3.mp3
deleted file mode 100644
index 0a27822..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/E2.mp3 b/frontend/public/samples/bass/fretless_bass/E2.mp3
deleted file mode 100644
index c6933cc..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/E3.mp3 b/frontend/public/samples/bass/fretless_bass/E3.mp3
deleted file mode 100644
index f2f2c6a..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/G2.mp3 b/frontend/public/samples/bass/fretless_bass/G2.mp3
deleted file mode 100644
index 4cf3e62..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/fretless_bass/G3.mp3 b/frontend/public/samples/bass/fretless_bass/G3.mp3
deleted file mode 100644
index e7be869..0000000
Binary files a/frontend/public/samples/bass/fretless_bass/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/A1.mp3 b/frontend/public/samples/bass/slap_bass_1/A1.mp3
deleted file mode 100644
index 7a33064..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/A2.mp3 b/frontend/public/samples/bass/slap_bass_1/A2.mp3
deleted file mode 100644
index ead0e73..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/A3.mp3 b/frontend/public/samples/bass/slap_bass_1/A3.mp3
deleted file mode 100644
index 82ad171..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/C2.mp3 b/frontend/public/samples/bass/slap_bass_1/C2.mp3
deleted file mode 100644
index 543db64..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/C3.mp3 b/frontend/public/samples/bass/slap_bass_1/C3.mp3
deleted file mode 100644
index e91044d..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/E2.mp3 b/frontend/public/samples/bass/slap_bass_1/E2.mp3
deleted file mode 100644
index f381a9f..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/E3.mp3 b/frontend/public/samples/bass/slap_bass_1/E3.mp3
deleted file mode 100644
index c829524..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/G2.mp3 b/frontend/public/samples/bass/slap_bass_1/G2.mp3
deleted file mode 100644
index 0b37175..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/slap_bass_1/G3.mp3 b/frontend/public/samples/bass/slap_bass_1/G3.mp3
deleted file mode 100644
index fc92af3..0000000
Binary files a/frontend/public/samples/bass/slap_bass_1/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/A1.mp3 b/frontend/public/samples/bass/synth_bass_1/A1.mp3
deleted file mode 100644
index 7a903b8..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/A1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/A2.mp3 b/frontend/public/samples/bass/synth_bass_1/A2.mp3
deleted file mode 100644
index 6b7d6ed..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/A3.mp3 b/frontend/public/samples/bass/synth_bass_1/A3.mp3
deleted file mode 100644
index afad613..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/C2.mp3 b/frontend/public/samples/bass/synth_bass_1/C2.mp3
deleted file mode 100644
index 4675426..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/C2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/C3.mp3 b/frontend/public/samples/bass/synth_bass_1/C3.mp3
deleted file mode 100644
index cf17bc0..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/E2.mp3 b/frontend/public/samples/bass/synth_bass_1/E2.mp3
deleted file mode 100644
index fdf5cd5..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/E2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/E3.mp3 b/frontend/public/samples/bass/synth_bass_1/E3.mp3
deleted file mode 100644
index 0fe48dd..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/G2.mp3 b/frontend/public/samples/bass/synth_bass_1/G2.mp3
deleted file mode 100644
index 51f9c5f..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/G2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/bass/synth_bass_1/G3.mp3 b/frontend/public/samples/bass/synth_bass_1/G3.mp3
deleted file mode 100644
index 4623ef3..0000000
Binary files a/frontend/public/samples/bass/synth_bass_1/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/crash.mp3 b/frontend/public/samples/drums/CR78/crash.mp3
deleted file mode 100644
index 474204d..0000000
Binary files a/frontend/public/samples/drums/CR78/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/hihat.mp3 b/frontend/public/samples/drums/CR78/hihat.mp3
deleted file mode 100644
index 474204d..0000000
Binary files a/frontend/public/samples/drums/CR78/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/hihat_open.mp3 b/frontend/public/samples/drums/CR78/hihat_open.mp3
deleted file mode 100644
index 474204d..0000000
Binary files a/frontend/public/samples/drums/CR78/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/kick.mp3 b/frontend/public/samples/drums/CR78/kick.mp3
deleted file mode 100644
index 01f3398..0000000
Binary files a/frontend/public/samples/drums/CR78/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/ride.mp3 b/frontend/public/samples/drums/CR78/ride.mp3
deleted file mode 100644
index 474204d..0000000
Binary files a/frontend/public/samples/drums/CR78/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/snare.mp3 b/frontend/public/samples/drums/CR78/snare.mp3
deleted file mode 100644
index aa596ce..0000000
Binary files a/frontend/public/samples/drums/CR78/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/tom1.mp3 b/frontend/public/samples/drums/CR78/tom1.mp3
deleted file mode 100644
index 454c348..0000000
Binary files a/frontend/public/samples/drums/CR78/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/tom2.mp3 b/frontend/public/samples/drums/CR78/tom2.mp3
deleted file mode 100644
index b634e33..0000000
Binary files a/frontend/public/samples/drums/CR78/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/CR78/tom3.mp3 b/frontend/public/samples/drums/CR78/tom3.mp3
deleted file mode 100644
index bb797e1..0000000
Binary files a/frontend/public/samples/drums/CR78/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/crash.mp3 b/frontend/public/samples/drums/KPR77/crash.mp3
deleted file mode 100644
index d6e8b17..0000000
Binary files a/frontend/public/samples/drums/KPR77/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/hihat.mp3 b/frontend/public/samples/drums/KPR77/hihat.mp3
deleted file mode 100644
index d6e8b17..0000000
Binary files a/frontend/public/samples/drums/KPR77/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/hihat_open.mp3 b/frontend/public/samples/drums/KPR77/hihat_open.mp3
deleted file mode 100644
index d6e8b17..0000000
Binary files a/frontend/public/samples/drums/KPR77/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/kick.mp3 b/frontend/public/samples/drums/KPR77/kick.mp3
deleted file mode 100644
index 5432a74..0000000
Binary files a/frontend/public/samples/drums/KPR77/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/ride.mp3 b/frontend/public/samples/drums/KPR77/ride.mp3
deleted file mode 100644
index d6e8b17..0000000
Binary files a/frontend/public/samples/drums/KPR77/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/snare.mp3 b/frontend/public/samples/drums/KPR77/snare.mp3
deleted file mode 100644
index 2d05802..0000000
Binary files a/frontend/public/samples/drums/KPR77/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/tom1.mp3 b/frontend/public/samples/drums/KPR77/tom1.mp3
deleted file mode 100644
index 7a231bb..0000000
Binary files a/frontend/public/samples/drums/KPR77/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/tom2.mp3 b/frontend/public/samples/drums/KPR77/tom2.mp3
deleted file mode 100644
index 0266a7b..0000000
Binary files a/frontend/public/samples/drums/KPR77/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/KPR77/tom3.mp3 b/frontend/public/samples/drums/KPR77/tom3.mp3
deleted file mode 100644
index fe97856..0000000
Binary files a/frontend/public/samples/drums/KPR77/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/crash.mp3 b/frontend/public/samples/drums/LINN/crash.mp3
deleted file mode 100644
index ba1e700..0000000
Binary files a/frontend/public/samples/drums/LINN/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/hihat.mp3 b/frontend/public/samples/drums/LINN/hihat.mp3
deleted file mode 100644
index ba1e700..0000000
Binary files a/frontend/public/samples/drums/LINN/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/hihat_open.mp3 b/frontend/public/samples/drums/LINN/hihat_open.mp3
deleted file mode 100644
index ba1e700..0000000
Binary files a/frontend/public/samples/drums/LINN/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/kick.mp3 b/frontend/public/samples/drums/LINN/kick.mp3
deleted file mode 100644
index bfbe035..0000000
Binary files a/frontend/public/samples/drums/LINN/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/ride.mp3 b/frontend/public/samples/drums/LINN/ride.mp3
deleted file mode 100644
index ba1e700..0000000
Binary files a/frontend/public/samples/drums/LINN/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/snare.mp3 b/frontend/public/samples/drums/LINN/snare.mp3
deleted file mode 100644
index 0f8e73e..0000000
Binary files a/frontend/public/samples/drums/LINN/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/tom1.mp3 b/frontend/public/samples/drums/LINN/tom1.mp3
deleted file mode 100644
index e39573b..0000000
Binary files a/frontend/public/samples/drums/LINN/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/tom2.mp3 b/frontend/public/samples/drums/LINN/tom2.mp3
deleted file mode 100644
index 51f92e5..0000000
Binary files a/frontend/public/samples/drums/LINN/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/LINN/tom3.mp3 b/frontend/public/samples/drums/LINN/tom3.mp3
deleted file mode 100644
index 5e671da..0000000
Binary files a/frontend/public/samples/drums/LINN/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/crash.mp3 b/frontend/public/samples/drums/R8/crash.mp3
deleted file mode 100644
index 39651ff..0000000
Binary files a/frontend/public/samples/drums/R8/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/hihat.mp3 b/frontend/public/samples/drums/R8/hihat.mp3
deleted file mode 100644
index 39651ff..0000000
Binary files a/frontend/public/samples/drums/R8/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/hihat_open.mp3 b/frontend/public/samples/drums/R8/hihat_open.mp3
deleted file mode 100644
index 39651ff..0000000
Binary files a/frontend/public/samples/drums/R8/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/kick.mp3 b/frontend/public/samples/drums/R8/kick.mp3
deleted file mode 100644
index 31d3bbf..0000000
Binary files a/frontend/public/samples/drums/R8/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/ride.mp3 b/frontend/public/samples/drums/R8/ride.mp3
deleted file mode 100644
index 39651ff..0000000
Binary files a/frontend/public/samples/drums/R8/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/snare.mp3 b/frontend/public/samples/drums/R8/snare.mp3
deleted file mode 100644
index f6dce87..0000000
Binary files a/frontend/public/samples/drums/R8/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/tom1.mp3 b/frontend/public/samples/drums/R8/tom1.mp3
deleted file mode 100644
index 9f4befd..0000000
Binary files a/frontend/public/samples/drums/R8/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/tom2.mp3 b/frontend/public/samples/drums/R8/tom2.mp3
deleted file mode 100644
index c7ca90d..0000000
Binary files a/frontend/public/samples/drums/R8/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/R8/tom3.mp3 b/frontend/public/samples/drums/R8/tom3.mp3
deleted file mode 100644
index ffb20dd..0000000
Binary files a/frontend/public/samples/drums/R8/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/crash.mp3 b/frontend/public/samples/drums/Techno/crash.mp3
deleted file mode 100644
index c9cd4e3..0000000
Binary files a/frontend/public/samples/drums/Techno/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/hihat.mp3 b/frontend/public/samples/drums/Techno/hihat.mp3
deleted file mode 100644
index c9cd4e3..0000000
Binary files a/frontend/public/samples/drums/Techno/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/hihat_open.mp3 b/frontend/public/samples/drums/Techno/hihat_open.mp3
deleted file mode 100644
index c9cd4e3..0000000
Binary files a/frontend/public/samples/drums/Techno/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/kick.mp3 b/frontend/public/samples/drums/Techno/kick.mp3
deleted file mode 100644
index 6967fef..0000000
Binary files a/frontend/public/samples/drums/Techno/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/ride.mp3 b/frontend/public/samples/drums/Techno/ride.mp3
deleted file mode 100644
index c9cd4e3..0000000
Binary files a/frontend/public/samples/drums/Techno/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/snare.mp3 b/frontend/public/samples/drums/Techno/snare.mp3
deleted file mode 100644
index e365c1f..0000000
Binary files a/frontend/public/samples/drums/Techno/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/tom1.mp3 b/frontend/public/samples/drums/Techno/tom1.mp3
deleted file mode 100644
index 37c4b91..0000000
Binary files a/frontend/public/samples/drums/Techno/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/tom2.mp3 b/frontend/public/samples/drums/Techno/tom2.mp3
deleted file mode 100644
index 7c44094..0000000
Binary files a/frontend/public/samples/drums/Techno/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/Techno/tom3.mp3 b/frontend/public/samples/drums/Techno/tom3.mp3
deleted file mode 100644
index c2eeda3..0000000
Binary files a/frontend/public/samples/drums/Techno/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/crash.mp3 b/frontend/public/samples/drums/acoustic-kit/crash.mp3
deleted file mode 100644
index 4c9417a..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/hihat.mp3 b/frontend/public/samples/drums/acoustic-kit/hihat.mp3
deleted file mode 100644
index 4c9417a..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/hihat_open.mp3 b/frontend/public/samples/drums/acoustic-kit/hihat_open.mp3
deleted file mode 100644
index 4c9417a..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/kick.mp3 b/frontend/public/samples/drums/acoustic-kit/kick.mp3
deleted file mode 100644
index b0057c8..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/ride.mp3 b/frontend/public/samples/drums/acoustic-kit/ride.mp3
deleted file mode 100644
index 4c9417a..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/snare.mp3 b/frontend/public/samples/drums/acoustic-kit/snare.mp3
deleted file mode 100644
index 4e23bae..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/tom1.mp3 b/frontend/public/samples/drums/acoustic-kit/tom1.mp3
deleted file mode 100644
index e401335..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/tom2.mp3 b/frontend/public/samples/drums/acoustic-kit/tom2.mp3
deleted file mode 100644
index ef88d25..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/acoustic-kit/tom3.mp3 b/frontend/public/samples/drums/acoustic-kit/tom3.mp3
deleted file mode 100644
index e747287..0000000
Binary files a/frontend/public/samples/drums/acoustic-kit/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/crash.mp3 b/frontend/public/samples/drums/breakbeat13/crash.mp3
deleted file mode 100644
index 328a6f7..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/hihat.mp3 b/frontend/public/samples/drums/breakbeat13/hihat.mp3
deleted file mode 100644
index 328a6f7..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/hihat_open.mp3 b/frontend/public/samples/drums/breakbeat13/hihat_open.mp3
deleted file mode 100644
index 328a6f7..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/kick.mp3 b/frontend/public/samples/drums/breakbeat13/kick.mp3
deleted file mode 100644
index 42e72dc..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/ride.mp3 b/frontend/public/samples/drums/breakbeat13/ride.mp3
deleted file mode 100644
index 328a6f7..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/snare.mp3 b/frontend/public/samples/drums/breakbeat13/snare.mp3
deleted file mode 100644
index dee7660..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/tom1.mp3 b/frontend/public/samples/drums/breakbeat13/tom1.mp3
deleted file mode 100644
index 5b7474f..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/tom2.mp3 b/frontend/public/samples/drums/breakbeat13/tom2.mp3
deleted file mode 100644
index f885519..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat13/tom3.mp3 b/frontend/public/samples/drums/breakbeat13/tom3.mp3
deleted file mode 100644
index 24a7211..0000000
Binary files a/frontend/public/samples/drums/breakbeat13/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/crash.mp3 b/frontend/public/samples/drums/breakbeat8/crash.mp3
deleted file mode 100644
index 13717b0..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/crash.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/hihat.mp3 b/frontend/public/samples/drums/breakbeat8/hihat.mp3
deleted file mode 100644
index 13717b0..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/hihat.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/hihat_open.mp3 b/frontend/public/samples/drums/breakbeat8/hihat_open.mp3
deleted file mode 100644
index 13717b0..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/hihat_open.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/kick.mp3 b/frontend/public/samples/drums/breakbeat8/kick.mp3
deleted file mode 100644
index 077d79c..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/kick.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/ride.mp3 b/frontend/public/samples/drums/breakbeat8/ride.mp3
deleted file mode 100644
index 13717b0..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/ride.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/snare.mp3 b/frontend/public/samples/drums/breakbeat8/snare.mp3
deleted file mode 100644
index f1ca928..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/snare.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/tom1.mp3 b/frontend/public/samples/drums/breakbeat8/tom1.mp3
deleted file mode 100644
index 5b7474f..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/tom1.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/tom2.mp3 b/frontend/public/samples/drums/breakbeat8/tom2.mp3
deleted file mode 100644
index f885519..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/tom2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/drums/breakbeat8/tom3.mp3 b/frontend/public/samples/drums/breakbeat8/tom3.mp3
deleted file mode 100644
index 24a7211..0000000
Binary files a/frontend/public/samples/drums/breakbeat8/tom3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/A2.mp3 b/frontend/public/samples/melodic/accordion/A2.mp3
deleted file mode 100644
index ae8caf5..0000000
Binary files a/frontend/public/samples/melodic/accordion/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/A3.mp3 b/frontend/public/samples/melodic/accordion/A3.mp3
deleted file mode 100644
index 9614364..0000000
Binary files a/frontend/public/samples/melodic/accordion/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/A4.mp3 b/frontend/public/samples/melodic/accordion/A4.mp3
deleted file mode 100644
index 8090d92..0000000
Binary files a/frontend/public/samples/melodic/accordion/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/A5.mp3 b/frontend/public/samples/melodic/accordion/A5.mp3
deleted file mode 100644
index b5d3626..0000000
Binary files a/frontend/public/samples/melodic/accordion/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/C3.mp3 b/frontend/public/samples/melodic/accordion/C3.mp3
deleted file mode 100644
index eb10293..0000000
Binary files a/frontend/public/samples/melodic/accordion/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/C4.mp3 b/frontend/public/samples/melodic/accordion/C4.mp3
deleted file mode 100644
index d242f3d..0000000
Binary files a/frontend/public/samples/melodic/accordion/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/C5.mp3 b/frontend/public/samples/melodic/accordion/C5.mp3
deleted file mode 100644
index 9d0b81c..0000000
Binary files a/frontend/public/samples/melodic/accordion/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/E3.mp3 b/frontend/public/samples/melodic/accordion/E3.mp3
deleted file mode 100644
index d642a9b..0000000
Binary files a/frontend/public/samples/melodic/accordion/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/E4.mp3 b/frontend/public/samples/melodic/accordion/E4.mp3
deleted file mode 100644
index d46190e..0000000
Binary files a/frontend/public/samples/melodic/accordion/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/E5.mp3 b/frontend/public/samples/melodic/accordion/E5.mp3
deleted file mode 100644
index 98f4eac..0000000
Binary files a/frontend/public/samples/melodic/accordion/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/G3.mp3 b/frontend/public/samples/melodic/accordion/G3.mp3
deleted file mode 100644
index f9643e4..0000000
Binary files a/frontend/public/samples/melodic/accordion/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/G4.mp3 b/frontend/public/samples/melodic/accordion/G4.mp3
deleted file mode 100644
index 8102313..0000000
Binary files a/frontend/public/samples/melodic/accordion/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/accordion/G5.mp3 b/frontend/public/samples/melodic/accordion/G5.mp3
deleted file mode 100644
index faf6ba8..0000000
Binary files a/frontend/public/samples/melodic/accordion/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/A2.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/A2.mp3
deleted file mode 100644
index d020d37..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/A3.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/A3.mp3
deleted file mode 100644
index ddc9945..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/A4.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/A4.mp3
deleted file mode 100644
index 2357a65..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/A5.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/A5.mp3
deleted file mode 100644
index e4dc8ce..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/C3.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/C3.mp3
deleted file mode 100644
index 699147e..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/C4.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/C4.mp3
deleted file mode 100644
index 13456cf..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/C5.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/C5.mp3
deleted file mode 100644
index 7cbe796..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/E3.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/E3.mp3
deleted file mode 100644
index 0001295..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/E4.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/E4.mp3
deleted file mode 100644
index f2bb3aa..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/E5.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/E5.mp3
deleted file mode 100644
index f63e036..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/G3.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/G3.mp3
deleted file mode 100644
index 3fd0d39..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/G4.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/G4.mp3
deleted file mode 100644
index 0896dba..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/acoustic_guitar_nylon/G5.mp3 b/frontend/public/samples/melodic/acoustic_guitar_nylon/G5.mp3
deleted file mode 100644
index 6e1edfc..0000000
Binary files a/frontend/public/samples/melodic/acoustic_guitar_nylon/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/A2.mp3 b/frontend/public/samples/melodic/clavinet/A2.mp3
deleted file mode 100644
index 55fdc01..0000000
Binary files a/frontend/public/samples/melodic/clavinet/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/A3.mp3 b/frontend/public/samples/melodic/clavinet/A3.mp3
deleted file mode 100644
index 270c937..0000000
Binary files a/frontend/public/samples/melodic/clavinet/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/A4.mp3 b/frontend/public/samples/melodic/clavinet/A4.mp3
deleted file mode 100644
index d1ee807..0000000
Binary files a/frontend/public/samples/melodic/clavinet/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/A5.mp3 b/frontend/public/samples/melodic/clavinet/A5.mp3
deleted file mode 100644
index d688442..0000000
Binary files a/frontend/public/samples/melodic/clavinet/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/C3.mp3 b/frontend/public/samples/melodic/clavinet/C3.mp3
deleted file mode 100644
index e6708c7..0000000
Binary files a/frontend/public/samples/melodic/clavinet/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/C4.mp3 b/frontend/public/samples/melodic/clavinet/C4.mp3
deleted file mode 100644
index ee4c84a..0000000
Binary files a/frontend/public/samples/melodic/clavinet/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/C5.mp3 b/frontend/public/samples/melodic/clavinet/C5.mp3
deleted file mode 100644
index 3ce5c4c..0000000
Binary files a/frontend/public/samples/melodic/clavinet/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/E3.mp3 b/frontend/public/samples/melodic/clavinet/E3.mp3
deleted file mode 100644
index 98d236e..0000000
Binary files a/frontend/public/samples/melodic/clavinet/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/E4.mp3 b/frontend/public/samples/melodic/clavinet/E4.mp3
deleted file mode 100644
index 03f296c..0000000
Binary files a/frontend/public/samples/melodic/clavinet/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/E5.mp3 b/frontend/public/samples/melodic/clavinet/E5.mp3
deleted file mode 100644
index 948dc48..0000000
Binary files a/frontend/public/samples/melodic/clavinet/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/G3.mp3 b/frontend/public/samples/melodic/clavinet/G3.mp3
deleted file mode 100644
index e5da808..0000000
Binary files a/frontend/public/samples/melodic/clavinet/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/G4.mp3 b/frontend/public/samples/melodic/clavinet/G4.mp3
deleted file mode 100644
index e2f0289..0000000
Binary files a/frontend/public/samples/melodic/clavinet/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/clavinet/G5.mp3 b/frontend/public/samples/melodic/clavinet/G5.mp3
deleted file mode 100644
index a398f45..0000000
Binary files a/frontend/public/samples/melodic/clavinet/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/A2.mp3 b/frontend/public/samples/melodic/drawbar_organ/A2.mp3
deleted file mode 100644
index c82c44e..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/A3.mp3 b/frontend/public/samples/melodic/drawbar_organ/A3.mp3
deleted file mode 100644
index e5cd842..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/A4.mp3 b/frontend/public/samples/melodic/drawbar_organ/A4.mp3
deleted file mode 100644
index 7aea90c..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/A5.mp3 b/frontend/public/samples/melodic/drawbar_organ/A5.mp3
deleted file mode 100644
index a3f19a5..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/C3.mp3 b/frontend/public/samples/melodic/drawbar_organ/C3.mp3
deleted file mode 100644
index a1c3c4b..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/C4.mp3 b/frontend/public/samples/melodic/drawbar_organ/C4.mp3
deleted file mode 100644
index 2a3a9a8..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/C5.mp3 b/frontend/public/samples/melodic/drawbar_organ/C5.mp3
deleted file mode 100644
index 3762c61..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/E3.mp3 b/frontend/public/samples/melodic/drawbar_organ/E3.mp3
deleted file mode 100644
index 875a099..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/E4.mp3 b/frontend/public/samples/melodic/drawbar_organ/E4.mp3
deleted file mode 100644
index 9685fbb..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/E5.mp3 b/frontend/public/samples/melodic/drawbar_organ/E5.mp3
deleted file mode 100644
index 453027b..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/G3.mp3 b/frontend/public/samples/melodic/drawbar_organ/G3.mp3
deleted file mode 100644
index 0953008..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/G4.mp3 b/frontend/public/samples/melodic/drawbar_organ/G4.mp3
deleted file mode 100644
index 83a8bbf..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/drawbar_organ/G5.mp3 b/frontend/public/samples/melodic/drawbar_organ/G5.mp3
deleted file mode 100644
index c1556c3..0000000
Binary files a/frontend/public/samples/melodic/drawbar_organ/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/A2.mp3 b/frontend/public/samples/melodic/electric_piano_1/A2.mp3
deleted file mode 100644
index df451b7..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/A3.mp3 b/frontend/public/samples/melodic/electric_piano_1/A3.mp3
deleted file mode 100644
index 5f72c6f..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/A4.mp3 b/frontend/public/samples/melodic/electric_piano_1/A4.mp3
deleted file mode 100644
index 178e2b9..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/A5.mp3 b/frontend/public/samples/melodic/electric_piano_1/A5.mp3
deleted file mode 100644
index e9ea74e..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/C3.mp3 b/frontend/public/samples/melodic/electric_piano_1/C3.mp3
deleted file mode 100644
index 6863a93..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/C4.mp3 b/frontend/public/samples/melodic/electric_piano_1/C4.mp3
deleted file mode 100644
index 3fd649f..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/C5.mp3 b/frontend/public/samples/melodic/electric_piano_1/C5.mp3
deleted file mode 100644
index 7fbb5b8..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/E3.mp3 b/frontend/public/samples/melodic/electric_piano_1/E3.mp3
deleted file mode 100644
index 8c6608c..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/E4.mp3 b/frontend/public/samples/melodic/electric_piano_1/E4.mp3
deleted file mode 100644
index 168af85..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/E5.mp3 b/frontend/public/samples/melodic/electric_piano_1/E5.mp3
deleted file mode 100644
index f0a8b7b..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/G3.mp3 b/frontend/public/samples/melodic/electric_piano_1/G3.mp3
deleted file mode 100644
index e17ddfe..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/G4.mp3 b/frontend/public/samples/melodic/electric_piano_1/G4.mp3
deleted file mode 100644
index 6830b8a..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_1/G5.mp3 b/frontend/public/samples/melodic/electric_piano_1/G5.mp3
deleted file mode 100644
index 37b0024..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_1/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/A2.mp3 b/frontend/public/samples/melodic/electric_piano_2/A2.mp3
deleted file mode 100644
index 343a415..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/A3.mp3 b/frontend/public/samples/melodic/electric_piano_2/A3.mp3
deleted file mode 100644
index 7283623..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/A4.mp3 b/frontend/public/samples/melodic/electric_piano_2/A4.mp3
deleted file mode 100644
index 81ee732..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/A5.mp3 b/frontend/public/samples/melodic/electric_piano_2/A5.mp3
deleted file mode 100644
index 56460df..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/C3.mp3 b/frontend/public/samples/melodic/electric_piano_2/C3.mp3
deleted file mode 100644
index 5ce8b69..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/C4.mp3 b/frontend/public/samples/melodic/electric_piano_2/C4.mp3
deleted file mode 100644
index 630cbab..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/C5.mp3 b/frontend/public/samples/melodic/electric_piano_2/C5.mp3
deleted file mode 100644
index a96be90..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/E3.mp3 b/frontend/public/samples/melodic/electric_piano_2/E3.mp3
deleted file mode 100644
index 767a3f1..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/E4.mp3 b/frontend/public/samples/melodic/electric_piano_2/E4.mp3
deleted file mode 100644
index edd11db..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/E5.mp3 b/frontend/public/samples/melodic/electric_piano_2/E5.mp3
deleted file mode 100644
index 1f15ed9..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/G3.mp3 b/frontend/public/samples/melodic/electric_piano_2/G3.mp3
deleted file mode 100644
index 13ef6df..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/G4.mp3 b/frontend/public/samples/melodic/electric_piano_2/G4.mp3
deleted file mode 100644
index cfc2469..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/electric_piano_2/G5.mp3 b/frontend/public/samples/melodic/electric_piano_2/G5.mp3
deleted file mode 100644
index 6f2d815..0000000
Binary files a/frontend/public/samples/melodic/electric_piano_2/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/A2.mp3 b/frontend/public/samples/melodic/string_ensemble_1/A2.mp3
deleted file mode 100644
index 71ba8d2..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/A3.mp3 b/frontend/public/samples/melodic/string_ensemble_1/A3.mp3
deleted file mode 100644
index 1fa880e..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/A4.mp3 b/frontend/public/samples/melodic/string_ensemble_1/A4.mp3
deleted file mode 100644
index ee4bbfc..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/A5.mp3 b/frontend/public/samples/melodic/string_ensemble_1/A5.mp3
deleted file mode 100644
index 099b834..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/C3.mp3 b/frontend/public/samples/melodic/string_ensemble_1/C3.mp3
deleted file mode 100644
index 2fd6410..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/C4.mp3 b/frontend/public/samples/melodic/string_ensemble_1/C4.mp3
deleted file mode 100644
index 25dedea..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/C5.mp3 b/frontend/public/samples/melodic/string_ensemble_1/C5.mp3
deleted file mode 100644
index 2dad86b..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/E3.mp3 b/frontend/public/samples/melodic/string_ensemble_1/E3.mp3
deleted file mode 100644
index bbce482..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/E4.mp3 b/frontend/public/samples/melodic/string_ensemble_1/E4.mp3
deleted file mode 100644
index 02a4e9f..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/E5.mp3 b/frontend/public/samples/melodic/string_ensemble_1/E5.mp3
deleted file mode 100644
index 54198dc..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/G3.mp3 b/frontend/public/samples/melodic/string_ensemble_1/G3.mp3
deleted file mode 100644
index f424981..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/G4.mp3 b/frontend/public/samples/melodic/string_ensemble_1/G4.mp3
deleted file mode 100644
index 7087be4..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/string_ensemble_1/G5.mp3 b/frontend/public/samples/melodic/string_ensemble_1/G5.mp3
deleted file mode 100644
index 8fb77e8..0000000
Binary files a/frontend/public/samples/melodic/string_ensemble_1/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/A2.mp3 b/frontend/public/samples/melodic/vibraphone/A2.mp3
deleted file mode 100644
index adb03b7..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/A2.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/A3.mp3 b/frontend/public/samples/melodic/vibraphone/A3.mp3
deleted file mode 100644
index fb66fa4..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/A3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/A4.mp3 b/frontend/public/samples/melodic/vibraphone/A4.mp3
deleted file mode 100644
index 76b2ead..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/A4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/A5.mp3 b/frontend/public/samples/melodic/vibraphone/A5.mp3
deleted file mode 100644
index 66d5a61..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/A5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/C3.mp3 b/frontend/public/samples/melodic/vibraphone/C3.mp3
deleted file mode 100644
index 9fd8e8f..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/C3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/C4.mp3 b/frontend/public/samples/melodic/vibraphone/C4.mp3
deleted file mode 100644
index b670fdc..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/C4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/C5.mp3 b/frontend/public/samples/melodic/vibraphone/C5.mp3
deleted file mode 100644
index 8db3797..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/C5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/E3.mp3 b/frontend/public/samples/melodic/vibraphone/E3.mp3
deleted file mode 100644
index dadd2e3..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/E3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/E4.mp3 b/frontend/public/samples/melodic/vibraphone/E4.mp3
deleted file mode 100644
index 158f57b..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/E4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/E5.mp3 b/frontend/public/samples/melodic/vibraphone/E5.mp3
deleted file mode 100644
index 898af9d..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/E5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/G3.mp3 b/frontend/public/samples/melodic/vibraphone/G3.mp3
deleted file mode 100644
index 008fb27..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/G3.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/G4.mp3 b/frontend/public/samples/melodic/vibraphone/G4.mp3
deleted file mode 100644
index 016592e..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/G4.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/G5.mp3 b/frontend/public/samples/melodic/vibraphone/G5.mp3
deleted file mode 100644
index 5303c03..0000000
Binary files a/frontend/public/samples/melodic/vibraphone/G5.mp3 and /dev/null differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/A4.mp3 b/frontend/public/samples/melodic/vibraphone/hard/A4.mp3
new file mode 100644
index 0000000..c5e5a0c
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/A4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/B3.mp3 b/frontend/public/samples/melodic/vibraphone/hard/B3.mp3
new file mode 100644
index 0000000..8b8840f
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/B3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/C3.mp3 b/frontend/public/samples/melodic/vibraphone/hard/C3.mp3
new file mode 100644
index 0000000..708183f
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/C3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/C5.mp3 b/frontend/public/samples/melodic/vibraphone/hard/C5.mp3
new file mode 100644
index 0000000..d9803b3
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/C5.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/D4.mp3 b/frontend/public/samples/melodic/vibraphone/hard/D4.mp3
new file mode 100644
index 0000000..29d622f
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/D4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/E3.mp3 b/frontend/public/samples/melodic/vibraphone/hard/E3.mp3
new file mode 100644
index 0000000..97bb20e
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/E3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/E5.mp3 b/frontend/public/samples/melodic/vibraphone/hard/E5.mp3
new file mode 100644
index 0000000..d4ea8f5
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/E5.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/F4.mp3 b/frontend/public/samples/melodic/vibraphone/hard/F4.mp3
new file mode 100644
index 0000000..eb12027
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/F4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/hard/G3.mp3 b/frontend/public/samples/melodic/vibraphone/hard/G3.mp3
new file mode 100644
index 0000000..9a357de
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/hard/G3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/A4.mp3 b/frontend/public/samples/melodic/vibraphone/soft/A4.mp3
new file mode 100644
index 0000000..0735449
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/A4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/B3.mp3 b/frontend/public/samples/melodic/vibraphone/soft/B3.mp3
new file mode 100644
index 0000000..b8d1834
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/B3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/C3.mp3 b/frontend/public/samples/melodic/vibraphone/soft/C3.mp3
new file mode 100644
index 0000000..7d5caf7
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/C3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/C5.mp3 b/frontend/public/samples/melodic/vibraphone/soft/C5.mp3
new file mode 100644
index 0000000..25d256f
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/C5.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/D4.mp3 b/frontend/public/samples/melodic/vibraphone/soft/D4.mp3
new file mode 100644
index 0000000..b234cc4
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/D4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/E3.mp3 b/frontend/public/samples/melodic/vibraphone/soft/E3.mp3
new file mode 100644
index 0000000..2b308f0
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/E3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/E5.mp3 b/frontend/public/samples/melodic/vibraphone/soft/E5.mp3
new file mode 100644
index 0000000..827aab3
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/E5.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/F4.mp3 b/frontend/public/samples/melodic/vibraphone/soft/F4.mp3
new file mode 100644
index 0000000..d070575
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/F4.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/soft/G3.mp3 b/frontend/public/samples/melodic/vibraphone/soft/G3.mp3
new file mode 100644
index 0000000..ba61bb6
Binary files /dev/null and b/frontend/public/samples/melodic/vibraphone/soft/G3.mp3 differ
diff --git a/frontend/public/samples/melodic/vibraphone/velocity.json b/frontend/public/samples/melodic/vibraphone/velocity.json
new file mode 100644
index 0000000..a001c10
--- /dev/null
+++ b/frontend/public/samples/melodic/vibraphone/velocity.json
@@ -0,0 +1,32 @@
+{
+  "layers": [
+    {
+      "maxVelocity": 0.5,
+      "urls": {
+        "C3": "soft/C3.mp3",
+        "E3": "soft/E3.mp3",
+        "G3": "soft/G3.mp3",
+        "B3": "soft/B3.mp3",
+        "D4": "soft/D4.mp3",
+        "F4": "soft/F4.mp3",
+        "A4": "soft/A4.mp3",
+        "C5": "soft/C5.mp3",
+        "E5": "soft/E5.mp3"
+      }
+    },
+    {
+      "maxVelocity": 1.0,
+      "urls": {
+        "C3": "hard/C3.mp3",
+        "E3": "hard/E3.mp3",
+        "G3": "hard/G3.mp3",
+        "B3": "hard/B3.mp3",
+        "D4": "hard/D4.mp3",
+        "F4": "hard/F4.mp3",
+        "A4": "hard/A4.mp3",
+        "C5": "hard/C5.mp3",
+        "E5": "hard/E5.mp3"
+      }
+    }
+  ]
+}
diff --git a/frontend/src/components/InstrumentsPanel.vue b/frontend/src/components/InstrumentsPanel.vue
new file mode 100644
index 0000000..83f2b14
--- /dev/null
+++ b/frontend/src/components/InstrumentsPanel.vue
@@ -0,0 +1,207 @@
+<!--
+  GenreGrid — a style-based MIDI generator.
+  Copyright (C) 2026 Tw Dover
+
+  This program is free software: you can redistribute it and/or modify it under
+  the terms of the GNU General Public License as published by the Free Software
+  Foundation, either version 3 of the License, or (at your option) any later
+  version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+  <https://www.gnu.org/licenses/> for details.
+-->
+<template>
+  <div v-if="panelOpen" class="ip-overlay" @click.self="close" @keydown.esc="close">
+    <div class="ip-modal" role="dialog" aria-label="Custom instruments">
+      <header class="ip-header">
+        <h2>Custom instruments</h2>
+        <button class="ip-x" title="Close" @click="close">✕</button>
+      </header>
+
+      <p v-if="!supported()" class="ip-note">
+        Custom instruments need the GenreGrid desktop app — this feature is unavailable in the browser build.
+      </p>
+
+      <template v-else>
+        <!-- Add -->
+        <section class="ip-add">
+          <h3>Add an instrument</h3>
+          <p class="ip-hint">
+            Drop <strong>one sound</strong> (pitched across the keyboard), or several files named by
+            note (<code>C4.wav</code>, <code>A#3.mp3</code>). Sub-folders like <code>soft/</code> and
+            <code>hard/</code> become velocity layers.
+          </p>
+          <div class="ip-add-row">
+            <input v-model="newName" class="ip-input" type="text" placeholder="Instrument name" />
+            <select v-model="newKind" class="ip-input ip-kind">
+              <option value="melodic">Melodic</option>
+              <option value="bass">Bass</option>
+            </select>
+          </div>
+          <div class="ip-add-row">
+            <label class="ip-file">
+              Choose files
+              <input ref="filesInput" type="file" accept="audio/*,.mp3,.wav,.ogg,.flac,.m4a" multiple @change="onPick" />
+            </label>
+            <label class="ip-file">
+              Choose folder
+              <input ref="folderInput" type="file" webkitdirectory @change="onPick" />
+            </label>
+            <span v-if="pickedCount" class="ip-picked">{{ pickedCount }} file(s) selected</span>
+          </div>
+          <div class="ip-add-row">
+            <button class="ip-btn" :disabled="!canImport || importing" @click="doImport">
+              {{ importing ? 'Importing…' : 'Add instrument' }}
+            </button>
+            <span v-if="error" class="ip-err">{{ error }}</span>
+          </div>
+        </section>
+
+        <!-- Library -->
+        <section class="ip-lib">
+          <h3>Your instruments ({{ instruments.length }})</h3>
+          <p v-if="!instruments.length" class="ip-empty">None yet — add one above.</p>
+          <ul v-else class="ip-list">
+            <li v-for="inst in instruments" :key="inst.id" class="ip-item">
+              <span class="ip-name">{{ inst.name }}</span>
+              <span class="ip-meta">{{ inst.kind }} · {{ inst.manifest.layers.length }} layer(s)</span>
+              <button class="ip-del" title="Delete" @click="remove(inst)">Delete</button>
+            </li>
+          </ul>
+        </section>
+
+        <!-- Per-part assignment -->
+        <section class="ip-assign">
+          <h3>Play these on…</h3>
+          <p class="ip-hint">Pick which instrument plays each part. “Built-in” keeps the default voice/synth.</p>
+          <div v-for="part in ASSIGNABLE_PARTS" :key="part" class="ip-assign-row">
+            <span class="ip-part">{{ partLabel(part) }}</span>
+            <select
+              class="ip-input"
+              :value="assignments.defaults[part] ?? ''"
+              @change="onAssign(part, ($event.target as HTMLSelectElement).value)"
+            >
+              <option value="">Built-in</option>
+              <option v-for="inst in instruments" :key="inst.id" :value="inst.id">{{ inst.name }}</option>
+            </select>
+          </div>
+        </section>
+      </template>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, computed, watch } from 'vue'
+import { useCustomInstruments } from '../composables/useCustomInstruments'
+import type { PlayerPart } from '../composables/useMidiPlayer'
+import type { CustomInstrument } from '../soundfonts/customInstruments'
+
+const {
+  instruments, assignments, panelOpen, supported,
+  ensureLoaded, importInstrument, deleteInstrument, assignPart,
+} = useCustomInstruments()
+
+const ASSIGNABLE_PARTS: PlayerPart[] = ['chords', 'melody', 'arpeggio', 'bass', 'pads', 'counter_melody']
+function partLabel(p: PlayerPart): string {
+  return p === 'counter_melody' ? 'Counter-melody' : p.charAt(0).toUpperCase() + p.slice(1)
+}
+
+const newName = ref('')
+const newKind = ref<'melodic' | 'bass'>('melodic')
+const picked = ref<File[]>([])
+const filesInput = ref<HTMLInputElement | null>(null)
+const folderInput = ref<HTMLInputElement | null>(null)
+const importing = ref(false)
+const error = ref('')
+
+const pickedCount = computed(() => picked.value.length)
+const canImport = computed(() => picked.value.length > 0 && newName.value.trim().length > 0)
+
+watch(panelOpen, (open) => { if (open) ensureLoaded() })
+
+function onPick(e: Event) {
+  const input = e.target as HTMLInputElement
+  picked.value = input.files ? Array.from(input.files) : []
+  error.value = ''
+}
+
+async function doImport() {
+  if (!canImport.value) return
+  importing.value = true
+  error.value = ''
+  try {
+    const inst = await importInstrument(newName.value, newKind.value, picked.value)
+    if (!inst) { error.value = 'No usable audio files found.'; return }
+    newName.value = ''
+    picked.value = []
+    if (filesInput.value) filesInput.value.value = ''
+    if (folderInput.value) folderInput.value.value = ''
+  } catch (err) {
+    error.value = err instanceof Error ? err.message : 'Import failed.'
+  } finally {
+    importing.value = false
+  }
+}
+
+async function remove(inst: CustomInstrument) {
+  if (!confirm(`Delete “${inst.name}”?`)) return
+  await deleteInstrument(inst.id)
+}
+
+function onAssign(part: PlayerPart, id: string) {
+  assignPart(part, id || null)
+}
+
+function close() { panelOpen.value = false }
+</script>
+
+<style scoped>
+.ip-overlay {
+  position: fixed; inset: 0; z-index: 1000;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex; align-items: center; justify-content: center; padding: 1rem;
+}
+.ip-modal {
+  background: var(--surface); color: var(--text);
+  border: 1px solid var(--border); border-radius: 10px;
+  width: min(560px, 100%); max-height: 86vh; overflow: auto;
+  padding: 1rem 1.25rem;
+}
+.ip-header { display: flex; align-items: center; justify-content: space-between; margin-bottom: 0.5rem; }
+.ip-header h2 { margin: 0; font-size: 1.1rem; }
+.ip-x { background: none; border: none; color: var(--text-faint); cursor: pointer; font-size: 1rem; }
+.ip-x:hover { color: var(--text); }
+.ip-note { color: var(--text-faint); }
+section { border-top: 1px solid var(--border); padding-top: 0.85rem; margin-top: 0.85rem; }
+h3 { font-size: 0.85rem; margin: 0 0 0.4rem; color: var(--text); }
+.ip-hint { font-size: 0.78rem; color: var(--text-faint); margin: 0 0 0.6rem; }
+.ip-hint code { background: var(--surface-muted); padding: 0 0.25rem; border-radius: 3px; }
+.ip-add-row { display: flex; gap: 0.5rem; align-items: center; margin-bottom: 0.5rem; flex-wrap: wrap; }
+.ip-input {
+  font: inherit; padding: 0.35rem 0.5rem; border: 1px solid var(--border);
+  border-radius: 6px; background: var(--surface); color: var(--text);
+}
+.ip-add .ip-input:first-child { flex: 1; min-width: 140px; }
+.ip-kind { min-width: 110px; }
+.ip-file {
+  font-size: 0.78rem; cursor: pointer; padding: 0.35rem 0.6rem;
+  border: 1px solid var(--border); border-radius: 6px; background: var(--surface-muted);
+}
+.ip-file input { display: none; }
+.ip-picked { font-size: 0.78rem; color: var(--text-faint); }
+.ip-btn {
+  font: inherit; padding: 0.4rem 0.8rem; border: 1px solid var(--border);
+  border-radius: 6px; background: var(--accent); color: var(--accent-contrast, #fff); cursor: pointer;
+}
+.ip-btn:disabled { opacity: 0.5; cursor: default; }
+.ip-err, .ip-empty { font-size: 0.8rem; color: var(--text-faint); }
+.ip-err { color: #e66; }
+.ip-list { list-style: none; margin: 0; padding: 0; }
+.ip-item { display: flex; align-items: center; gap: 0.6rem; padding: 0.35rem 0; border-bottom: 1px solid var(--border); }
+.ip-name { font-weight: 600; }
+.ip-meta { font-size: 0.75rem; color: var(--text-faint); flex: 1; }
+.ip-del { font-size: 0.75rem; background: none; border: 1px solid var(--border); border-radius: 5px; color: var(--text-faint); cursor: pointer; padding: 0.2rem 0.5rem; }
+.ip-del:hover { color: #e66; border-color: #e66; }
+.ip-assign-row { display: flex; align-items: center; gap: 0.6rem; margin-bottom: 0.4rem; }
+.ip-part { width: 120px; font-size: 0.82rem; }
+.ip-assign-row .ip-input { flex: 1; }
+</style>
diff --git a/frontend/src/components/TransportBar.vue b/frontend/src/components/TransportBar.vue
index 5d56db6..a57adb2 100644
--- a/frontend/src/components/TransportBar.vue
+++ b/frontend/src/components/TransportBar.vue
@@ -62,6 +62,30 @@
       >{{ chipLabel(ch) }}</button>
     </div>
 
+    <!-- Instrument mode: sampled instruments vs full synthesis -->
+    <div class="tb-mode" role="group" aria-label="Instrument sound">
+      <button
+        class="tb-mode-btn"
+        :class="{ 'is-active': sampleMode === 'samples' }"
+        :aria-pressed="sampleMode === 'samples'"
+        title="Sampled instruments where available (piano, vibraphone), synth for the rest"
+        @click="setSampleMode('samples')"
+      >Samples</button>
+      <button
+        class="tb-mode-btn"
+        :class="{ 'is-active': sampleMode === 'synth' }"
+        :aria-pressed="sampleMode === 'synth'"
+        title="Synthesize every instrument"
+        @click="setSampleMode('synth')"
+      >Synth</button>
+    </div>
+    <button
+      v-if="instrumentsSupported()"
+      class="tb-instr-btn"
+      title="Manage custom instruments (upload your own samples)"
+      @click="instrumentsPanelOpen = true"
+    >🎹</button>
+
     <!-- Volume -->
     <div class="tb-volume">
       <span class="tb-vol-icon">{{ volume === 0 ? '🔇' : volume < 40 ? '🔈' : '🔊' }}</span>
@@ -81,14 +105,17 @@
 <script setup lang="ts">
 import { computed } from 'vue'
 import { useMidiPlayer, PLAYER_PARTS, type PlayerPart } from '../composables/useMidiPlayer'
+import { useCustomInstruments } from '../composables/useCustomInstruments'
 
 const {
   currentlyPlaying, nowPlayingLabel, isLoading, isRecording,
   stop, looping, setLooping, channelMuted, toggleMute, soloPart,
   positionSeconds, durationSeconds, seek, isPaused, togglePause,
-  volume, setVolume, playCued, cuedLabel,
+  volume, setVolume, sampleMode, setSampleMode, playCued, cuedLabel,
 } = useMidiPlayer()
 
+const { panelOpen: instrumentsPanelOpen, supported: instrumentsSupported } = useCustomInstruments()
+
 const isIdle = computed(() => !currentlyPlaying.value && !isLoading.value)
 
 // Idle shows the cued track (what ▶ would start) so the bar is never a blank
@@ -248,8 +275,25 @@ function onSeek(e: Event) {
 .tb-vol-icon { font-size: 0.75rem; }
 .tb-vol-slider { width: 90px; accent-color: var(--accent); cursor: pointer; }
 
+/* Samples/Synth segmented toggle */
+.tb-mode { display: inline-flex; flex-shrink: 0; border: 1px solid var(--border); border-radius: 6px; overflow: hidden; }
+.tb-mode-btn {
+  font: inherit; font-size: 0.7rem; line-height: 1; padding: 0.3rem 0.5rem;
+  background: var(--surface); color: var(--text-faint); border: none; cursor: pointer;
+}
+.tb-mode-btn + .tb-mode-btn { border-left: 1px solid var(--border); }
+.tb-mode-btn:hover { color: var(--text); }
+.tb-mode-btn.is-active { background: var(--accent); color: var(--accent-contrast, #fff); }
+.tb-instr-btn {
+  font-size: 0.85rem; line-height: 1; flex-shrink: 0; cursor: pointer;
+  padding: 0.3rem 0.45rem; border: 1px solid var(--border); border-radius: 6px;
+  background: var(--surface); color: var(--text-faint);
+}
+.tb-instr-btn:hover { color: var(--text); }
+
 @media (max-width: 900px) {
   .tb-label { display: none; }
   .tb-vol-slider { width: 60px; }
+  .tb-mode { display: none; }   /* keep the narrow bar uncluttered */
 }
 </style>
diff --git a/frontend/src/composables/useCustomInstruments.ts b/frontend/src/composables/useCustomInstruments.ts
new file mode 100644
index 0000000..a8ae2af
--- /dev/null
+++ b/frontend/src/composables/useCustomInstruments.ts
@@ -0,0 +1,208 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import { ref } from 'vue'
+import {
+  buildManifest,
+  type CustomInstrument,
+  type InstrumentAssignments,
+} from '../soundfonts/customInstruments'
+import type { LayeredSamplerManifest } from '../soundfonts/layeredSampler'
+import type { PlayerPart } from './useMidiPlayer'
+
+// ── Custom-instrument library store ──────────────────────────────────────────
+// Owns the user's uploaded instruments (persisted by the Electron main process
+// under userData/instruments/) and the per-part assignments (persisted in
+// localStorage). At play time `materialize()` reads an instrument's audio bytes over
+// IPC and turns them into object URLs, so LayeredSampler loads them as blob: URLs —
+// the same audio path the app already uses, which sidesteps the custom-scheme Web
+// Audio silence bug seen on Linux Electron. See docs/custom-instruments-design.md.
+// Storage is Electron-only for now; a plain browser build shows an empty library
+// (OPFS support is a follow-up).
+
+const ASSIGN_KEY = 'genregrid_instrument_assignments'
+
+// Module-level singletons so every consumer shares one library + assignment map.
+const instruments = ref<CustomInstrument[]>([])
+const assignments = ref<InstrumentAssignments>(loadAssignments())
+const panelOpen = ref(false)
+let loadedOnce = false
+
+function loadAssignments(): InstrumentAssignments {
+  if (typeof localStorage === 'undefined') return { defaults: {} }
+  try {
+    const raw = localStorage.getItem(ASSIGN_KEY)
+    if (raw) {
+      const parsed = JSON.parse(raw) as InstrumentAssignments
+      if (parsed && typeof parsed === 'object' && parsed.defaults) return parsed
+    }
+  } catch { /* corrupt/absent — start fresh */ }
+  return { defaults: {} }
+}
+
+function persistAssignments() {
+  if (typeof localStorage === 'undefined') return
+  localStorage.setItem(ASSIGN_KEY, JSON.stringify(assignments.value))
+}
+
+function storageApi() {
+  return typeof window !== 'undefined' ? window.electronAPI?.instruments : undefined
+}
+
+/** True when a persistent instrument store is available (the Electron shell). */
+export function customInstrumentsSupported(): boolean {
+  return !!storageApi()
+}
+
+// Cache of materialized instruments (object-URL manifests), keyed by id, so repeated
+// plays don't re-read the bytes or leak new object URLs each time.
+const materialized = new Map<string, LayeredSamplerManifest>()
+
+/**
+ * Read an instrument's audio over IPC and build a LayeredSampler manifest whose file
+ * references are blob: object URLs. Cached per instrument. Returns null if the
+ * instrument or the storage backend is unavailable. Use with LayeredSampler:
+ *   new LayeredSampler({ baseUrl: '', manifest })
+ */
+async function materialize(id: string): Promise<LayeredSamplerManifest | null> {
+  const cached = materialized.get(id)
+  if (cached) return cached
+  const inst = getInstrument(id)
+  const api = storageApi()
+  if (!inst || !api) return null
+
+  const files = await api.read(id)
+  const urlByName = new Map<string, string>()
+  for (const f of files) {
+    urlByName.set(f.name, URL.createObjectURL(new Blob([new Uint8Array(f.data)])))
+  }
+  const resolve = (v: string | string[]) =>
+    Array.isArray(v) ? v.map(x => urlByName.get(x) ?? x) : (urlByName.get(v) ?? v)
+
+  const manifest: LayeredSamplerManifest = {
+    layers: inst.manifest.layers.map(l => ({
+      maxVelocity: l.maxVelocity,
+      urls: Object.fromEntries(Object.entries(l.urls).map(([note, v]) => [note, resolve(v)])),
+    })),
+  }
+  materialized.set(id, manifest)
+  return manifest
+}
+
+function uuid(): string {
+  if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) return crypto.randomUUID()
+  return `inst-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+}
+
+/** Load the library index once (idempotent). Safe to call from any consumer. */
+async function ensureLoaded(): Promise<void> {
+  if (loadedOnce) return
+  loadedOnce = true
+  const api = storageApi()
+  if (!api) return
+  try {
+    instruments.value = await api.list()
+  } catch {
+    instruments.value = []
+  }
+}
+
+/**
+ * Import dropped files as a new custom instrument. Folder structure is preserved in
+ * each file's name (via webkitRelativePath) so velocity-layer subfolders map through
+ * `buildManifest`. Returns the created instrument, or null if nothing usable was found
+ * or storage is unavailable.
+ */
+async function importInstrument(
+  name: string,
+  kind: CustomInstrument['kind'],
+  files: File[],
+): Promise<CustomInstrument | null> {
+  const api = storageApi()
+  if (!api) throw new Error('Custom instruments need the desktop app.')
+
+  const named = files.map(f => ({ file: f, path: relPath(f) }))
+  const { manifest, mapped } = buildManifest(named.map(n => n.path))
+  if (mapped === 0 || manifest.layers.length === 0) return null
+
+  const id = uuid()
+  const inst: CustomInstrument = { id, name: name.trim() || 'Untitled', kind, manifest, createdAt: Date.now() }
+
+  const payload = await Promise.all(
+    named
+      .filter(n => /\.(mp3|wav|ogg|flac|m4a|aac)$/i.test(n.path))
+      .map(async n => ({ name: n.path, data: [...new Uint8Array(await n.file.arrayBuffer())] })),
+  )
+  await api.save(inst, payload)
+  instruments.value = [...instruments.value, inst]
+  return inst
+}
+
+// The path used both for the manifest and for storage. Folder uploads carry a
+// webkitRelativePath ("MyRhodes/hard/C4.mp3"); drop its redundant top segment so the
+// stored/served path matches what buildManifest derived the layer folder from.
+function relPath(f: File): string {
+  const rel = (f as File & { webkitRelativePath?: string }).webkitRelativePath
+  if (rel && rel.includes('/')) return rel.split('/').slice(1).join('/') || f.name
+  return f.name
+}
+
+async function deleteInstrument(id: string): Promise<void> {
+  const api = storageApi()
+  if (api) await api.remove(id)
+  instruments.value = instruments.value.filter(i => i.id !== id)
+  materialized.delete(id)
+  // Drop any assignments that referenced it.
+  let changed = false
+  for (const part of Object.keys(assignments.value.defaults) as PlayerPart[]) {
+    if (assignments.value.defaults[part] === id) { delete assignments.value.defaults[part]; changed = true }
+  }
+  for (const style of Object.keys(assignments.value.perStyle ?? {})) {
+    const m = assignments.value.perStyle![style]
+    for (const part of Object.keys(m) as PlayerPart[]) {
+      if (m[part] === id) { delete m[part]; changed = true }
+    }
+  }
+  if (changed) persistAssignments()
+}
+
+/** Assign (or clear, with id=null) a custom instrument to a part — globally, or for a
+ *  specific style when `styleId` is given. */
+function assignPart(part: PlayerPart, id: string | null, styleId?: string): void {
+  if (styleId) {
+    assignments.value.perStyle ??= {}
+    assignments.value.perStyle[styleId] ??= {}
+    if (id) assignments.value.perStyle[styleId][part] = id
+    else delete assignments.value.perStyle[styleId][part]
+  } else {
+    if (id) assignments.value.defaults[part] = id
+    else delete assignments.value.defaults[part]
+  }
+  persistAssignments()
+}
+
+function getInstrument(id: string): CustomInstrument | undefined {
+  return instruments.value.find(i => i.id === id)
+}
+
+export function useCustomInstruments() {
+  return {
+    instruments,
+    assignments,
+    panelOpen,
+    ensureLoaded,
+    importInstrument,
+    deleteInstrument,
+    assignPart,
+    getInstrument,
+    materialize,
+    supported: customInstrumentsSupported,
+  }
+}
diff --git a/frontend/src/composables/useMidiPlayer.ts b/frontend/src/composables/useMidiPlayer.ts
index de7cd82..dc270d3 100644
--- a/frontend/src/composables/useMidiPlayer.ts
+++ b/frontend/src/composables/useMidiPlayer.ts
@@ -12,11 +12,15 @@ import { ref } from 'vue'
 import * as Tone from 'tone'
 import { Midi } from '@tonejs/midi'
 import { downloadUrl } from '../services/api'
-import { getPianoSampler, getMasterCompressor, getBassBus, getMelodicBus, duckOnKick, resetBusLevels } from '../soundfonts/loader'
+import { getPianoSampler, getMasterLimiterNode, getBassBus, getMelodicBus, duckOnKick, resetBusLevels, makeMasterLimiter, applyMelodicFxPreset, setMasterTrimDb } from '../soundfonts/loader'
+import { MELODIC_FX_PRESETS, MASTER_TRIM_DB, fxFamilyFor } from '../soundfonts/fxPresets'
 import { drumCharacterForStyle } from '../soundfonts/drums'
 import { makeSynthKit } from '../soundfonts/synthDrums'
-import { getBassSampler } from '../soundfonts/bass'
+import { getBassSampler, SAMPLED_BASS_VOICES } from '../soundfonts/bass'
 import { getMelodicSamplerById, SAMPLED_VOICES } from '../soundfonts/melodic'
+import { LayeredSampler } from '../soundfonts/layeredSampler'
+import { resolvePartInstrument } from '../soundfonts/customInstruments'
+import { useCustomInstruments } from './useCustomInstruments'
 import { voiceFor } from './useStyleCatalog'
 import { encodeWav } from '../utils/wavEncoder'
 
@@ -115,12 +119,28 @@ function applyVolume(v: number) {
 // Volume is applied inside toggle() after Tone.start() — calling applyVolume here
 // would create the AudioContext at import time, which browsers block before a user gesture.
 
+// Instrument mode: 'samples' plays the confirmed-license sample sets where a voice
+// has one (piano, vibraphone) and synthesizes the rest; 'synth' synthesizes every
+// voice. Lets you A/B the sampled vs fully-synthetic sound, and is the seam a future
+// "bring your own samples" feature plugs into. Persisted across sessions.
+export type SampleMode = 'samples' | 'synth'
+const _savedMode = typeof localStorage !== 'undefined'
+  ? localStorage.getItem('genregrid_sample_mode')
+  : null
+const sampleMode = ref<SampleMode>(_savedMode === 'synth' ? 'synth' : 'samples')
+function setSampleMode(mode: SampleMode) {
+  sampleMode.value = mode
+  if (typeof localStorage !== 'undefined') localStorage.setItem('genregrid_sample_mode', mode)
+}
+
 // Cache parsed MIDI data per URL so the piano roll persists after stop
 const midiStore = ref<Record<string, MidiData>>({})
 
 let scheduledParts: Tone.Part[] = []
 // Per-play disposables — samplers and synths that are NOT globally cached
 let disposables: Tone.ToneAudioNode[] = []
+// Per-play user custom-instrument samplers (LayeredSampler isn't a ToneAudioNode)
+let customSamplers: LayeredSampler[] = []
 
 function cleanup() {
   isPaused.value = false
@@ -130,8 +150,10 @@ function cleanup() {
   resetBusLevels()   // never leave a sidechain duck applied after stop
   scheduledParts.forEach(p => p.dispose())
   disposables.forEach(d => d.dispose())
+  customSamplers.forEach(s => s.dispose())
   scheduledParts = []
   disposables = []
+  customSamplers = []
   durationSeconds.value = 0
   stopPositionPolling()
   currentlyPlaying.value = null
@@ -293,6 +315,13 @@ export function useMidiPlayer() {
       const isPad          = styleId ? PAD_STYLES.has(styleId) : false
       const isLofi         = styleId ? LOFI_STYLES.has(styleId) : false
 
+      // Retune the shared melodic FX chain + master loudness trim to this style's
+      // family, so each genre sits in its own space and at an even level. Kicked off
+      // here (may regenerate the reverb IR) and awaited before parts are scheduled.
+      const fxFamily = fxFamilyFor({ isPad, isLofi, isSynth, isMelodicSynth })
+      const fxReady = applyMelodicFxPreset(MELODIC_FX_PRESETS[fxFamily])
+      setMasterTrimDb(MASTER_TRIM_DB[fxFamily])
+
       // Pre-load all samplers + MIDI in parallel.
       // SYNTH_STYLES use synthesis for drums + bass — skip those sampler loads entirely.
       //
@@ -306,17 +335,24 @@ export function useMidiPlayer() {
         melody: voiceFor(styleId, 'melody'),
         arpeggio: voiceFor(styleId, 'arpeggio'),
       }
+      // 'synth' mode skips every sampler load, so the existing synth fallbacks below
+      // take over for all voices. In 'samples' mode a voice loads a sampler only if it
+      // has a confirmed-license set (SAMPLED_VOICES / SAMPLED_BASS_VOICES); everything
+      // else still synthesizes.
+      const useSamples = sampleMode.value === 'samples'
       const _samplerP = (v: string | null) =>
-        (v ? getMelodicSamplerById(v) : null) ?? Promise.resolve(null)
+        (useSamples && v ? getMelodicSamplerById(v) : null) ?? Promise.resolve(null)
       // The Salamander grand piano is the last-resort chords/melody voice, needed
       // only when the chords part has no sampled voice and no synth family fits.
-      const _chordsSampled = !!_partVoice.chords && SAMPLED_VOICES.has(_partVoice.chords)
+      const _chordsSampled = useSamples && !!_partVoice.chords && SAMPLED_VOICES.has(_partVoice.chords)
+      const _bassVoice = voiceFor(styleId, 'bass')
+      const _bassSampled = useSamples && !isSynth && !!_bassVoice && SAMPLED_BASS_VOICES.has(_bassVoice)
 
       const fetchUrl = url.startsWith('blob:') || url.startsWith('data:') ? url : downloadUrl(url)
       const [, buf, bassSampler, chordsSamp, melodySamp, arpSamp] = await Promise.all([
-        (!isSynth && !isPad && !isLofi && !isMelodicSynth && !_chordsSampled) ? getPianoSampler() : Promise.resolve(null),
+        (useSamples && !isSynth && !isPad && !isLofi && !isMelodicSynth && !_chordsSampled) ? getPianoSampler() : Promise.resolve(null),
         fetch(fetchUrl).then(r => r.arrayBuffer()),
-        isSynth ? Promise.resolve(null) : getBassSampler(voiceFor(styleId, 'bass')),
+        _bassSampled ? getBassSampler(_bassVoice) : Promise.resolve(null),
         _samplerP(_partVoice.chords),
         _samplerP(_partVoice.melody),
         _samplerP(_partVoice.arpeggio),
@@ -324,6 +360,32 @@ export function useMidiPlayer() {
 
       if (token !== _playToken) return
 
+      await fxReady            // reverb IR ready before the first note is scheduled
+      if (token !== _playToken) return
+
+      // Load any user custom instruments assigned to this style's parts. Every part
+      // can be user-sampled; a custom assignment overrides that part's built-in voice.
+      const customByPart: Partial<Record<PlayerPart, LayeredSampler>> = {}
+      if (useSamples) {
+        const ci = useCustomInstruments()
+        if (ci.supported()) {
+          await ci.ensureLoaded()
+          const parts: PlayerPart[] = ['chords', 'bass', 'melody', 'arpeggio', 'pads', 'counter_melody']
+          await Promise.all(parts.map(async (part) => {
+            const r = resolvePartInstrument(ci.assignments.value, styleId, part, null)
+            if (r.source !== 'custom') return
+            const manifest = await ci.materialize(r.id)
+            if (!manifest || manifest.layers.length === 0) return
+            const ls = new LayeredSampler({ baseUrl: '', manifest, volume: -6 })
+            await ls.loaded
+            ls.connect(part === 'bass' ? getBassBus() : getMelodicBus())
+            customByPart[part] = ls
+            customSamplers.push(ls)
+          }))
+          if (token !== _playToken) return
+        }
+      }
+
       const midi = new Midi(buf)
 
       // Cache parsed notes for the piano roll
@@ -344,8 +406,8 @@ export function useMidiPlayer() {
 
       Tone.getTransport().bpm.value = midi.header.tempos[0]?.bpm ?? 120
 
-      // Resolve piano fallback if still needed
-      const piano = (!isSynth && !isPad && !isLofi && !isMelodicSynth && !_chordsSampled)
+      // Resolve piano fallback if still needed (never in 'synth' mode — useSamples gates it)
+      const piano = (useSamples && !isSynth && !isPad && !isLofi && !isMelodicSynth && !_chordsSampled)
         ? await getPianoSampler()
         : null
 
@@ -371,7 +433,7 @@ export function useMidiPlayer() {
       // fallback are cached/shared with their own fx chains, so chords+melody reuse
       // that one instrument (acoustic styles read fine sharing a voice); only the
       // arpeggio gets a distinct pluck on top.
-      const voiceCache: Record<number, Tone.PolySynth | Tone.Sampler> = {}
+      const voiceCache: Record<number, Tone.PolySynth | LayeredSampler> = {}
 
       function makePanned(build: (out: Tone.ToneAudioNode) => Tone.PolySynth, pan: number): Tone.PolySynth {
         const panner = new Tone.Panner(pan).connect(getMelodicBus())
@@ -381,14 +443,18 @@ export function useMidiPlayer() {
 
       // channel 0 = chords, 2 = melody, 3 = arpeggio, 4 = pads,
       // 5 = counter-melody (see backend _PART_CHANNELS)
-      function getMelodicInstrument(channel: number, pan: number): Tone.PolySynth | Tone.Sampler {
+      function getMelodicInstrument(channel: number, pan: number): Tone.PolySynth | LayeredSampler {
         if (voiceCache[channel]) return voiceCache[channel]
 
+        // A user custom instrument assigned to this part overrides everything else.
+        const custom = customByPart[CHANNEL_PART[channel]]
+        if (custom) { voiceCache[channel] = custom; return custom }
+
         // Instrument-identity resolution first: a sampled voice loaded for
         // this part wins; a wind/brass "melody_lead" voice gets the articulate
         // soft lead (matches the breath-phrased writing). Anything unresolved
         // falls through to the legacy style-family logic below.
-        const _voiceSamplers: Record<number, Tone.Sampler | null> = { 0: chordsSamp, 2: melodySamp, 3: arpSamp }
+        const _voiceSamplers: Record<number, LayeredSampler | null> = { 0: chordsSamp, 2: melodySamp, 3: arpSamp }
         const _voiceIds: Record<number, string | null> = { 0: _partVoice.chords, 2: _partVoice.melody, 3: _partVoice.arpeggio }
         if (_voiceSamplers[channel]) {
           voiceCache[channel] = _voiceSamplers[channel]!
@@ -399,7 +465,7 @@ export function useMidiPlayer() {
           return voiceCache[2]
         }
 
-        let inst: Tone.PolySynth | Tone.Sampler
+        let inst: Tone.PolySynth | LayeredSampler
         if (channel === 4) {
           // Pads part — always the sustained pad voice, never the sampler, so
           // the layer washes behind the comp regardless of style.
@@ -424,8 +490,13 @@ export function useMidiPlayer() {
           inst = channel === 0
             ? makePanned(makePad, pan)
             : makePanned((out) => makeMelodyLead(true, out), pan)
+        } else if (piano) {
+          inst = piano                                // Salamander grand piano (shared)
         } else {
-          inst = piano!                               // Salamander grand piano (shared)
+          // 'synth' mode (or piano not loaded): synth comp for chords, lead for melody.
+          inst = channel === 0
+            ? makePanned(makeSynthChords, pan)
+            : makePanned((out) => makeMelodyLead(false, out), pan)
         }
         voiceCache[channel] = inst
         return inst
@@ -451,8 +522,9 @@ export function useMidiPlayer() {
           scheduledParts.push(part)
 
         } else if (channel === 1) {
-          // Bass — synthesis for electronic styles, sampler otherwise
-          const bassInst = isSynth ? getSynthBass() : bassSampler!
+          // Bass — a user custom instrument wins, then a sampled voice (samples mode +
+          // confirmed-license set), otherwise the synth bass (electronic/synth mode).
+          const bassInst = customByPart.bass ?? bassSampler ?? getSynthBass()
           const notes = track.notes.map(n => ({
             time: n.time, midi: n.midi, duration: n.duration, velocity: n.velocity,
           }))
@@ -541,7 +613,9 @@ export function useMidiPlayer() {
       await toggle(url, styleId, label)
       looping.value = wasLooping
 
-      const comp = getMasterCompressor()
+      // Tap the post-limiter node so the recording captures exactly what's heard
+      // (the master's soft-clip limiter included), not the pre-limiter mix.
+      const comp = getMasterLimiterNode()
       const recorder = new Tone.Recorder()
       comp.connect(recorder)
       recorder.start()
@@ -631,8 +705,10 @@ export function useMidiPlayer() {
         dest.volume.value = 0
         // Plain gain, not a Tone.Compressor — a DynamicsCompressorNode renders silence on
         // Linux packaged Electron (see getMasterCompressor in loader.ts), which would make
-        // WAV exports silent there too.
-        const comp = new Tone.Gain({ context, gain: 1 }).connect(dest)
+        // WAV exports silent there too. A WaveShaper soft-clip limiter after it catches
+        // peaks so the exported WAV can't clip, matching live playback's master chain.
+        const limiter = makeMasterLimiter(context).connect(dest)
+        const comp = new Tone.Gain({ context, gain: 1 }).connect(limiter)
 
         // Only needed so Transport-relative delay-time notation ('8n', '4n', …)
         // in the effects below resolves against the song's real tempo — no note
@@ -1001,18 +1077,21 @@ export function useMidiPlayer() {
     const isSynth = styleId ? SYNTH_STYLES.has(styleId) : false
     const isPad   = styleId ? PAD_STYLES.has(styleId)   : false
     const isLofi  = styleId ? LOFI_STYLES.has(styleId)  : false
-    // Synth/pad/lofi styles use in-memory oscillators — nothing to fetch.
-    // Drums are synthesized for every style now, so only bass/melodic samplers load.
-    if (isSynth || isPad || isLofi) return
+    // Synth/pad/lofi styles use in-memory oscillators — nothing to fetch; and 'synth'
+    // mode never loads samplers. Drums are synthesized for every style now, so only
+    // the confirmed-license bass/melodic sets warm here.
+    if (isSynth || isPad || isLofi || sampleMode.value !== 'samples') return
     // Warm the registry-selected sample sets for this style (best-effort).
     const melodicVoices = (['chords', 'melody', 'arpeggio'] as const)
       .map(part => voiceFor(styleId, part))
       .filter((v): v is string => !!v && SAMPLED_VOICES.has(v))
+    const bassVoice = voiceFor(styleId, 'bass')
+    const bassP = bassVoice && SAMPLED_BASS_VOICES.has(bassVoice) ? [getBassSampler(bassVoice)] : []
     Promise.all([
-      getBassSampler(voiceFor(styleId, 'bass')),
+      ...bassP,
       ...melodicVoices.map(v => getMelodicSamplerById(v)),
     ]).catch(() => { /* best-effort, ignore network errors */ })
   }
 
-  return { toggle, stop, currentlyPlaying, nowPlayingLabel, isLoading, getMidiData, prefetchMidi, prefetchSamplers, volume, setVolume, looping, setLooping, isRecording, exportAudio, offlineRender, isRendering, channelMuted, toggleMute, soloPart, seek, positionSeconds, durationSeconds, isPlayingUrl, isPaused, togglePause, cue, playCued, cuedLabel }
+  return { toggle, stop, currentlyPlaying, nowPlayingLabel, isLoading, getMidiData, prefetchMidi, prefetchSamplers, volume, setVolume, sampleMode, setSampleMode, looping, setLooping, isRecording, exportAudio, offlineRender, isRendering, channelMuted, toggleMute, soloPart, seek, positionSeconds, durationSeconds, isPlayingUrl, isPaused, togglePause, cue, playCued, cuedLabel }
 }
diff --git a/frontend/src/env.d.ts b/frontend/src/env.d.ts
index ca9509e..c328b02 100644
--- a/frontend/src/env.d.ts
+++ b/frontend/src/env.d.ts
@@ -15,6 +15,23 @@ interface ElectronAPI {
   startDrag: (filePath: string) => void
   checkForUpdates: () => Promise<{ status: string; version: string; latest?: string; message?: string }>
   logRendererError: (entry: { timestamp: string; context: string; message: string; stack?: string }) => Promise<void>
+
+  /** User custom-instrument storage (see docs/custom-instruments-design.md). Audio
+   *  lives under userData/instruments/<id>/ and is served back over the gginstr://
+   *  protocol; only the index (with manifests) round-trips through these calls. */
+  instruments?: {
+    /** Read the library index (instruments without their audio bytes). */
+    list: () => Promise<import('./soundfonts/customInstruments').CustomInstrument[]>
+    /** Persist one instrument + its audio files (name may include a sub-path). */
+    save: (
+      inst: import('./soundfonts/customInstruments').CustomInstrument,
+      files: Array<{ name: string; data: number[] }>,
+    ) => Promise<void>
+    /** Delete an instrument and its audio. */
+    remove: (id: string) => Promise<void>
+    /** Read every audio file for an instrument (name may include a sub-path). */
+    read: (id: string) => Promise<Array<{ name: string; data: number[] }>>
+  }
 }
 
 /** Custom Vite env vars (merges with vite/client's ImportMetaEnv). */
diff --git a/frontend/src/pages/HomePage.vue b/frontend/src/pages/HomePage.vue
index 89406d9..e7355fc 100644
--- a/frontend/src/pages/HomePage.vue
+++ b/frontend/src/pages/HomePage.vue
@@ -189,6 +189,7 @@
     <DownloadNamePrompt />
     <ErrorLogPanel />
     <RenderQueuePanel />
+    <InstrumentsPanel />
   </div>
 </template>
 
@@ -206,6 +207,7 @@ import ToastHost from '../components/ToastHost.vue'
 import DownloadNamePrompt from '../components/DownloadNamePrompt.vue'
 import ErrorLogPanel from '../components/ErrorLogPanel.vue'
 import RenderQueuePanel from '../components/RenderQueuePanel.vue'
+import InstrumentsPanel from '../components/InstrumentsPanel.vue'
 import { useErrorLog } from '../composables/useErrorLog'
 import { setStyleCatalog } from '../composables/useStyleCatalog'
 import { useRenderQueue } from '../composables/useRenderQueue'
diff --git a/frontend/src/soundfonts/bass.ts b/frontend/src/soundfonts/bass.ts
index 54679d2..ee338ce 100644
--- a/frontend/src/soundfonts/bass.ts
+++ b/frontend/src/soundfonts/bass.ts
@@ -10,6 +10,7 @@
  */
 import * as Tone from 'tone'
 import { getBassBus } from './loader'
+import { LayeredSampler, loadLayeredSampler } from './layeredSampler'
 
 // The per-style bass sample set now comes from the instrument registry: each
 // style's `instrumentation.bass` resolves to an instrument whose `playback_voice`
@@ -18,6 +19,13 @@ import { getBassBus } from './loader'
 // is the single source of truth (see docs/instrument-identity-design.md).
 const DEFAULT_INSTRUMENT = 'electric_bass_finger'
 
+// Bass voices with a confirmed-license sample set on disk. The MusyngKite-derived
+// bass sets (electric/acoustic/fretless/slap/synth) were removed for licensing
+// reasons — see docs/LICENSE_AUDIT.md — and no confirmed-CC0 bass-guitar library
+// covers them, so this is empty and all bass currently plays through the synth bass.
+// Drop a re-sourced CC0/CC-BY voice id here (and its samples) to re-enable sampling.
+export const SAMPLED_BASS_VOICES = new Set<string>()
+
 const BASS_SAMPLE_MAP: Record<string, string> = {
   A1: 'A1.mp3', C2: 'C2.mp3', E2: 'E2.mp3', G2: 'G2.mp3',
   A2: 'A2.mp3', C3: 'C3.mp3', E3: 'E3.mp3', G3: 'G3.mp3', A3: 'A3.mp3',
@@ -34,22 +42,21 @@ function buildBassFx(inst: string, out: Tone.ToneAudioNode): Tone.ToneAudioNode
   return out
 }
 
-const bassCache = new Map<string, Promise<Tone.Sampler>>()
+const bassCache = new Map<string, Promise<LayeredSampler>>()
 
-export function getBassSampler(voice?: string | null): Promise<Tone.Sampler> {
+export function getBassSampler(voice?: string | null): Promise<LayeredSampler> {
   const inst = voice ?? DEFAULT_INSTRUMENT
   if (bassCache.has(inst)) return bassCache.get(inst)!
 
   const fxInput = buildBassFx(inst, getBassBus())
 
-  const promise = new Promise<Tone.Sampler>((resolve, reject) => {
-    const sampler = new Tone.Sampler({
-      urls: BASS_SAMPLE_MAP,
-      baseUrl: `/samples/bass/${inst}/`,
-      volume: -4,
-      onload: () => resolve(sampler),
-      onerror: reject,
-    }).connect(fxInput)
+  const promise = loadLayeredSampler({
+    baseUrl: `/samples/bass/${inst}/`,
+    legacyUrls: BASS_SAMPLE_MAP,
+    volume: -4,
+  }).then((sampler) => {
+    sampler.connect(fxInput)
+    return sampler
   })
 
   bassCache.set(inst, promise)
diff --git a/frontend/src/soundfonts/customInstruments.test.ts b/frontend/src/soundfonts/customInstruments.test.ts
new file mode 100644
index 0000000..7c774f5
--- /dev/null
+++ b/frontend/src/soundfonts/customInstruments.test.ts
@@ -0,0 +1,124 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  isAudioFile,
+  parseSampleName,
+  buildManifest,
+  resolvePartInstrument,
+  type InstrumentAssignments,
+} from './customInstruments'
+
+describe('isAudioFile', () => {
+  it('accepts common audio extensions, rejects others', () => {
+    for (const f of ['a.mp3', 'a.WAV', 'a.ogg', 'a.flac', 'a.m4a']) expect(isAudioFile(f)).toBe(true)
+    for (const f of ['a.txt', 'a.json', 'a.png', 'velocity.json', 'a']) expect(isAudioFile(f)).toBe(false)
+  })
+})
+
+describe('parseSampleName', () => {
+  it('reads plain note names and normalises sharps', () => {
+    expect(parseSampleName('C4.mp3').note).toBe('C4')
+    expect(parseSampleName('A4.wav').note).toBe('A4')
+    expect(parseSampleName('F#3.ogg').note).toBe('F#3')
+    expect(parseSampleName('As3.mp3').note).toBe('A#3')   // 's' → '#'
+    expect(parseSampleName('Gb2.mp3').note).toBe('Gb2')   // flat preserved
+  })
+
+  it('ignores a name prefix and takes the trailing note', () => {
+    expect(parseSampleName('Piano_C4.mp3').note).toBe('C4')
+    expect(parseSampleName('MyRhodes-A3.wav').note).toBe('A3')
+  })
+
+  it('does not false-match letters glued to digits', () => {
+    expect(parseSampleName('Bass1.wav').note).toBeNull()
+    expect(parseSampleName('kick.wav').note).toBeNull()
+  })
+
+  it('reads a velocity-layer hint from the folder or a suffix', () => {
+    expect(parseSampleName('hard/C4.mp3').layer).toBe('hard')
+    expect(parseSampleName('soft/C4.mp3').layer).toBe('soft')
+    expect(parseSampleName('Vibes_C4_v2.mp3').layer).toBe('v2')
+    expect(parseSampleName('C4.mp3').layer).toBeNull()
+  })
+
+  it('reads a round-robin index', () => {
+    expect(parseSampleName('C4_rr1.mp3').rr).toBe(1)
+    expect(parseSampleName('C4_rr2.mp3').rr).toBe(2)
+    expect(parseSampleName('C4.mp3').rr).toBeNull()
+  })
+})
+
+describe('buildManifest', () => {
+  it('T1: a single un-pitched file becomes a one-shot at the default root', () => {
+    const { manifest, mapped, skipped } = buildManifest(['MySound.wav'])
+    expect(mapped).toBe(1)
+    expect(skipped).toEqual([])
+    expect(manifest.layers).toHaveLength(1)
+    expect(manifest.layers[0]).toEqual({ maxVelocity: 1, urls: { C4: 'MySound.wav' } })
+  })
+
+  it('skips non-audio files', () => {
+    const { skipped, mapped } = buildManifest(['C4.mp3', 'readme.txt', 'cover.png'])
+    expect(skipped).toEqual(['readme.txt', 'cover.png'])
+    expect(mapped).toBe(1)
+  })
+
+  it('T2: note-named files become one full-range layer, one zone per note', () => {
+    const { manifest } = buildManifest(['C4.mp3', 'E4.mp3', 'G4.mp3'])
+    expect(manifest.layers).toHaveLength(1)
+    expect(manifest.layers[0].maxVelocity).toBe(1)
+    expect(manifest.layers[0].urls).toEqual({ C4: 'C4.mp3', E4: 'E4.mp3', G4: 'G4.mp3' })
+  })
+
+  it('T3: velocity folders become ascending layers, top ceiling forced to 1', () => {
+    const { manifest } = buildManifest(['soft/C4.mp3', 'hard/C4.mp3', 'soft/E4.mp3', 'hard/E4.mp3'])
+    expect(manifest.layers).toHaveLength(2)
+    // soft ranks below hard, so layer 0 is soft with a fractional ceiling, layer 1 hard=1.
+    expect(manifest.layers[0].urls.C4).toBe('soft/C4.mp3')
+    expect(manifest.layers[0].maxVelocity).toBeCloseTo(0.5)
+    expect(manifest.layers[1].urls.C4).toBe('hard/C4.mp3')
+    expect(manifest.layers[1].maxVelocity).toBe(1)
+  })
+
+  it('T3: repeated note+layer files become round-robins, ordered by rr index', () => {
+    const { manifest } = buildManifest(['C4_rr2.mp3', 'C4_rr1.mp3'])
+    expect(manifest.layers[0].urls.C4).toEqual(['C4_rr1.mp3', 'C4_rr2.mp3'])
+  })
+
+  it('empty / all-skipped input yields no layers', () => {
+    expect(buildManifest(['notes.txt']).manifest.layers).toEqual([])
+  })
+})
+
+describe('resolvePartInstrument', () => {
+  const assignments: InstrumentAssignments = {
+    defaults: { bass: 'inst-bass', chords: 'inst-rhodes' },
+    perStyle: { jazz: { chords: 'inst-jazzpiano' } },
+  }
+
+  it('per-style override wins over the global default', () => {
+    expect(resolvePartInstrument(assignments, 'jazz', 'chords', 'electric_piano_1'))
+      .toEqual({ source: 'custom', id: 'inst-jazzpiano' })
+  })
+
+  it('falls back to the global default when no per-style override', () => {
+    expect(resolvePartInstrument(assignments, 'soul', 'chords', 'electric_piano_1'))
+      .toEqual({ source: 'custom', id: 'inst-rhodes' })
+  })
+
+  it('falls back to the registry voice when no assignment', () => {
+    expect(resolvePartInstrument(assignments, 'soul', 'melody', 'melody_lead'))
+      .toEqual({ source: 'builtin', voice: 'melody_lead' })
+    expect(resolvePartInstrument(null, 'soul', 'bass', null))
+      .toEqual({ source: 'builtin', voice: null })
+  })
+})
diff --git a/frontend/src/soundfonts/customInstruments.ts b/frontend/src/soundfonts/customInstruments.ts
new file mode 100644
index 0000000..9dd8f8b
--- /dev/null
+++ b/frontend/src/soundfonts/customInstruments.ts
@@ -0,0 +1,178 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import type { LayeredSamplerManifest, VelocityLayer } from './layeredSampler'
+import type { PlayerPart } from '../composables/useMidiPlayer'
+
+// ── User-uploaded custom instruments: pure core ──────────────────────────────
+// Turns a bag of user-dropped audio files into a LayeredSampler manifest, and
+// resolves which instrument (built-in registry voice or a user instrument) plays a
+// part. No audio, no storage, no framework here — just the mapping rules, so they
+// can be unit-tested without an AudioContext or Electron. See
+// docs/custom-instruments-design.md.
+
+/** A user instrument as stored in the library index (audio bytes live separately,
+ *  addressed by the manifest's file names relative to the instrument's base URL). */
+export interface CustomInstrument {
+  id: string
+  name: string
+  kind: 'melodic' | 'bass' | 'drums'
+  manifest: LayeredSamplerManifest
+  createdAt: number
+}
+
+/** Per-part instrument assignments: a global default map plus optional per-style
+ *  overrides. Values are custom-instrument ids. */
+export interface InstrumentAssignments {
+  defaults: Partial<Record<PlayerPart, string>>
+  perStyle?: Record<string, Partial<Record<PlayerPart, string>>>
+}
+
+const AUDIO_EXT = /\.(mp3|wav|ogg|flac|m4a|aac)$/i
+export function isAudioFile(name: string): boolean {
+  return AUDIO_EXT.test(name)
+}
+
+/** Parsed pieces of a sample filename: the pitch, an optional velocity-layer hint,
+ *  and an optional round-robin index. Any of them may be absent. */
+export interface ParsedSampleName {
+  note: string | null       // normalised, e.g. "C4", "A#3"
+  layer: string | null      // velocity-layer hint from a folder or _vN / soft|hard token
+  rr: number | null         // round-robin index (1-based) from _rrN
+}
+
+// A note token: letter A–G, optional accidental (# / s = sharp, b = flat), octave
+// (0–8, optionally negative), not glued to more letters/digits on the note side.
+const NOTE_RE = /(?:^|[^A-Za-z0-9])([A-Ga-g])(#|s|b)?(-?[0-8])(?![0-9A-Za-z])/g
+
+/** Extract note / velocity-layer / round-robin from a file path. `path` may include a
+ *  folder (e.g. "hard/C4.mp3"); the folder is used as a velocity-layer hint. */
+export function parseSampleName(path: string): ParsedSampleName {
+  const parts = path.split('/')
+  const base = parts[parts.length - 1].replace(AUDIO_EXT, '')
+  const folder = parts.length > 1 ? parts[parts.length - 2].toLowerCase() : ''
+
+  // Note: take the LAST note-like token so a prefix like "Piano" or "Bass" can't win.
+  let note: string | null = null
+  for (const m of base.matchAll(NOTE_RE)) {
+    const acc = m[2] === 's' ? '#' : (m[2] ?? '')
+    note = `${m[1].toUpperCase()}${acc}${m[3]}`
+  }
+
+  const rrMatch = base.match(/[._-]rr(\d+)/i)
+  const rr = rrMatch ? parseInt(rrMatch[1], 10) : null
+
+  // Layer hint: an explicit velocity token in the name, else the containing folder
+  // if it looks like a dynamics label (soft/hard/mf/…), else a _vN group.
+  const DYN = /(soft|hard|quiet|loud|pp|mp|mf|ff|p|f|v\d+)/i
+  const nameDyn = base.match(/[._-](soft|hard|quiet|loud|pp|mp|mf|ff|v\d+)\b/i)
+  let layer: string | null = nameDyn ? nameDyn[1].toLowerCase() : null
+  if (!layer && folder && DYN.test(folder)) layer = folder
+
+  return { note, layer, rr }
+}
+
+// Order velocity-layer hints from softest to loudest so we can assign ascending
+// velocity ceilings. Unknown labels sort after known ones, stably.
+const DYN_ORDER = ['pp', 'p', 'soft', 'quiet', 'mp', 'v1', 'mf', 'v2', 'v3', 'v4', 'f', 'loud', 'hard', 'ff']
+function dynRank(label: string): number {
+  const i = DYN_ORDER.indexOf(label.toLowerCase())
+  return i === -1 ? DYN_ORDER.length : i
+}
+
+export interface BuildManifestResult {
+  manifest: LayeredSamplerManifest
+  mapped: number       // files placed into the manifest
+  skipped: string[]    // non-audio / unusable paths
+}
+
+/**
+ * Build a LayeredSampler manifest from user-dropped files.
+ *
+ * - **T1 (one shot):** a single file with no parseable note → mapped to C4 and
+ *   pitch-shifted across the keyboard.
+ * - **T2 (note-named):** files named by note → one zone per note.
+ * - **T3 (velocity/round-robin):** files grouped by a velocity hint (folder or _vN /
+ *   soft|hard) become velocity layers; `_rrN` become round-robins within a note+layer.
+ *
+ * Returns the manifest plus counts. `defaultRoot` is where an un-pitched one-shot lands.
+ */
+export function buildManifest(paths: string[], defaultRoot = 'C4'): BuildManifestResult {
+  const audio = paths.filter(isAudioFile)
+  const skipped = paths.filter(p => !isAudioFile(p))
+
+  if (audio.length === 0) {
+    return { manifest: { layers: [] }, mapped: 0, skipped }
+  }
+
+  const parsed = audio.map(p => ({ path: p, ...parseSampleName(p) }))
+  const anyNote = parsed.some(p => p.note)
+
+  // One-shot: a lone file (or files with no notes at all) → single zone at the root.
+  if (!anyNote) {
+    const layer: VelocityLayer = {
+      maxVelocity: 1,
+      urls: { [defaultRoot]: audio.length === 1 ? audio[0] : audio },
+    }
+    return { manifest: { layers: [layer] }, mapped: audio.length, skipped }
+  }
+
+  // Group by velocity-layer hint (a single group when none are labelled).
+  const byLayer = new Map<string, typeof parsed>()
+  for (const p of parsed) {
+    const key = p.layer ?? ''
+    if (!byLayer.has(key)) byLayer.set(key, [])
+    byLayer.get(key)!.push(p)
+  }
+
+  const layerKeys = [...byLayer.keys()].sort((a, b) => dynRank(a) - dynRank(b))
+  const layers: VelocityLayer[] = layerKeys.map((key, idx) => {
+    // Ascending, evenly-spaced ceilings; the top layer always reaches 1.
+    const maxVelocity = idx === layerKeys.length - 1 ? 1 : (idx + 1) / layerKeys.length
+    const urls: Record<string, string | string[]> = {}
+    for (const p of byLayer.get(key)!) {
+      const note = p.note ?? defaultRoot
+      const existing = urls[note]
+      if (existing === undefined) urls[note] = p.path
+      else if (Array.isArray(existing)) existing.push(p.path)   // more round-robins
+      else urls[note] = [existing, p.path]
+    }
+    // Sort round-robin arrays by their rr index so cycling is deterministic.
+    for (const note of Object.keys(urls)) {
+      const v = urls[note]
+      if (Array.isArray(v)) {
+        v.sort((a, b) => (parseSampleName(a).rr ?? 0) - (parseSampleName(b).rr ?? 0))
+      }
+    }
+    return { maxVelocity, urls }
+  })
+
+  return { manifest: { layers }, mapped: audio.length, skipped }
+}
+
+/**
+ * Resolve which instrument plays a part: a user assignment wins over the registry
+ * voice. Returns either a custom-instrument id (with `source: 'custom'`) or the
+ * built-in registry voice (`source: 'builtin'`, possibly null → synth). Resolution
+ * order: per-style override → global default → registry voice.
+ */
+export function resolvePartInstrument(
+  assignments: InstrumentAssignments | null,
+  styleId: string | undefined,
+  part: PlayerPart,
+  registryVoice: string | null,
+): { source: 'custom'; id: string } | { source: 'builtin'; voice: string | null } {
+  if (assignments) {
+    const perStyle = styleId ? assignments.perStyle?.[styleId]?.[part] : undefined
+    const chosen = perStyle ?? assignments.defaults[part]
+    if (chosen) return { source: 'custom', id: chosen }
+  }
+  return { source: 'builtin', voice: registryVoice }
+}
diff --git a/frontend/src/soundfonts/drums.ts b/frontend/src/soundfonts/drums.ts
index 46ec8a4..7d8973b 100644
--- a/frontend/src/soundfonts/drums.ts
+++ b/frontend/src/soundfonts/drums.ts
@@ -8,9 +8,12 @@
  * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
  * <https://www.gnu.org/licenses/> for details.
  */
-import * as Tone from 'tone'
-import { getDrumBus } from './loader'
-
+// The live player synthesizes every drum kit (see synthDrums.ts, makeSynthKit).
+// This module only maps a style → a synth-kit "character". The old sampled kits
+// (getDrumKit / Tone.Players over /samples/drums/) were removed: they had no
+// callers, and the Tone.js drum samples they used carry no confirmed license
+// (see docs/LICENSE_AUDIT.md). STYLE_TO_KIT's names are retained purely as keys
+// into the character map below.
 const STYLE_TO_KIT: Record<string, string> = {
   // Acoustic kit — live drum feel
   jazz:            'acoustic-kit',
@@ -65,75 +68,8 @@ const KIT_TO_CHARACTER: Record<string, import('./synthDrums').DrumCharacter> = {
 
 /** Resolve the synthesized-drum character for a style (used by the live player). */
 export function drumCharacterForStyle(styleId?: string): import('./synthDrums').DrumCharacter {
-  // Styles without a sampled kit (grime, hyperpop) were pure-synthesis before —
+  // Styles without a mapped kit (grime, hyperpop) were pure-synthesis before —
   // give them a hard electronic character.
   const kit = (styleId && STYLE_TO_KIT[styleId]) ?? (styleId ? 'Techno' : DEFAULT_KIT)
   return KIT_TO_CHARACTER[kit] ?? 'acoustic'
 }
-
-// Kits that get light room reverb (acoustic sources benefit; electronic stays dry)
-const REVERB_KITS = new Set(['acoustic-kit', 'LINN'])
-const KIT_REVERB_PARAMS: Record<string, { decay: number; wet: number }> = {
-  'acoustic-kit': { decay: 0.7, wet: 0.16 },
-  'LINN':         { decay: 0.4, wet: 0.10 },
-}
-
-export const DRUM_PITCH_TO_SAMPLE: Record<number, string> = {
-  35: 'kick',  36: 'kick',
-  38: 'snare', 39: 'snare', 40: 'snare',
-  41: 'tom3',  43: 'tom3',
-  45: 'tom2',  47: 'tom2',
-  48: 'tom1',  50: 'tom1',
-  42: 'hihat', 44: 'hihat',
-  46: 'hihat_open',
-  49: 'crash', 52: 'crash', 55: 'crash', 57: 'crash',
-  51: 'ride',  53: 'ride',  59: 'ride',
-}
-
-const kitCache = new Map<string, Promise<Tone.Players>>()
-
-async function buildDrumFx(kitName: string, out: Tone.ToneAudioNode): Promise<Tone.ToneAudioNode> {
-  if (REVERB_KITS.has(kitName)) {
-    const params = KIT_REVERB_PARAMS[kitName]
-    const reverb = new Tone.Reverb({ decay: params.decay, wet: params.wet })
-    await reverb.generate()
-    reverb.connect(out)
-    return reverb
-  }
-  // Electronic kits: connect directly (dry)
-  return out
-}
-
-export function getDrumKit(styleId?: string): Promise<Tone.Players> {
-  const kitName = (styleId && STYLE_TO_KIT[styleId]) ?? DEFAULT_KIT
-  if (kitCache.has(kitName)) return kitCache.get(kitName)!
-
-  const bus = getDrumBus()
-  const base = `/samples/drums/${kitName}/`
-
-  const promise = buildDrumFx(kitName, bus).then(
-    (fxInput) =>
-      new Promise<Tone.Players>((resolve, reject) => {
-        const players = new Tone.Players(
-          {
-            kick:       base + 'kick.mp3',
-            snare:      base + 'snare.mp3',
-            hihat:      base + 'hihat.mp3',
-            // Open hihat/crash/ride: dedicated files where available; download_samples.py
-            // creates these from the hihat as a fallback for kits without real articulations.
-            hihat_open: base + 'hihat_open.mp3',
-            crash:      base + 'crash.mp3',
-            ride:       base + 'ride.mp3',
-            tom1:       base + 'tom1.mp3',
-            tom2:       base + 'tom2.mp3',
-            tom3:       base + 'tom3.mp3',
-          },
-          () => resolve(players),
-        ).connect(fxInput)
-        setTimeout(() => reject(new Error(`Drum kit "${kitName}" load timeout`)), 15_000)
-      }),
-  )
-
-  kitCache.set(kitName, promise)
-  return promise
-}
diff --git a/frontend/src/soundfonts/fxPresets.test.ts b/frontend/src/soundfonts/fxPresets.test.ts
new file mode 100644
index 0000000..c9a9113
--- /dev/null
+++ b/frontend/src/soundfonts/fxPresets.test.ts
@@ -0,0 +1,54 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import { describe, it, expect } from 'vitest'
+import { fxFamilyFor, MELODIC_FX_PRESETS, MASTER_TRIM_DB, type FxFamily } from './fxPresets'
+
+describe('fxFamilyFor', () => {
+  it('prioritises pad and lo-fi over the synth buckets', () => {
+    // A style can be both pad and synth (e.g. cinematic) — pad must win.
+    expect(fxFamilyFor({ isPad: true, isLofi: false, isSynth: true, isMelodicSynth: false })).toBe('pad')
+    expect(fxFamilyFor({ isPad: false, isLofi: true, isSynth: true, isMelodicSynth: false })).toBe('lofi')
+    expect(fxFamilyFor({ isPad: false, isLofi: false, isSynth: false, isMelodicSynth: true })).toBe('melodicSynth')
+    expect(fxFamilyFor({ isPad: false, isLofi: false, isSynth: true, isMelodicSynth: false })).toBe('synth')
+    expect(fxFamilyFor({ isPad: false, isLofi: false, isSynth: false, isMelodicSynth: false })).toBe('default')
+  })
+})
+
+describe('preset + trim tables', () => {
+  const families: FxFamily[] = ['default', 'synth', 'melodicSynth', 'pad', 'lofi']
+
+  it('defines an FX preset and a master trim for every family', () => {
+    for (const f of families) {
+      expect(MELODIC_FX_PRESETS[f]).toBeDefined()
+      expect(MASTER_TRIM_DB[f]).toBeTypeOf('number')
+    }
+  })
+
+  it('keeps every wet mix within a sane 0..1 range', () => {
+    for (const f of families) {
+      const p = MELODIC_FX_PRESETS[f]
+      for (const wet of [p.chorus.wet, p.delay.wet, p.reverb.wet]) {
+        expect(wet).toBeGreaterThanOrEqual(0)
+        expect(wet).toBeLessThanOrEqual(1)
+      }
+      expect(p.reverb.decay).toBeGreaterThan(0)
+    }
+  })
+
+  it('trims hot electronic families down and never boosts more than a little', () => {
+    expect(MASTER_TRIM_DB.synth).toBeLessThan(0)          // pulled down
+    expect(MASTER_TRIM_DB.default).toBe(0)                // reference level
+    for (const f of families) {
+      expect(MASTER_TRIM_DB[f]).toBeGreaterThanOrEqual(-6)
+      expect(MASTER_TRIM_DB[f]).toBeLessThanOrEqual(3)    // guard against runaway boost into the limiter
+    }
+  })
+})
diff --git a/frontend/src/soundfonts/fxPresets.ts b/frontend/src/soundfonts/fxPresets.ts
new file mode 100644
index 0000000..ba72525
--- /dev/null
+++ b/frontend/src/soundfonts/fxPresets.ts
@@ -0,0 +1,89 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import type { Unit } from 'tone'
+
+// ── Per-style master FX presets ──────────────────────────────────────────────
+// The shared melodic bus carries one chorus + feedback-delay, and a shared reverb
+// sits behind it (see loader.ts). Those used to be fixed for every style, so an
+// ambient wash and a funk comp got identical space. These presets retune that
+// shared chain per style FAMILY — the same families useMidiPlayer already derives
+// for voice selection — so each genre sits in its own room. loader.applyMelodicFx-
+// Preset() sets these live; only a changed reverb decay costs an IR regenerate.
+
+export interface MelodicFxPreset {
+  chorus: { frequency: number; depth: number; wet: number }
+  delay: { delayTime: Unit.Time; feedback: number; wet: number }
+  reverb: { decay: number; wet: number }
+}
+
+export type FxFamily = 'default' | 'synth' | 'melodicSynth' | 'pad' | 'lofi'
+
+export const MELODIC_FX_PRESETS: Record<FxFamily, MelodicFxPreset> = {
+  // Acoustic / pop / hip-hop with sampled voices — tasteful, present, not washy.
+  default: {
+    chorus: { frequency: 1.5, depth: 0.3, wet: 0.18 },
+    delay:  { delayTime: '8n.', feedback: 0.22, wet: 0.12 },
+    reverb: { decay: 1.6, wet: 0.22 },
+  },
+  // Electronic — more movement and rhythmic delay to fill the grid.
+  synth: {
+    chorus: { frequency: 1.2, depth: 0.5, wet: 0.28 },
+    delay:  { delayTime: '8n', feedback: 0.30, wet: 0.18 },
+    reverb: { decay: 1.4, wet: 0.18 },
+  },
+  // Trap/drill leads — tight and dry so the lead cuts; reverb stays short.
+  melodicSynth: {
+    chorus: { frequency: 1.0, depth: 0.2, wet: 0.10 },
+    delay:  { delayTime: '8n', feedback: 0.18, wet: 0.10 },
+    reverb: { decay: 1.1, wet: 0.14 },
+  },
+  // Ambient / cinematic / cloud — long lush tail, wide chorus, generous delay.
+  pad: {
+    chorus: { frequency: 0.7, depth: 0.6, wet: 0.35 },
+    delay:  { delayTime: '4n', feedback: 0.40, wet: 0.28 },
+    reverb: { decay: 3.2, wet: 0.38 },
+  },
+  // Lo-fi — slow wobbly chorus, gentle short room, restrained delay.
+  lofi: {
+    chorus: { frequency: 0.5, depth: 0.7, wet: 0.30 },
+    delay:  { delayTime: '8n.', feedback: 0.25, wet: 0.14 },
+    reverb: { decay: 1.2, wet: 0.20 },
+  },
+}
+
+// ── Loudness normalization ───────────────────────────────────────────────────
+// A per-family trim (dB) on the pre-limiter master so perceived loudness doesn't
+// jump when you switch styles. Dense electronic mixes run hot and get pulled down;
+// sparse/soft families sit near unity. These are calibrated starting points (a true
+// per-style LUFS target would need offline measurement) — safe to hand-tune by ear.
+// Applied via loader.setMasterTrimDb() when a style starts.
+export const MASTER_TRIM_DB: Record<FxFamily, number> = {
+  default: 0,        // sampled acoustic/pop — the reference level
+  synth: -2.5,       // four-on-the-floor + sidechain runs loud
+  melodicSynth: -1.5,
+  pad: 1.0,          // sustained washes read quieter than transient material
+  lofi: -0.5,
+}
+
+/** Resolve the FX family from the booleans useMidiPlayer already computes for a
+ *  style. Order matters: pad and lo-fi override the synth buckets. */
+export function fxFamilyFor(flags: {
+  isPad: boolean
+  isLofi: boolean
+  isSynth: boolean
+  isMelodicSynth: boolean
+}): FxFamily {
+  if (flags.isPad) return 'pad'
+  if (flags.isLofi) return 'lofi'
+  if (flags.isMelodicSynth) return 'melodicSynth'
+  if (flags.isSynth) return 'synth'
+  return 'default'
+}
diff --git a/frontend/src/soundfonts/layeredSampler.test.ts b/frontend/src/soundfonts/layeredSampler.test.ts
new file mode 100644
index 0000000..a939173
--- /dev/null
+++ b/frontend/src/soundfonts/layeredSampler.test.ts
@@ -0,0 +1,90 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  normalizeLayers,
+  selectLayerIndex,
+  roundRobinWidth,
+  urlsForRoundRobin,
+  type VelocityLayer,
+} from './layeredSampler'
+
+// The LayeredSampler class needs a real AudioContext (Tone.Sampler), so these
+// exercise the pure selection/loading logic that decides which sample plays.
+describe('LayeredSampler layer selection', () => {
+  const layers: VelocityLayer[] = [
+    { maxVelocity: 0.4, urls: { C4: 'soft/C4.mp3' } },
+    { maxVelocity: 0.75, urls: { C4: 'mid/C4.mp3' } },
+    { maxVelocity: 1, urls: { C4: 'hard/C4.mp3' } },
+  ]
+
+  it('picks the lowest layer whose ceiling covers the velocity', () => {
+    expect(selectLayerIndex(layers, 0.1)).toBe(0)
+    expect(selectLayerIndex(layers, 0.4)).toBe(0)  // inclusive upper bound
+    expect(selectLayerIndex(layers, 0.41)).toBe(1)
+    expect(selectLayerIndex(layers, 0.75)).toBe(1)
+    expect(selectLayerIndex(layers, 0.76)).toBe(2)
+    expect(selectLayerIndex(layers, 1)).toBe(2)
+  })
+
+  it('clamps out-of-range velocity to the top layer', () => {
+    expect(selectLayerIndex(layers, 1.5)).toBe(2)
+    expect(selectLayerIndex(layers, 99)).toBe(2)
+  })
+})
+
+describe('normalizeLayers', () => {
+  it('produces a single full-range layer from a legacy map', () => {
+    const out = normalizeLayers({ legacyUrls: { C4: 'C4.mp3', E4: 'E4.mp3' } })
+    expect(out).toHaveLength(1)
+    expect(out[0].maxVelocity).toBe(1)
+    expect(out[0].urls).toEqual({ C4: 'C4.mp3', E4: 'E4.mp3' })
+  })
+
+  it('sorts manifest layers ascending and forces the top ceiling to 1', () => {
+    const out = normalizeLayers({
+      manifest: {
+        layers: [
+          { maxVelocity: 0.9, urls: { C4: 'hard/C4.mp3' } }, // authored below 1 …
+          { maxVelocity: 0.3, urls: { C4: 'soft/C4.mp3' } },
+        ],
+      },
+    })
+    expect(out.map(l => l.maxVelocity)).toEqual([0.3, 1]) // sorted + top clamped to 1
+    expect(out[0].urls.C4).toBe('soft/C4.mp3')
+  })
+
+  it('prefers the manifest when both are supplied', () => {
+    const out = normalizeLayers({
+      manifest: { layers: [{ maxVelocity: 1, urls: { C4: 'a.mp3' } }] },
+      legacyUrls: { C4: 'legacy.mp3' },
+    })
+    expect(out[0].urls.C4).toBe('a.mp3')
+  })
+})
+
+describe('round-robin expansion', () => {
+  it('reports the widest note as the round-robin width', () => {
+    const layer: VelocityLayer = { maxVelocity: 1, urls: { C4: ['a.mp3', 'b.mp3'], E4: 'e.mp3' } }
+    expect(roundRobinWidth(layer)).toBe(2)
+  })
+
+  it('single-file notes have width 1', () => {
+    expect(roundRobinWidth({ maxVelocity: 1, urls: { C4: 'c.mp3', E4: 'e.mp3' } })).toBe(1)
+  })
+
+  it('maps each round-robin slot, reusing the last alternate for shorter notes', () => {
+    const layer: VelocityLayer = { maxVelocity: 1, urls: { C4: ['c0.mp3', 'c1.mp3'], E4: 'e.mp3' } }
+    expect(urlsForRoundRobin(layer, 0)).toEqual({ C4: 'c0.mp3', E4: 'e.mp3' })
+    // E4 has only one alternate, so slot 1 reuses it; C4 advances.
+    expect(urlsForRoundRobin(layer, 1)).toEqual({ C4: 'c1.mp3', E4: 'e.mp3' })
+  })
+})
diff --git a/frontend/src/soundfonts/layeredSampler.ts b/frontend/src/soundfonts/layeredSampler.ts
new file mode 100644
index 0000000..179c822
--- /dev/null
+++ b/frontend/src/soundfonts/layeredSampler.ts
@@ -0,0 +1,221 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import * as Tone from 'tone'
+
+// ── Multi-velocity / round-robin sampler ─────────────────────────────────────
+// Tone.Sampler maps one file per note-zone and only scales that file's gain by
+// note velocity — so a soft and a hard hit sound identical but louder, which reads
+// as synthetic, and a repeated note replays the exact same sample ("machine-gun"
+// effect). LayeredSampler wraps several Tone.Samplers to add the two things real
+// instruments have and Tone.Sampler lacks:
+//
+//   • Velocity layers — separate samples recorded (or filtered) at different
+//     dynamics; the incoming note velocity picks the layer, so timbre changes with
+//     dynamics, not just level.
+//   • Round-robins — several alternate samples for the same note+layer, cycled per
+//     hit so repeated notes don't machine-gun.
+//
+// It is a drop-in for the call sites' Tone.Sampler surface (triggerAttackRelease /
+// connect / disconnect / dispose) and degrades to exactly one inner Tone.Sampler
+// when handed a single-layer, single-round-robin set — so the legacy sample sets
+// keep working byte-for-byte until a `velocity.json` manifest adds layers.
+
+/** One velocity layer: an upper velocity bound plus the note→file(s) for it.
+ *  A string value is a single sample; an array is that note's round-robins. */
+export interface VelocityLayer {
+  /** Inclusive upper bound in Tone's 0..1 velocity range. The top layer should be 1. */
+  maxVelocity: number
+  urls: Record<string, string | string[]>
+}
+
+export interface LayeredSamplerManifest {
+  /** Velocity layers; order in the file does not matter — they are sorted ascending. */
+  layers: VelocityLayer[]
+}
+
+export interface LayeredSamplerOptions {
+  baseUrl: string
+  volume?: number
+  context?: Tone.BaseContext
+  /** Multi-layer set. Mutually exclusive with `legacyUrls`. */
+  manifest?: LayeredSamplerManifest
+  /** Single-layer legacy set: a plain note→file map (the pre-manifest format). */
+  legacyUrls?: Record<string, string>
+}
+
+// A layer normalized for playback: its velocity ceiling and one Tone.Sampler per
+// round-robin slot (samplers[i] holds the i-th alternate of every note).
+interface LoadedLayer {
+  maxVelocity: number
+  samplers: Tone.Sampler[]
+}
+
+// ── Pure helpers (unit-tested; no AudioContext needed) ───────────────────────
+
+/** Turn a manifest (or a legacy map) into layers sorted ascending by ceiling.
+ *  The returned layers always cover the full range — the top one is forced to 1. */
+export function normalizeLayers(opts: Pick<LayeredSamplerOptions, 'manifest' | 'legacyUrls'>): VelocityLayer[] {
+  if (opts.manifest && opts.manifest.layers.length > 0) {
+    const layers = [...opts.manifest.layers].sort((a, b) => a.maxVelocity - b.maxVelocity)
+    // Guarantee the loudest layer catches velocity 1.0 no matter how it was authored.
+    layers[layers.length - 1] = { ...layers[layers.length - 1], maxVelocity: 1 }
+    return layers
+  }
+  return [{ maxVelocity: 1, urls: opts.legacyUrls ?? {} }]
+}
+
+/** Pick the layer index for a velocity: the lowest layer whose ceiling covers it,
+ *  clamped to the top layer for anything at or above the last ceiling. */
+export function selectLayerIndex(layers: Pick<VelocityLayer, 'maxVelocity'>[], velocity: number): number {
+  for (let i = 0; i < layers.length; i++) {
+    if (velocity <= layers[i].maxVelocity) return i
+  }
+  return layers.length - 1
+}
+
+/** How many round-robin slots a layer needs: the widest note's alternate count. */
+export function roundRobinWidth(layer: VelocityLayer): number {
+  let width = 1
+  for (const v of Object.values(layer.urls)) {
+    if (Array.isArray(v)) width = Math.max(width, v.length)
+  }
+  return width
+}
+
+/** The note→file map for one round-robin slot of a layer. Notes with fewer
+ *  alternates than `rrIndex` reuse their last one, so uneven RR counts are fine. */
+export function urlsForRoundRobin(layer: VelocityLayer, rrIndex: number): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const [note, v] of Object.entries(layer.urls)) {
+    if (Array.isArray(v)) out[note] = v[Math.min(rrIndex, v.length - 1)]
+    else out[note] = v
+  }
+  return out
+}
+
+// ── The sampler ──────────────────────────────────────────────────────────────
+
+export class LayeredSampler {
+  /** Resolves once every inner Tone.Sampler has loaded its buffers. */
+  readonly loaded: Promise<void>
+  private layers: LoadedLayer[] = []
+  private rr = 0
+  private disposed = false
+
+  constructor(opts: LayeredSamplerOptions) {
+    const normalized = normalizeLayers(opts)
+    const pending: Promise<void>[] = []
+
+    for (const layer of normalized) {
+      const width = roundRobinWidth(layer)
+      const samplers: Tone.Sampler[] = []
+      for (let rr = 0; rr < width; rr++) {
+        pending.push(
+          new Promise<void>((resolve, reject) => {
+            const sampler = new Tone.Sampler({
+              ...(opts.context ? { context: opts.context } : {}),
+              urls: urlsForRoundRobin(layer, rr),
+              baseUrl: opts.baseUrl,
+              volume: opts.volume ?? 0,
+              onload: () => resolve(),
+              onerror: reject,
+            })
+            samplers.push(sampler)
+          }),
+        )
+      }
+      this.layers.push({ maxVelocity: layer.maxVelocity, samplers })
+    }
+
+    this.loaded = Promise.all(pending).then(() => undefined)
+  }
+
+  /** Play a note, choosing the velocity layer and cycling the layer's round-robins. */
+  triggerAttackRelease(
+    note: Tone.Unit.Frequency,
+    duration: Tone.Unit.Time,
+    time?: Tone.Unit.Time,
+    velocity = 1,
+  ): this {
+    const layer = this.layers[selectLayerIndex(this.layers, velocity)]
+    if (layer) {
+      const sampler = layer.samplers[this.rr++ % layer.samplers.length]
+      sampler.triggerAttackRelease(note, duration, time, velocity)
+    }
+    return this
+  }
+
+  /** Route every inner sampler to the destination (they sum there). */
+  connect(destination: Tone.InputNode): this {
+    for (const layer of this.layers) for (const s of layer.samplers) s.connect(destination)
+    return this
+  }
+
+  disconnect(destination?: Tone.InputNode): this {
+    for (const layer of this.layers) {
+      for (const s of layer.samplers) {
+        if (destination) s.disconnect(destination)
+        else s.disconnect()
+      }
+    }
+    return this
+  }
+
+  dispose(): this {
+    if (this.disposed) return this
+    this.disposed = true
+    for (const layer of this.layers) for (const s of layer.samplers) s.dispose()
+    return this
+  }
+}
+
+// How many velocity layers this instrument actually loaded (1 = legacy set).
+// Exposed for logging/diagnostics.
+export function layerCount(sampler: LayeredSampler): number {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (sampler as any).layers.length
+}
+
+/**
+ * Load a sample set that may or may not have velocity layers yet. Looks for a
+ * `velocity.json` manifest under `baseUrl`; if present the set plays with velocity
+ * layers + round-robins, otherwise it falls back to the passed single-layer map so
+ * instruments that haven't been re-sampled keep working unchanged.
+ *
+ * `baseUrl` must end in '/'. `legacyUrls` is the pre-manifest note→file map.
+ */
+export async function loadLayeredSampler(opts: {
+  baseUrl: string
+  legacyUrls: Record<string, string>
+  volume?: number
+  context?: Tone.BaseContext
+}): Promise<LayeredSampler> {
+  let manifest: LayeredSamplerManifest | undefined
+  try {
+    const res = await fetch(`${opts.baseUrl}velocity.json`, { cache: 'force-cache' })
+    if (res.ok) {
+      const parsed = (await res.json()) as LayeredSamplerManifest
+      if (parsed && Array.isArray(parsed.layers) && parsed.layers.length > 0) manifest = parsed
+    }
+  } catch {
+    // No manifest (404 / offline / parse error) — fall back to the legacy single layer.
+  }
+
+  const sampler = new LayeredSampler({
+    baseUrl: opts.baseUrl,
+    volume: opts.volume,
+    context: opts.context,
+    manifest,
+    legacyUrls: manifest ? undefined : opts.legacyUrls,
+  })
+  await sampler.loaded
+  return sampler
+}
diff --git a/frontend/src/soundfonts/loader.ts b/frontend/src/soundfonts/loader.ts
index f618f65..e6969f1 100644
--- a/frontend/src/soundfonts/loader.ts
+++ b/frontend/src/soundfonts/loader.ts
@@ -9,6 +9,8 @@
  * <https://www.gnu.org/licenses/> for details.
  */
 import * as Tone from 'tone'
+import { LayeredSampler, loadLayeredSampler, layerCount } from './layeredSampler'
+import type { MelodicFxPreset } from './fxPresets'
 
 // Salamander Grand Piano — bundled locally under public/samples/piano/ (served by
 // the renderer's static server) so the flagship piano works fully offline and
@@ -29,23 +31,83 @@ const SAMPLE_MAP: Record<string, string> = {
 
 // Module-level singletons — created once, reused across all plays
 let masterOut: Tone.Gain | null = null
+let masterLimiter: Tone.WaveShaper | null = null
 let reverb: Tone.Reverb | null = null
-let piano: Tone.Sampler | null = null
-let loadPromise: Promise<Tone.Sampler> | null = null
+let piano: LayeredSampler | null = null
+let loadPromise: Promise<LayeredSampler> | null = null
+
+// ── Master soft-clip limiter ─────────────────────────────────────────────────
+// A safety limiter on the master so a dense full arrangement can't peak past the
+// ceiling and clip the DAC. It's a WaveShaper (a static transfer curve), NOT a
+// DynamicsCompressor: a DynamicsCompressorNode renders SILENCE on Linux packaged
+// Electron (see getMasterCompressor below), which is exactly why the master itself is
+// a plain Gain. A WaveShaperNode works on every platform.
+//
+// The curve is unity (fully transparent) below the threshold, bends through a gentle
+// quadratic knee above it, and — because the Web Audio API clamps a WaveShaper's input
+// to [-1, 1] — flattens to the ceiling for anything at or above 0 dBFS. So quiet
+// material passes untouched and only loud peaks are caught and held under the ceiling.
+const SOFTCLIP_THRESHOLD = 0.6    // linear amplitude (≈ -4.4 dBFS): knee starts here
+const SOFTCLIP_CEILING   = 0.985  // linear amplitude (≈ -0.13 dBFS): absolute ceiling
+
+// Transfer curve for the master limiter. `x` is an AudioRange [-1, 1] sample value.
+// Exported for unit testing (the WaveShaper node itself needs an AudioContext).
+export function softClipCurve(x: number): number {
+  const a = Math.abs(x)
+  if (a <= SOFTCLIP_THRESHOLD) return x            // transparent below threshold
+  const R = 1 - SOFTCLIP_THRESHOLD
+  const H = SOFTCLIP_CEILING - SOFTCLIP_THRESHOLD
+  const b = (H - R) / (R * R)                      // slope 1 at the knee, ≤1 through it
+  const d = Math.min(a, 1) - SOFTCLIP_THRESHOLD    // inputs past 0 dBFS clamp to ceiling
+  return Math.sign(x) * (SOFTCLIP_THRESHOLD + d + b * d * d)
+}
+
+// Build a master limiter node. Pass an explicit context for offline (WAV) renders so
+// the node lives in the offline graph rather than the ambient one; omit it for live
+// playback. Oversampled to keep the harmonics the knee introduces from aliasing.
+export function makeMasterLimiter(context?: Tone.BaseContext): Tone.WaveShaper {
+  const ws = context
+    ? new Tone.WaveShaper({ context, mapping: softClipCurve, length: 4096 })
+    : new Tone.WaveShaper(softClipCurve, 4096)
+  ws.oversample = '4x'
+  return ws
+}
 
 // Master output node. This used to be a Tone.Compressor for mix glue, but a
 // DynamicsCompressorNode renders SILENCE to the hardware on Linux packaged Electron —
 // signal enters it (meters read it fine) yet nothing reaches the speakers, and since the
 // entire mix routes through this one node, the whole app was silent on Linux (Win/Mac were
-// unaffected). A plain Gain works on every platform, so the master is now a unity gain
-// straight to the destination. (Kept the name to avoid touching every call site.)
+// unaffected). A plain Gain works on every platform, so the master is a unity gain feeding
+// the soft-clip limiter, which then reaches the destination. (Kept the name getMaster-
+// Compressor to avoid touching every call site.)
 export function getMasterCompressor(): Tone.Gain {
   if (masterOut) return masterOut
-  masterOut = new Tone.Gain(1).toDestination()
-  console.log(`[audio] master gain created (ctx=${Tone.getContext().state}, sr=${Tone.getContext().rawContext.sampleRate}) → toDestination`)
+  masterOut = new Tone.Gain(1)
+  masterLimiter = makeMasterLimiter()
+  masterOut.connect(masterLimiter)                     // masterOut → limiter → speakers
+  masterLimiter.toDestination()
+  console.log(`[audio] master gain + soft-clip limiter created (ctx=${Tone.getContext().state}, sr=${Tone.getContext().rawContext.sampleRate}) → toDestination`)
   return masterOut
 }
 
+// Set the pre-limiter master trim, in dB, for cross-style loudness normalization
+// (see MASTER_TRIM_DB in fxPresets.ts). The trim sits before the soft-clip limiter,
+// so pulling a hot style down also eases it off the limiter. Ramped, not stepped,
+// so switching styles mid-session doesn't click.
+export function setMasterTrimDb(db: number): void {
+  const master = getMasterCompressor()
+  const now = Tone.getContext().currentTime
+  master.gain.cancelScheduledValues(now)
+  master.gain.setTargetAtTime(Tone.dbToGain(db), now, 0.02)
+}
+
+// The live master's post-limiter node — the final node before the speakers. Tap this
+// (not getMasterCompressor, which is pre-limiter) to record exactly what's heard.
+export function getMasterLimiterNode(): Tone.WaveShaper {
+  getMasterCompressor()      // ensure the master chain is built
+  return masterLimiter!
+}
+
 // ── Submix buses ───────────────────────────────────────────────────────────
 // Every instrument routes through its group bus before the master compressor,
 // so the three groups can be balanced against each other. The synthesized drum
@@ -110,38 +172,61 @@ export function resetBusLevels(): void {
   if (bassBus)    { bassBus.gain.cancelScheduledValues(0);    bassBus.gain.value = BASS_BUS_DB }
 }
 
+// Decay the shared reverb's IR is currently generated for. Regenerating an IR is
+// relatively costly, so applyMelodicFxPreset only does it when the decay changes.
+let reverbDecay = 1.6
+
 async function getSharedReverb(): Promise<Tone.Reverb> {
   if (reverb) return reverb
-  const r = new Tone.Reverb({ decay: 1.6, wet: 0.22 })
+  const r = new Tone.Reverb({ decay: reverbDecay, wet: 0.22 })
   await r.generate()
   r.connect(getMelodicBus())      // piano is a melodic voice — route through its bus
   reverb = r
   return r
 }
 
+// Retune the shared melodic FX chain (chorus + delay) and reverb to a style's
+// preset. Chorus/delay/reverb-wet are live parameter writes (no graph rebuild, no
+// audible glitch); the reverb IR is only regenerated when the target decay differs
+// from what's loaded. Call before scheduling a style's parts. See fxPresets.ts.
+export async function applyMelodicFxPreset(p: MelodicFxPreset): Promise<void> {
+  getMelodicBus()                 // ensure the shared chorus + delay exist
+  const rv = await getSharedReverb()
+
+  if (melodicChorus) {
+    melodicChorus.frequency.value = p.chorus.frequency
+    melodicChorus.depth = p.chorus.depth
+    melodicChorus.wet.value = p.chorus.wet
+  }
+  if (melodicDelay) {
+    melodicDelay.delayTime.value = p.delay.delayTime
+    melodicDelay.feedback.value = p.delay.feedback
+    melodicDelay.wet.value = p.delay.wet
+  }
+
+  rv.wet.value = p.reverb.wet
+  if (Math.abs(reverbDecay - p.reverb.decay) > 0.01) {
+    reverbDecay = p.reverb.decay
+    rv.decay = p.reverb.decay
+    await rv.generate()           // rebuild the IR only when the room size changed
+  }
+}
+
 /**
  * Load the Salamander piano sampler once and cache it.
  * Subsequent calls return the cached instance immediately.
  */
-export async function getPianoSampler(): Promise<Tone.Sampler> {
+export async function getPianoSampler(): Promise<LayeredSampler> {
   if (piano) return piano
   if (loadPromise) return loadPromise
 
-  loadPromise = getSharedReverb().then(
-    (rv) =>
-      new Promise<Tone.Sampler>((resolve, reject) => {
-        const sampler = new Tone.Sampler({
-          urls: SAMPLE_MAP,
-          baseUrl: BASE_URL,
-          volume: -6,
-          onload: () => {
-            piano = sampler
-            resolve(sampler)
-          },
-          onerror: reject,
-        }).connect(rv)
-      }),
-  )
+  loadPromise = getSharedReverb().then(async (rv) => {
+    const sampler = await loadLayeredSampler({ baseUrl: BASE_URL, legacyUrls: SAMPLE_MAP, volume: -6 })
+    sampler.connect(rv)   // piano is a melodic voice — route through its bus (via reverb)
+    piano = sampler
+    console.log(`[audio] piano loaded — ${layerCount(sampler)} velocity layer(s)`)
+    return sampler
+  })
 
   return loadPromise
 }
diff --git a/frontend/src/soundfonts/masterLimiter.test.ts b/frontend/src/soundfonts/masterLimiter.test.ts
new file mode 100644
index 0000000..d32a897
--- /dev/null
+++ b/frontend/src/soundfonts/masterLimiter.test.ts
@@ -0,0 +1,59 @@
+/*
+ * GenreGrid — a style-based MIDI generator.
+ * Copyright (C) 2026 Tw Dover
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+ * <https://www.gnu.org/licenses/> for details.
+ */
+import { describe, it, expect } from 'vitest'
+import { softClipCurve } from './loader'
+
+// The master soft-clip limiter's transfer curve. The WaveShaper node it feeds needs
+// a real AudioContext, so these test the pure math that defines its behaviour: quiet
+// signals pass untouched, loud peaks are held under the ceiling, and it never expands.
+describe('softClipCurve (master limiter transfer function)', () => {
+  const THRESHOLD = 0.6
+  const CEILING = 0.985
+
+  it('is perfectly transparent below the threshold', () => {
+    for (const x of [0, 0.1, 0.3, 0.5, THRESHOLD]) {
+      expect(softClipCurve(x)).toBeCloseTo(x, 12)
+      expect(softClipCurve(-x)).toBeCloseTo(-x, 12)
+    }
+  })
+
+  it('is an odd function (symmetric for positive/negative signals)', () => {
+    for (const x of [0.2, 0.65, 0.8, 1, 1.5]) {
+      expect(softClipCurve(-x)).toBeCloseTo(-softClipCurve(x), 12)
+    }
+  })
+
+  it('holds all output at or below the ceiling, even for over-unity input', () => {
+    for (const x of [0.7, 0.9, 1, 1.5, 4, 100]) {
+      expect(softClipCurve(x)).toBeLessThanOrEqual(CEILING + 1e-9)
+      expect(softClipCurve(x)).toBeGreaterThan(THRESHOLD) // still audibly present
+    }
+  })
+
+  it('reaches the ceiling exactly at 0 dBFS and clamps beyond it', () => {
+    expect(softClipCurve(1)).toBeCloseTo(CEILING, 6)
+    // Web Audio clamps a WaveShaper's input to [-1, 1]; the curve must be flat past it.
+    expect(softClipCurve(2)).toBeCloseTo(CEILING, 6)
+    expect(softClipCurve(10)).toBeCloseTo(CEILING, 6)
+  })
+
+  it('is monotonic and never expands (0 < slope ≤ 1) through the knee', () => {
+    let prev = softClipCurve(0)
+    for (let x = 0.001; x <= 1; x += 0.001) {
+      const y = softClipCurve(x)
+      const slope = (y - prev) / 0.001
+      expect(y).toBeGreaterThan(prev)          // strictly increasing
+      expect(slope).toBeGreaterThan(0)
+      expect(slope).toBeLessThanOrEqual(1 + 1e-6) // compresses, never boosts
+      prev = y
+    }
+  })
+})
diff --git a/frontend/src/soundfonts/melodic.ts b/frontend/src/soundfonts/melodic.ts
index 154a953..95c993d 100644
--- a/frontend/src/soundfonts/melodic.ts
+++ b/frontend/src/soundfonts/melodic.ts
@@ -10,6 +10,7 @@
  */
 import * as Tone from 'tone'
 import { getMelodicBus } from './loader'
+import { LayeredSampler, loadLayeredSampler } from './layeredSampler'
 
 // Per-part melodic voices come from the instrument registry (served via
 // /styles → voices.{chords,melody,arpeggio}, read with voiceFor()). This module
@@ -23,15 +24,12 @@ const MELODIC_SAMPLE_MAP: Record<string, string> = {
   A5: 'A5.mp3',
 }
 
+// Voices with a confirmed-license (CC0 / CC-BY) sample set on disk. Only these load
+// a sampler; every other voice is synthesized. The old MusyngKite-derived sets
+// (electric pianos, clavinet, accordion, organ, nylon guitar, strings) were removed
+// for licensing reasons — see docs/LICENSE_AUDIT.md — so they fall back to synths.
 const INSTRUMENT_VOLUME: Record<string, number> = {
-  vibraphone:            -3,
-  acoustic_guitar_nylon: -2,
-  clavinet:              -8,
-  accordion:             -5,
-  string_ensemble_1:     -3,
-  electric_piano_1:      -5,
-  electric_piano_2:      -6,
-  drawbar_organ:         -7,
+  vibraphone: -6,   // VCSL CC0, velocity-layered (peak-normalised → quieter than the old set)
 }
 const DEFAULT_VOLUME = -6
 
@@ -44,14 +42,6 @@ const DEFAULT_VOLUME = -6
 async function buildFxChain(inst: string, out: Tone.ToneAudioNode): Promise<Tone.ToneAudioNode> {
   switch (inst) {
 
-    case 'string_ensemble_1': {
-      // Long hall reverb — lush orchestral pad sound
-      const reverb = new Tone.Reverb({ decay: 2.8, wet: 0.38 })
-      await reverb.generate()
-      reverb.connect(out)
-      return reverb
-    }
-
     case 'vibraphone': {
       // Short room reverb + light chorus for shimmer
       const reverb = new Tone.Reverb({ decay: 1.2, wet: 0.28 })
@@ -62,53 +52,6 @@ async function buildFxChain(inst: string, out: Tone.ToneAudioNode): Promise<Tone
       return chorus
     }
 
-    case 'acoustic_guitar_nylon': {
-      // Warm room reverb — adds natural space without washing out the attack
-      const reverb = new Tone.Reverb({ decay: 1.5, wet: 0.22 })
-      await reverb.generate()
-      reverb.connect(out)
-      return reverb
-    }
-
-    case 'electric_piano_1': {
-      // Classic Rhodes treatment: chorus for movement + short verb for bloom
-      const reverb = new Tone.Reverb({ decay: 1.4, wet: 0.20 })
-      await reverb.generate()
-      reverb.connect(out)
-      const chorus = new Tone.Chorus({ frequency: 3, depth: 0.35, wet: 0.22 }).connect(reverb)
-      chorus.start()
-      return chorus
-    }
-
-    case 'electric_piano_2': {
-      // DX7 is naturally bright — minimal verb, no chorus
-      const reverb = new Tone.Reverb({ decay: 0.9, wet: 0.14 })
-      await reverb.generate()
-      reverb.connect(out)
-      return reverb
-    }
-
-    case 'clavinet': {
-      // Phaser for that wah-funk movement; stays dry and punchy (no reverb)
-      const phaser = new Tone.Phaser({ frequency: 2.5, octaves: 3, wet: 0.45 }).connect(out)
-      return phaser
-    }
-
-    case 'drawbar_organ': {
-      // Rotary / Leslie simulator via chorus
-      const chorus = new Tone.Chorus({ frequency: 3.5, depth: 0.55, wet: 0.5 }).connect(out)
-      chorus.start()
-      return chorus
-    }
-
-    case 'accordion': {
-      // Light room verb — keeps the attack crisp
-      const reverb = new Tone.Reverb({ decay: 1.0, wet: 0.16 })
-      await reverb.generate()
-      reverb.connect(out)
-      return reverb
-    }
-
     default: {
       // Fallback: gentle verb for anything not specifically handled
       const reverb = new Tone.Reverb({ decay: 1.1, wet: 0.15 })
@@ -119,8 +62,8 @@ async function buildFxChain(inst: string, out: Tone.ToneAudioNode): Promise<Tone
   }
 }
 
-// Cache: instrument name → promise resolving to the loaded Tone.Sampler
-const melodicCache = new Map<string, Promise<Tone.Sampler>>()
+// Cache: instrument name → promise resolving to the loaded sampler
+const melodicCache = new Map<string, Promise<LayeredSampler>>()
 // Cache: instrument name → promise resolving to the fx input node
 const fxCache = new Map<string, Promise<Tone.ToneAudioNode>>()
 
@@ -131,7 +74,7 @@ export const SAMPLED_VOICES = new Set(Object.keys(INSTRUMENT_VOLUME))
 
 /** Load a melodic sampler by voice id (instrument-registry playback_voice).
  *  Returns null for non-sampled voices — callers fall back to synth voices. */
-export function getMelodicSamplerById(inst: string): Promise<Tone.Sampler> | null {
+export function getMelodicSamplerById(inst: string): Promise<LayeredSampler> | null {
   if (!SAMPLED_VOICES.has(inst)) return null
 
   if (melodicCache.has(inst)) return melodicCache.get(inst)!
@@ -141,18 +84,15 @@ export function getMelodicSamplerById(inst: string): Promise<Tone.Sampler> | nul
   }
   const fxPromise = fxCache.get(inst)!
 
-  const promise = fxPromise.then(
-    (fxInput) =>
-      new Promise<Tone.Sampler>((resolve, reject) => {
-        const sampler = new Tone.Sampler({
-          urls: MELODIC_SAMPLE_MAP,
-          baseUrl: `/samples/melodic/${inst}/`,
-          volume: INSTRUMENT_VOLUME[inst] ?? DEFAULT_VOLUME,
-          onload: () => resolve(sampler),
-          onerror: reject,
-        }).connect(fxInput)
-      }),
-  )
+  const promise = fxPromise.then(async (fxInput) => {
+    const sampler = await loadLayeredSampler({
+      baseUrl: `/samples/melodic/${inst}/`,
+      legacyUrls: MELODIC_SAMPLE_MAP,
+      volume: INSTRUMENT_VOLUME[inst] ?? DEFAULT_VOLUME,
+    })
+    sampler.connect(fxInput)
+    return sampler
+  })
 
   melodicCache.set(inst, promise)
   return promise
diff --git a/scripts/build_velocity_samples.py b/scripts/build_velocity_samples.py
new file mode 100644
index 0000000..10bc658
--- /dev/null
+++ b/scripts/build_velocity_samples.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# GenreGrid — a style-based MIDI generator.
+# Copyright (C) 2026 Tw Dover
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
+# <https://www.gnu.org/licenses/> for details.
+"""Build velocity-layered sample sets for GenreGrid's sampled instruments.
+
+Tone.Sampler only scales one sample's gain by velocity, so a soft and a hard note
+sound identical but louder. GenreGrid's LayeredSampler (frontend/src/soundfonts/
+layeredSampler.ts) instead plays a different sample per velocity range — real
+dynamics — driven by a `velocity.json` manifest next to the samples. This script
+produces those layered sets: it downloads a source library's multi-dynamic WAVs,
+converts each to a trimmed, peak-normalised mono MP3 (matching the existing sample
+format), lays them out under frontend/public/samples/.../<layer>/, and writes the
+manifest.
+
+Instruments whose set has NO velocity.json keep playing as a single legacy layer,
+so this only needs to run for instruments you're upgrading.
+
+Requirements (dev-only; not part of the app):
+    pip install numpy soundfile lameenc
+
+Usage (from repo root):
+    python scripts/build_velocity_samples.py                 # all specs below
+    python scripts/build_velocity_samples.py vibraphone      # one instrument
+    python scripts/build_velocity_samples.py --list
+
+SOURCES & LICENSING. Each spec names its source and license. Only CC0 / public-
+domain sources are wired in here so the produced MP3s can ship with the GPL code
+(samples are data, licensed separately — see DATA_LICENSES.md). VCSL is CC0. Do
+not add a source here without confirming its license permits redistribution.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+import lameenc
+
+REPO = Path(__file__).parent.parent
+SAMPLES_DIR = REPO / "frontend" / "public" / "samples"
+CACHE = REPO / ".sample-cache"          # downloaded source WAVs (git-ignored)
+
+# ── Conversion settings ──────────────────────────────────────────────────────
+TRIM_THRESHOLD_DB = -45.0   # trim leading/trailing audio quieter than this
+TAIL_PAD_S = 0.15           # keep this much tail after the last loud sample
+PEAK_DB = -1.0              # normalise each sample to this peak
+MAX_TAIL_S = 6.0            # cap very long rings so files stay small
+MP3_BITRATE = 128
+
+
+@dataclass
+class Layer:
+    """One velocity layer: an inclusive upper velocity bound (0..1) and the source
+    WAV (relative to the spec's base URL) for each note. A list gives round-robins."""
+    name: str
+    max_velocity: float
+    notes: dict[str, str | list[str]]
+
+
+@dataclass
+class Spec:
+    group: str                       # 'melodic' | 'bass' | 'piano'
+    inst: str                        # sample dir name (matches the app's voice id)
+    base_url: str                    # source root; note paths are appended
+    license: str                     # for the log + DATA_LICENSES.md
+    layers: list[Layer] = field(default_factory=list)
+
+
+# ── Instrument specs ─────────────────────────────────────────────────────────
+# NOTE: VCSL (CC0) is an acoustic/orchestral library. It cleanly covers only a few
+# of GenreGrid's voices (vibraphone here; grand piano, marimba, upright exist too).
+# The electric/synth voices (Rhodes, clavinet, electric/synth bass, …) are NOT in
+# any single CC0 library and are intentionally absent — they keep their legacy
+# single-layer sets until a license-clean multi-velocity source is sourced.
+
+_VIB = "https://raw.githubusercontent.com/sgossner/VCSL/master/Idiophones/Struck%20Idiophones/Vibraphone/"
+_VIB_NOTES = ["C3", "E3", "G3", "B3", "D4", "F4", "A4", "C5", "E5"]
+
+SPECS: dict[str, Spec] = {
+    "vibraphone": Spec(
+        group="melodic",
+        inst="vibraphone",
+        base_url=_VIB,
+        license="VCSL (Versilian Community Sample Library) — CC0 / public domain",
+        layers=[
+            # Soft mallets for gentle playing; hard mallets when struck hard. The
+            # timbre — not just the level — changes with velocity.
+            Layer("soft", 0.5, {n: f"Soft%20Mallets/Vibes_soft_{n}_v2_rr1_Main.wav" for n in _VIB_NOTES}),
+            Layer("hard", 1.0, {n: f"Hard%20Mallets/Vibes_hard_{n}_v3_rr1_Main.wav" for n in _VIB_NOTES}),
+        ],
+    ),
+}
+
+
+def db_to_amp(db: float) -> float:
+    return float(10.0 ** (db / 20.0))
+
+
+def fetch(url: str) -> Path:
+    """Download to the cache (skip if present); return the local path."""
+    key = urllib.parse.quote(url, safe="")
+    dest = CACHE / key
+    if dest.exists():
+        return dest
+    CACHE.mkdir(parents=True, exist_ok=True)
+    urllib.request.urlretrieve(url, dest)
+    return dest
+
+
+def convert(src: Path, dst: Path) -> int:
+    """WAV → trimmed, peak-normalised mono MP3. Returns output byte size."""
+    data, sr = sf.read(str(src), always_2d=True)
+    mono = data.mean(axis=1)
+
+    # Trim leading/trailing near-silence, keeping a short tail.
+    thr = db_to_amp(TRIM_THRESHOLD_DB)
+    loud = np.where(np.abs(mono) > thr)[0]
+    if len(loud):
+        start = loud[0]
+        end = min(len(mono), loud[-1] + int(TAIL_PAD_S * sr))
+        mono = mono[start:end]
+    mono = mono[: int(MAX_TAIL_S * sr)]
+
+    # Peak-normalise.
+    peak = float(np.max(np.abs(mono))) or 1.0
+    mono = mono * (db_to_amp(PEAK_DB) / peak)
+
+    pcm = (np.clip(mono, -1.0, 1.0) * 32767.0).astype("<i2").tobytes()
+    enc = lameenc.Encoder()
+    enc.set_bit_rate(MP3_BITRATE)
+    enc.set_in_sample_rate(int(sr))
+    enc.set_channels(1)
+    enc.set_quality(2)
+    mp3 = enc.encode(pcm) + enc.flush()
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    dst.write_bytes(mp3)
+    return len(mp3)
+
+
+def build(spec: Spec) -> None:
+    out_dir = SAMPLES_DIR / spec.group / spec.inst
+    print(f"\n=== {spec.inst} ({spec.group}) ===\n  source: {spec.license}")
+    manifest_layers = []
+    total = 0
+
+    for layer in spec.layers:
+        urls: dict[str, str | list[str]] = {}
+        for note, rel in layer.notes.items():
+            rels = rel if isinstance(rel, list) else [rel]
+            out_rels: list[str] = []
+            for i, r in enumerate(rels):
+                src = fetch(spec.base_url + r)
+                suffix = f"_rr{i + 1}" if len(rels) > 1 else ""
+                out_name = f"{note}{suffix}.mp3"
+                size = convert(src, out_dir / layer.name / out_name)
+                total += size
+                out_rels.append(f"{layer.name}/{out_name}")
+                print(f"  ok    {layer.name}/{out_name}  ({size // 1024} KB)")
+            urls[note] = out_rels if len(out_rels) > 1 else out_rels[0]
+        manifest_layers.append({"maxVelocity": layer.max_velocity, "urls": urls})
+
+    manifest = {"layers": manifest_layers}
+    (out_dir / "velocity.json").write_text(json.dumps(manifest, indent=2) + "\n")
+    print(f"  wrote velocity.json — {len(spec.layers)} layers, {total // 1024} KB total")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Build velocity-layered sample sets.")
+    ap.add_argument("instruments", nargs="*", help="specific instruments (default: all)")
+    ap.add_argument("--list", action="store_true", help="list available specs and exit")
+    args = ap.parse_args()
+
+    if args.list:
+        for name, spec in SPECS.items():
+            print(f"{name:24} {spec.group:8} {spec.license}")
+        return
+
+    names = args.instruments or list(SPECS)
+    unknown = [n for n in names if n not in SPECS]
+    if unknown:
+        print(f"Unknown instrument(s): {', '.join(unknown)}", file=sys.stderr)
+        print(f"Available: {', '.join(SPECS)}", file=sys.stderr)
+        sys.exit(1)
+
+    for name in names:
+        build(SPECS[name])
+    print("\nDone. Re-run the app; upgraded instruments now load velocity layers.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/download_samples.py b/scripts/download_samples.py
deleted file mode 100644
index f3b059a..0000000
--- a/scripts/download_samples.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-# GenreGrid — a style-based MIDI generator.
-# Copyright (C) 2026 Tw Dover
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version. Distributed WITHOUT ANY WARRANTY. See the GNU General Public License
-# <https://www.gnu.org/licenses/> for details.
-"""
-Download free instrument samples into frontend/public/samples/.
-
-Sources:
-  Drums   — https://tonejs.github.io/audio/drum-samples/{Kit}/{file}.mp3
-  Bass    — https://gleitz.github.io/midi-js-soundfonts/MusyngKite/{inst}-mp3/{note}.mp3
-  Melodic — same gleitz base
-
-Run from repo root:
-  python scripts/download_samples.py
-"""
-
-import shutil
-import sys
-import urllib.request
-from pathlib import Path
-
-BASE_DIR = Path(__file__).parent.parent / "frontend" / "public" / "samples"
-
-# ---------------------------------------------------------------------------
-# Drum kits
-# ---------------------------------------------------------------------------
-DRUM_BASE = "https://tonejs.github.io/audio/drum-samples"
-DRUM_KITS = ["acoustic-kit", "CR78", "KPR77", "LINN", "R8", "Techno", "breakbeat8", "breakbeat13"]
-
-# Core files available in every kit
-DRUM_CORE = ["kick", "snare", "hihat", "tom1", "tom2", "tom3"]
-# Extra articulation files — attempted per kit; falls back to hihat copy if absent on CDN
-DRUM_EXTRAS = ["hihat_open", "crash", "ride"]
-
-# ---------------------------------------------------------------------------
-# Bass instruments  (denser notes — Sampler interpolates shorter distances)
-# ---------------------------------------------------------------------------
-GLEITZ_BASE = "https://gleitz.github.io/midi-js-soundfonts/MusyngKite"
-BASS_NOTES = ["A1", "C2", "E2", "G2", "A2", "C3", "E3", "G3", "A3"]
-BASS_INSTRUMENTS = [
-    "electric_bass_finger",
-    "slap_bass_1",
-    "fretless_bass",
-    "acoustic_bass",
-    "synth_bass_1",
-    "electric_bass_pick",
-]
-
-# ---------------------------------------------------------------------------
-# Melodic instruments  (denser notes — reduces pitch-stretch artefacts)
-# ---------------------------------------------------------------------------
-MELODIC_NOTES = ["A2", "C3", "E3", "G3", "A3", "C4", "E4", "G4", "A4", "C5", "E5", "G5", "A5"]
-MELODIC_INSTRUMENTS = [
-    "electric_piano_1",
-    "electric_piano_2",
-    "drawbar_organ",
-    "vibraphone",
-    "acoustic_guitar_nylon",
-    "clavinet",
-    "accordion",
-    "string_ensemble_1",
-]
-
-
-def note_to_gleitz_filename(note: str) -> str:
-    """Convert e.g. 'A#3' → 'As3' (gleitz uses 's' for sharps)."""
-    return note.replace("#", "s")
-
-
-def download(url: str, dest: Path) -> bool:
-    """Return True if downloaded, False if skipped or failed."""
-    if dest.exists():
-        print(f"  skip  {dest.name}")
-        return False
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    try:
-        urllib.request.urlretrieve(url, dest)
-        print(f"  ok    {dest.relative_to(BASE_DIR.parent.parent.parent)}")
-        return True
-    except Exception as e:
-        print(f"  FAIL  {url}  → {e}", file=sys.stderr)
-        return False
-
-
-def main() -> None:
-    print("=== Drum kits ===")
-    for kit in DRUM_KITS:
-        kit_dir = BASE_DIR / "drums" / kit
-        print(f"\n  kit: {kit}")
-
-        # Core samples
-        for file in DRUM_CORE:
-            url = f"{DRUM_BASE}/{kit}/{file}.mp3"
-            download(url, kit_dir / f"{file}.mp3")
-
-        # Extra articulations: try CDN first, copy hihat as fallback
-        hihat_src = kit_dir / "hihat.mp3"
-        for extra in DRUM_EXTRAS:
-            dest = kit_dir / f"{extra}.mp3"
-            if dest.exists():
-                print(f"  skip  {dest.name}")
-                continue
-            url = f"{DRUM_BASE}/{kit}/{extra}.mp3"
-            try:
-                urllib.request.urlretrieve(url, dest)
-                print(f"  ok    {dest.relative_to(BASE_DIR.parent.parent.parent)}")
-            except Exception:
-                # CDN doesn't have this articulation — copy hihat as placeholder
-                if hihat_src.exists():
-                    shutil.copy(hihat_src, dest)
-                    print(f"  copy  {dest.name} (hihat placeholder — replace with real sample)")
-                else:
-                    print(f"  skip  {dest.name} (no hihat to copy from yet)", file=sys.stderr)
-
-    print("\n=== Bass instruments ===")
-    for inst in BASS_INSTRUMENTS:
-        print(f"\n  {inst}")
-        for note in BASS_NOTES:
-            fname = note_to_gleitz_filename(note)
-            url = f"{GLEITZ_BASE}/{inst}-mp3/{fname}.mp3"
-            dest = BASE_DIR / "bass" / inst / f"{note}.mp3"
-            download(url, dest)
-
-    print("\n=== Melodic instruments ===")
-    for inst in MELODIC_INSTRUMENTS:
-        print(f"\n  {inst}")
-        for note in MELODIC_NOTES:
-            fname = note_to_gleitz_filename(note)
-            url = f"{GLEITZ_BASE}/{inst}-mp3/{fname}.mp3"
-            dest = BASE_DIR / "melodic" / inst / f"{note}.mp3"
-            download(url, dest)
-
-    print("\nDone.")
-    print("\nTip: for best drum quality, replace the hihat_open/crash/ride placeholders")
-    print("in frontend/public/samples/drums/ with real one-shots (freesound.org CC0).")
-
-
-if __name__ == "__main__":
-    main()