Euterpe → SOTA, Industry-Leading DAW — Gap Analysis (2026-06-07)

Question (standing goal): Are there any gaps left in Euterpe being the most SOTA, industry-leading DAW — in AI integration & utilization, UI/UX, and all other aspects of a DAW?

How this was produced: a 47-agent research workflow run on 2026-06-07 HEAD. Three axes — (A) internal truth: 13 code-grounded current-state audits re-verified against HEAD (the prior EUTERPE_SOTA_DAW_REMAINING_WORK_2026-06-06.md baseline was treated as stale, since 82 commits landed after it); (B) external SOTA benchmark: 6 web-research passes on the 2026 flagship-DAW field (Ableton 12, Logic Pro 11, FL Studio 2025, Cubase 14, Pro Tools 2025, Bitwig 5.3, Studio One 7, Reaper 7) and the AI-music frontier (Suno/Udio/Lyria, Demucs/Moises, iZotope/Sonible, C2PA/SynthID); (C) gap synthesis + adversarial verification: every headline "missing" claim was handed to a separate skeptic agent that tried to refute it against the code (17 claims were corrected from "missing" to "partial" on the deeper read). This document supersedes the 06-06 analysis as the current baseline.

0. The verdict (TL;DR)#

Yes — meaningful gaps remain. Euterpe is a genuinely deep, AI-native, music-theory-aware web DAW that has closed its prior central blocker (the linear arrangement/timeline engine now exists, Rust + wasm + reducer + UI, 92 tests) — but it is not yet SOTA on any of the three pillars.

Critic's bottom line: Yes — meaningful gaps remain; Euterpe is an impressive, genuinely-deep DAW that is not yet SOTA on any of the three pillars. Headline gaps, consistent across dimensions: (1) AI-native credibility — export provenance is only a one-line text label, not a signed C2PA manifest or imperceptible PCM/SynthID watermark (the single most-repeated P0, appearing in 5 dimensions), and the AI surface is realtime-stream-only with no one-shot text→editable-clip and no agent-writes-MIDI-to-arrangement; (2) UX parity — no Session/Clip-launch View (missing across 6 dimensions), no bus/aux mixer architecture, no unified modulation matrix, no take-comping; (3) everything-else — NO cloud-storage or real-time-collaboration backend at all, no native VST3/AU/CLAP plugin hosting (a web-platform boundary), and a large unwired-library debt where ~20 substantial @euterpe libraries (film/game scoring, conservatory, podcast, video, spatial, distribution, analytics) exist but the DAW imports only 5 of ~25. Of the 15 prior "entirely-missing" areas, seven have moved from absent to partial because the capability now exists as an unwired library; notation, control-surface (MCU/HUI/OSC), modular, multi-window, batch-processing, sample-pack-management, sound-design, and i18n remain fully absent.

This pass catalogs 186 residual gaps (P0 15 · P1 79 · P2 67 · P3 25). The most important structural fact about that backlog: 120 of 186 are local — pure web/wasm work that is buildable and unit-testable now, with no external blocker — and 47 are present-unwired: real, tested capability that already exists in an @euterpe/* library but was never wired into the DAW product. The dominant remaining work is wiring and surfacing existing capability, not inventing it. Only 14 gaps are native-desktop-bound (plugin hosting, CoreAudio/ASIO) and 26 are backend/cred-bound (cloud, collaboration, external AI providers).

Three-pillar verdict (from the completeness critic):

• AI integration & utilization — not yet SOTA. NOT yet SOTA. The foundation is genuinely strong and differentiated: on-device MRT2 realtime generation is wired live into the DAW mixer (generator-panel.tsx, fail-closed), plus transcribe and genesis. But three defining AI-native capabilities are missing in-product: (1) one-shot text-to-music producing an editable clip (AI-8, P0); (2) an agentic copilot that writes editable MIDI into the arrangement (AI-N1, P0); (3) real C2PA + audio watermark on AI-touched exports — currently only a text LABEL (RIGHTS-1/2, AI-19, P0). Plus neural stem separation (ARR-N1/UX-25/REC-N1) and polyphonic pitch-correction (AI-4) are unwired. SINGLE BIGGEST BLOCKER: provenance is a one-line string, not a signed C2PA manifest + imperceptible PCM watermark — an AI-native DAW that cannot cryptographically attribute or watermark its own AI output is not credible as SOTA.

• UI/UX — not yet SOTA. NOT yet SOTA. The linear-arrangement DAW UX is solid and broad (25 real components: arrangement-view, piano-roll, channel-strip, synth/sampler panels, automation lanes, master EQ/multiband, command palette, customizable keymap, a11y-aware). But the modern-DAW-defining nonlinear surface is entirely missing: no Session/Clip-launch View (ARR-7/UX-23/IO-N5/REC-4, P0), no take-comping lanes (UX-10/FX-18/REC-2), no bus/aux mixer architecture (MIX-2, P0), no unified modulation UI (UX-5, P0), no dockable/saveable screensets (UX-1), no notation editor, no semantic asset browser (UX-7), no i18n, single-window only. SINGLE BIGGEST BLOCKER: the absence of a Session/Clip-launch View — the one surface that separates a tracker/linear editor from a modern performance-capable DAW (Ableton/Bitwig/FL parity).

• All other DAW aspects — not yet SOTA (most gaps live here). NOT yet SOTA, and this pillar carries the most gaps. Engine internals are strong (Rust dsp-graph, f64 paths, real master/loudness/dither/goniometer, DAWproject I/O). But the structural debt dominates: ~20 substantial @euterpe libraries (score/film+game-audio, conservatory, podcast, video, spatial, distribution, analytics, samples, collab) are NOT wired into the product — the DAW imports only 5 of ~25 libs. Native-bound gaps (VST3/AU/CLAP hosting FX-11/IO-4; CoreAudio/ASIO ENG-1/PLAT-2; multicore scheduler ENG-4) cap pro parity on the web target. And there is NO cloud/collaboration layer at all (COLLAB-1/2 P0: no project store, no multiplayer). SINGLE BIGGEST BLOCKER: the absence of any cloud-storage + real-time-collaboration backend — every other 'other' gap is incremental, but a modern DAW with zero cloud project persistence or co-editing cannot claim SOTA.

1. ⚠️ Critical finding — the served audio-worklet bundle is stale#

The adversarial verification of ARR-8 surfaced a real correctness/build bug that is not a feature gap but invalidates several "shipped" features in the running app:

The compiled wasm/AudioWorklet bundle that the DAW actually loads is stale relative to the Rust source. Recently-landed DSP — clip fades / auto-crossfade (ARR-8), per-clip tempo multiplier (MIDI-19), the new trig-conditions (MIDI-17), and other dsp-graph changes — exists and is tested in Rust, but never reaches the engine the browser runs until the worklet bundle is rebuilt and re-served.

Action (do this first — it is S effort and silently un-breaks multiple committed features): rebuild the dsp-wasm / @euterpe/audio-engine-web worklet artifact and re-vendor it into apps/euterpe-studio-web, then add a CI/build check (or a build-hash assertion at engine init) so a stale bundle fails loudly instead of silently shipping last week's DSP. Until then, any in-browser verification of post-06-05 DSP features is testing old code.

2. What changed since the 2026-06-06 baseline#

P0 arrangement engine closed; 82 commits. The prior analysis's central P0 finding — "Euterpe has no clip-based arrangement/timeline; it is a step-sequencer + pattern generator, not a linear DAW" — is now CLOSED. Nine separate prior P0 entries (ARR-1/2/3, FX-17, UX-9, REC-1, IO-10, PLAT-7, AI-11) all pointed at the same missing spine; a single real stack now satisfies them.

Notable prior-P0/P1 closures (verified at file:line):

Per-dimension activity since 06-06 (82 commits total): ARR (timeline P0+clips) · ENG (f64/metering) · MIX (automation/multiband) · FX (synths/inserts) · MIDI (trig/groove) · MASTER (export/loudness) · IO (DAWproject/SMF) · UX (palette/undo) · PLAT (a11y) · REC (count-in) · AI (copilot) · COLLAB (autosave) · RIGHTS (none).

3. Aggregate residual-gap statistics#

186 residual gaps across the 13 dimensions, after adversarial verification.

Status mix: missing 84 · partial 53 · present-but-unwired 47 · polish 2. The 47 "present-unwired" gaps are the single most actionable cluster: the algorithm/engine work is already done and tested in a library; only the DAW wiring is missing. Combined with 120 local gaps, the headline is that most of the distance to SOTA is web/wasm wiring, not external blockers — the genuinely-hard boundaries are concentrated in just three areas: native plugin hosting + drivers (web-platform limit), a cloud/collaboration backend (no server today), and a handful of cloud-cred AI providers.

4. Consolidated headline themes#

The 15 P0 gaps and the heaviest P1 clusters collapse into a small set of recurring themes (several appear in multiple dimensions — e.g. Session View recurs across ARR/UX/REC/IO, plugin hosting across FX/IO/MIX):

1. AI-native provenance is only a text label, not real attribution. The single most-repeated P0 (5 dimensions): export provenance returns a one-line string; there is no signed C2PA Content Credentials manifest and no imperceptible PCM/SynthID-style watermark on AI-touched exports. RIGHTS-1/2, AI-19, MASTER-N2. AI · local · L. For an AI-native DAW this is the highest-leverage credibility gap.
2. No Session / Clip-launch View. The one surface that separates a linear editor from a modern performance DAW (Ableton/Bitwig/FL/Studio One all ship it): scenes, launch grid, follow-actions, capture-to-timeline. ARR-7, UX-23, REC-4, IO-N5. UX · local · XL.
3. AI surface is realtime-stream-only. No one-shot text→editable-clip (AI-8) and no agentic copilot that writes editable MIDI into the arrangement (AI-N1) — the copilot today emits transport/mix DawActions, not musical content. AI · local/cloud-cred · M.
4. Neural stem separation. Today's on-device separation is HPSS + mid/side (2-band); the 2026 baseline (Logic Stem Splitter, Ableton 12.3, Moises) is on-device 4-way (drums/bass/vocals/other). ARR-N1, IO-N4, UX-25. AI · local · XL.
5. No bus/aux mixer architecture. Routing is hardwired (track → inserts → fader → fixed reverb/delay sends → master); no user-created summing buses, no patch bay, no VCA groups surfaced. MIX-2 (+ routing-matrix P1). UX/Other · local.
6. No unified modulation system. Only a fixed cutoff-LFO + static macros; SOTA (Bitwig, Cubase 14 modulators) is any-source→any-target mod-matrix with free LFOs and envelope followers. UX-5, FX-7. UX · local · XL.
7. AI Master Assistant is unwired. @euterpe/master recommendChain exists but the one-click full-chain master recommendation (Logic Mastering Assistant / Ozone parity) is not surfaced. MASTER-N1. AI · local · M.
8. Third-party plugin hosting (VST3/CLAP/AU). Only built-in devices; a Tauri sidecar host is the path. FX-11, IO-4, MIX-22. Other · native-desktop · XL — a genuine web-platform boundary.
9. No cloud/collaboration layer at all. No project store, no real-time multi-user co-edit. COLLAB-1/2. Other · backend · XL.
10. Polyphonic pitch correction (Melodyne-class) and in-DAW notation/score editing (MusicXML staff) remain absent in-product. AI-4, MIDI-2. AI/Other · local.
11. The ~20-library "unwired debt." The DAW imports ~5 of ~25 @euterpe/* libraries; substantial real engines for film/game scoring, podcast, video, spatial, distribution (DDEX/ISWC), conservatory/education, and analytics exist off-DAW. Seven of the prior "entirely-missing" capability areas are really "present-but-unwired." Other · mostly local wiring.

5. Residual P0 + P1 roadmap#

All P0 and P1 gaps, after verification, sorted by severity then dimension. (Full P2/P3 catalog in Appendix B.)

6. Per-dimension deep dive#

Each section is the code-grounded current state + residual gaps for one dimension, after adversarial verification (the verification notes at the end of each section record any claim that was corrected on a second look).

6.1 Arrangement & Audio/Clip Editing (ARR)#

16 residual gaps — P0:2 P1:8 P2:5 P3:1

Euterpe's arrangement dimension has leapt forward, and the prior 2026-06-06 analysis is badly stale: the three P0 items it called "missing/partial" — the arrangement timeline UI, the multi-clip data model, and the per-clip scheduling engine — are all fully built and wired end-to-end at HEAD (verified in code). The DAW now has a genuine song-arrangement timeline: an SVG ArrangementView (one lane per track, bar/beat grid, engine-synced playhead, capture-based drag/resize, multiple snap modes including magnetic-to-transients, marquee multi-select, and a keyboard workflow) mounted in daw-app.tsx; a real ClipState model carrying startBeat/lengthBeats/offsetBeats/loopWithin/notes/gainDb/fadeInBeats/fadeOutBeats/tempoMult; a full reducer (addClip/moveClip/resizeClip/splitClip/duplicateClip/setClipGain/setClipFade/setClipLoop/setClipTempo/autoCrossfade/markers, each emitting an engine command); and a true per-clip Rust scheduler in dsp-graph (clip.rs with per-clip gain, equal-power sin crossfade, loop-within, offset, and a 0.0625–16× tempo multiplier — advance_arrangement drives both MIDI synth notes and loaded samples). Markers, per-clip static gain, split-at-playhead, smart selection, undo/redo, MIDI note thumbnails, an honest classic-DSP HPSS + Mid/Side stem separator, a WSOLA whole-sample warp in the sampler, and a generative session-player accompaniment are all wired. On the linear-arrangement core, Euterpe is at or near parity. The residual gaps cluster in four areas: a build-artifact hygiene gap (not, on re-verification, a live runtime regression), a large unwired SOTA editing library, several genuinely-absent flagship features, and an AI-stem-separation parity gap.

Two headline claims from the draft were corrected on adversarial re-verification (see Verification notes): ARR-8 was downgraded (the stale public worklet is auto-resynced from the 17-array source by predev/prebuild, so a real pnpm dev/pnpm build does NOT ship the 11-array bundle — the residue is a stale checked-in artifact plus a missing CI arity guard, not a feature that is dead at runtime), and ARR-5's evidence was corrected (WSOLA time-stretch IS wired, but only as a destructive whole-sample sampler warp; the non-destructive per-clip warp-marker / elastic-playback capability remains absent). All other headline gaps were confirmed.

Remaining gaps#

P0 — table stakes / blocking

P1 — expected by pros

P2 — valuable

P3 — nice to have

Where Euterpe leads#

Euterpe's per-clip Rust scheduler is genuinely strong: an equal-power sin crossfade whose two overlapping clips sum to constant power, a per-clip tempo multiplier spanning 0.0625–16× that re-schedules note content polyrhythmically against the song without time-stretch, and a single scheduler that drives BOTH MIDI-synth and audio-sample clips on one timeline — all behind a clean 17-array wasm encoding (and, contrary to the original draft, that 17-array encoding does reach a properly-built app, because predev/prebuild resync the served bundle). The equal-power auto-crossfade and the magnetic snap to detected transients (spectral-flux onset detection feeding clip-edge magnetism) are at the level of, or ahead of, the mainstream field. And as a browser/WASM DAW it already carries native-quality built-in DSP, which is precisely the dimension the cloud-collab DAWs (BandLab/Soundtrap) cannot match — leaving the multiplayer-collab + neural-AI axes (ARR-7, ARR-N1) as the place to press the advantage. The chief caveat is now an architectural one rather than a runtime one: several editing capabilities already exist as unwired library code (ARR-4/5/12/14b/N3) — the fastest wins are wiring, not greenfield.

Verification notes#

• ARR-8 — partial-exists (CORRECTED, downgraded P0/partial → P2/polish). The committed public bundle is genuinely stale (public/audio/euterpe-engine-processor.js:942/1695 passes 11 arrays vs source libs/euterpe/audio-engine-web/wasm/euterpe-engine-processor.js:976/1791 passing 17), and daw-app.tsx:83/121 loads /audio. BUT scripts/sync-engine-assets.mjs:24-27 copies the fresh 17-array source bundle into public/audio, and package.json:7/9 wire it to BOTH predev and prebuild — so a real pnpm dev/pnpm build resyncs the served bundle and the fades/crossfade/tempo features DO reach the running engine. The TS reducer already emits all 17 arrays (daw-session.ts:138/147-149/195-197). The real residue is the stale checked-in artifact plus the absence of any test/CI asserting the served-bundle arity (none found). The draft's "dead-on-arrival in the running app" framing was overstated.
• ARR-7 — confirmed-absent. arrangementMode (types.ts:437) is a label toggle only (arrangement-view.tsx:465-471; reducer effect daw-session.ts:1760-1769/1970 just flips clip-vs-note-clip playback). Zero matches for followAction/sessionView/clipLaunch/clipAlias/scene-launch. Gap stands.
• ARR-N1 — confirmed-absent. Wired separator is classic HPSS+M/S (daw-app.tsx:19/721, stem-separation.ts:2-10). The samples separateEightStems (stem-separation-sota.ts:227) is band-energy → mask/SDR planning math, not a neural separator, and is imported by no app. Gap stands (partial: classic present, neural absent).
• ARR-4 — confirmed-absent. extendClipStart/trimClip/nudgeClip exist (clip-editing.ts:563/527/299); only libs/calliope/muse imports @euterpe/studio (the aiFeatures submodule). DAW Drag mode is 'move' | 'resize' only (arrangement-view.tsx:53). Gap stands as present-unwired.
• ARR-5 — partial-exists (evidence CORRECTED). Per-clip warp markers / elastic arrangement playback are absent (no warpMarker/warpPoint; ClipState has no warp fields). However WSOLA time-stretch IS wired destructively at whole-sample scope (daw-app.tsx:707 warpSample → loadSampleWarped; sampler-panel.tsx:400-445; timestretch.rs:95/176, dsp-wasm/src/lib.rs:1297/1303). Status changed missing-headline retained; evidence updated to acknowledge the wired destructive path.
• ARR-9 — confirmed-absent. Single static tempoBpm (types.ts:316); only literal 4/4 (generate-clip.ts:206/246, dawproject.ts:142). No tempo map / meter track. Gap stands.
• ARR-7b — confirmed-absent. No takeLane/comping/compLane/swipeComp/takeFolder anywhere; "take" hits are BWF metadata, a recorded buffer name, and mixer.take(). ClipRecorder commits one take. Gap stands.
• ARR-14b — confirmed-absent. ClipState has static gainDb/fades only (types.ts:196/198/200); the breakpoint/lane types (types.ts:91-124) are track-level. Studio ClipAutomationLane (clip-editing.ts:1288/1331) imported by no app. Gap stands as present-unwired.
• ARR-12 — confirmed-absent. groove-clip.ts re-exports quantize/humanize only; theory/groove.ts has GROOVE_TEMPLATES(:433)/matchGrooveTemplate(:999) but no extractGroove/applyGroove and is unimported by the DAW. Gap stands as present-unwired.
• ARR-N2 — confirmed-absent. No retrospective/captureRecord/backgroundRecord; "ring buffer" hits are visualizer + AI-stream buffers. ClipRecorder records only when armed. Gap stands.
• ARR-N3 — confirmed-absent. clip-editing.ts (split/join/consolidate/crossfade/timeStretch/pitchShift/repeatToFill) + timeline.ts are real but only libs/calliope/muse imports @euterpe/studio; the DAW reducer re-implements a thinner model (has split/crossfade/fade, no consolidate/join). Gap stands as present-unwired.

6.2 MIDI & Composition#

10 residual gaps — P0:0 P1:5 P2:3 P3:2

Euterpe's MIDI & Composition layer has closed most of the editing-fundamentals gap and now sits at or near parity with the flagship field on the core symbolic axis. Verified-wired end-to-end this window (UI -> reducer -> Rust engine, with domain-correct tests): per-note ratchet/trig-probability/trig-conditions including if-prev/if-not-prev (deterministic SplitMix64 + Elektron-style condition table in clip.rs:32-102, tests clip.rs:426-573), clip-level tempo multiplier, an in-clip arpeggiator, strum/note-repeat/flam, partial-strength quantize+swing, scale-degree transpose, chord-voicing presets (close/open/drop2/drop3/shell), velocity ramp/randomize, humanize, one-click AI generate/vary/harmonize/inpaint from @euterpe/genesis, Standard-MIDI-File format-0/1 import+export, live Web-MIDI hardware input, and a Euclidean step sequencer. Two capabilities the brief listed as missing are in fact already present and wired, just shallow: an AI Session Player (session-player.ts generateAccompaniment -> daw-session.ts:1620 -> step-grid.tsx:136) that lays bass/arp/block-chord parts from chord symbols, and DAWproject (.dawproject) import+export (dawproject.ts -> daw-app.tsx:335,966), though the latter currently round-trips only notes+velocity+mixer vol/pan/mute. The remaining gaps are expressivity, notation, controller-mapping, and interop depth — the high-effort SOTA-bar items.\n\nOne adversarial-verification correction this pass: the prior draft claimed Euterpe "cannot read or write MusicXML." That is false at the monorepo level — libs/euterpe/theory/src/notation/notation.ts ships a real (non-stub) MusicXML 4.0 writer and parser (generateMusicXML:108, parseMusicXML:272) plus LilyPond/ABC. The genuine gap is narrower: that converter operates on a notation Score model and @euterpe/theory is not imported anywhere in the DAW app, so there is no clip-model round-trip and no staff render. MIDI-2 is accordingly downgraded from missing to partial and rescoped to DAW wiring + a staff view (see Verification notes).\n\n#### Remaining gaps\n\n| ID | Gap | Pillar | Sev | Status | Effort | Action |\n|----|-----|--------|-----|--------|--------|--------|\n| MIDI-1 | MPE / per-note expression (bend/pressure/timbre curves) in the DAW | UX | P1 | missing | XL | local |\n| MIDI-18 | MIDI-learn / CC + controller mapping to params | UX | P1 | missing | M | browser |\n| MIDI-2 | Notation/staff view in the DAW + MusicXML round-trip of the clip model | UX | P1 | partial | L | local |\n| MIDI-7 | MIDI-effects device chain (non-destructive note FX rack) | AI | P1 | partial | L | local |\n| MIDI-13 | Deep/real-time generative Session Player (genre models, reacts) | AI | P1 | partial | L | local |\n| IO-2 | DAWproject round-trip depth (expression/automation/sends/warp) | Other | P2 | partial | L | local |\n| MIDI-16 | Dedicated drum rack/sequencer (named pads, per-pad lanes) | UX | P2 | partial | M | local |\n| MIDI-9 | Chord track with chord-symbol-on-timeline driving parts | UX | P2 | partial | M | local |\n| MIDI-5 | Microtuning (Scala .scl/.kbm, MTS-ESP, temperaments) | Other | P3 | missing | L | local |\n| MIDI-14 | MIDI 2.0 / UMP + high-resolution CC | Other | P3 | missing | L | browser |\n\nP1 (expected by pros). MPE / per-note expression (MIDI-1) is the biggest expressivity hole — the DAW ClipNote carries only velocity (types.ts:142-162), SMF/Web-MIDI import discards pitch-bend (web-midi.spec.ts:29-30, midi-import.ts:146), and there is no expression lane or per-note synth modulation input; Ableton 12, Bitwig, Logic and Cubase all edit MPE, and DAWproject v1.0 treats note-expressions as first-class. (An isolated configureMpe channel-strip helper exists in libs/euterpe/studio/runtime-sota but is not wired into the DAW; it can seed the controller-zone mapping but is not the editing layer.) MIDI-learn (MIDI-18) is the highest value-to-effort fix: web-midi.ts:37 returns null for CC/bend/aftertouch, so no hardware knob can drive any param — a capability universal across the field and a few days' work on the parser plus a binding store. Notation/MusicXML (MIDI-2) — the converter already exists in @euterpe/theory (generateMusicXML/parseMusicXML), so the pragmatic first step is a thin DAW NoteClipState <-> Score adapter plus Export/Import actions (unit-testable now) before any staff rendering; Cubase 14's Dorico-powered Score Editor sets the long-term bar. MIDI-effects chain (MIDI-7) exists only as destructive one-shot clip transforms plus the live arp; Ableton MIDI Tools and Logic's MIDI-FX slots are a non-destructive, ordered, pre-instrument rack — Euterpe has all the transform bodies but no chain model. Session Player (MIDI-13) is wired but rule-thin (root/cycle/block-chord, equal slices, offline; session-player.ts:19-55); Logic 11's Bass Player has 8 styles with complexity/intensity dials reacting to the chord track in real time, and there is no Markov/probabilistic melodic layer in genesis (melody-gen is rule-based chord-tone probability, not a transition matrix).\n\nP2 (valuable). DAWproject depth (IO-2) — the round-trip works but is lossy (notes+velocity+vol/pan/mute only), dropping the automation, sends, fades, warp, and note-expressions the v1.0 spec carries. Drum rack (MIDI-16) — drum synthesis is real and wired but routed through the generic single-row sampler grid; Cubase 14's Drum Machine, Bitwig 5.3's drum devices + Stepwise, and Ableton's Drum Rack all offer per-pad multi-lane grids with choke groups. Chord track (MIDI-9) — voicings and ChordSymbol parsing exist, but there is no chord-symbol-on-timeline lane driving parts the way Logic/Studio One/Cubase chord tracks do.\n\nP3 (nice-to-have). Microtuning (MIDI-5) — the engine is hard 12-TET; Scala/MTS-ESP support is a sound-design/experimental nicety. MIDI 2.0 / UMP (MIDI-14) — best deferred until MPE and CC-mapping land, since UMP is their high-res transport and browser Web-MIDI UMP support is still nascent.\n\n#### Where Euterpe leads\n\nOn per-note probabilistic sequencing Euterpe is at or beyond the mainstream bar: the clip engine implements deterministic, reproducible per-note trig probability, ratcheting, and a full Elektron-style trig-condition table including if-prev/if-not-prev recurrence (clip.rs:32-102) with state-reconciliation playback — Elektron-grade conditional sequencing that most flagship DAWs expose only via third-party Max/MIDI-tool add-ons. Its one-click, in-piano-roll AI operations (generate diatonic melody, eight melodic transforms, harmonize counter-melody, symbolic Regen-½ inpainting) backed by the 2194-line genesis generator put symbolic generation directly in the editing surface rather than behind a separate device, which is a cleaner integration than several leaders' generator panels.\n\n#### Verification notes\n\n- MIDI-1 (MPE / per-note expression) — confirmed-absent (gap stands, evidence enriched). DAW ClipNote (apps/euterpe-studio-web/src/daw/types.ts:142-162) has no bend/pressure/timbre fields; web-midi.ts:37, web-midi.spec.ts:29-30, and midi-import.ts:145-146 all discard CC/pitch-bend/aftertouch. The configureMpe/MpeConfig helper in libs/euterpe/studio/src/runtime-sota/runtime-sota.ts:341 + types.ts:201-210 is real but is not imported anywhere under apps/euterpe-studio-web/src (grep clean) and is a controller channel-strip config, not a note-expression editing layer.\n- MIDI-18 (MIDI-learn / CC mapping) — confirmed-absent (gap stands). parseMidiMessage (web-midi.ts:23-38) handles only note-on/off; everything else returns null (web-midi.ts:37); midi-import.ts:146 ignores CC/aftertouch/program; no ccMap/MIDI-learn module or binding table exists in the app.\n- MIDI-2 (Notation / MusicXML) — partial-exists (CORRECTED: was missing). REFUTED headline: generateMusicXML (libs/euterpe/theory/src/notation/notation.ts:108-236) and parseMusicXML (notation.ts:272-317) are a real MusicXML 4.0 writer+parser (plus LilyPond/ABC), so Euterpe can read+write MusicXML. The surviving gap: they operate on the theory Score model (notation/types.ts:107), @euterpe/theory is not imported into the DAW app (grep clean), there is no ClipNote -> Score bridge, and no staff render. Status downgraded missing -> partial, effort XL -> L, recommendation rescoped to a clip<->Score adapter wired to the existing converter + a later staff view.\n- MIDI-7 (MIDI-effects chain) — confirmed-absent (status partial retained). No MidiEffect/NoteFx type, no pre-engine noteChain/applyNoteEffects path in daw-session.ts, insert-rack.tsx hosts only audio inserts (types.ts:11-26); destructive transform bodies exist but no non-destructive ordered rack.\n- MIDI-13 (Session Player depth) — partial-exists (status partial retained). Wired (session-player.ts:19-55 -> daw-session.ts:24,1620-1625 -> step-grid.tsx:136) but only 3 styles, equal slices, offline; genesis melody-gen is rule-based chord-tone probability (melody-gen/types.ts:89), not a Markov/transition-matrix generator (the markov/transition hits are confined to genesis/arrangement section-planning and sfx-foley).

6.3 Audio Engine & Performance (ENG)#

16 residual gaps — P0:0 P1:6 P2:6 P3:4

Euterpe's audio engine is, on the merits, a real and well-tested Rust/WASM DSP stack — not the thin shim the prior pass implied. Across dsp-core (24 modules, 134 domain-correct unit tests asserting values like LUFS = −3.01 dBFS at 0 dBFS/997 Hz), dsp-graph (84 tests) and dsp-wasm (48 tests), all 266 Rust tests pass, and I verified the recent batch against the code: denormal flush (ENG-6), windowed-sinc oversampling (ENG-8), BS.1770-4 true-peak (ENG-12), click-free mute + insert-bypass crossfades (ENG-13), live EBU-3342 LRA (ENG-15), auto make-up gain (ENG-16), a real CPU-load meter (ENG-20) and a selectable pan law (MIX-17, superseding ENG-10) are all genuinely wired through the worklet snapshot into the React UI. The signal path is allocation-free after construction with explicit subnormal flushing in every recursive feedback line, and the f64-internal path now covers biquad coefficients/state, the delay feedback line and the reverb comb/allpass stores. The metering and DSP-correctness story is close to SOTA.

The residual gaps are architectural and platform-level, and they verify cleanly against the source. The engine is WebAudio-only and stereo-only: there is no native driver crate (no cpal/CoreAudio/ASIO/WASAPI anywhere in any of the nine Cargo.toml files — mrt2-native is a napi-rs Node bridge for the generative engine, not an audio I/O driver), control flows over postMessage rather than a SharedArrayBuffer lock-free ring buffer, there is no WASM SIMD, the graph processes tracks in serial for loops (no rayon/work-stealing), the sampler holds whole files in a Vec<f32> (no OPFS/disk streaming into a voice), there is no plugin-delay-compensation pass despite latent inserts already existing, MIDI is input-only with no CC-learn binding, and automation is evaluated once per 128-frame block rather than per-sample. These are the things that separate a strong web DSP library from a flagship DAW engine.

Remaining gaps#

The defensible near-term wins are the local-actionable P1s: PDC (ENG-3) is the most glaring — Euterpe already ships latent inserts (oversamplers report latency()) but engine.rs never compensates (verified: no latency/compensate/predelay anywhere in it), so inserting an oversampled effect time-shifts that track against the mix. SharedArrayBuffer transport (ENG-N1) and OPFS streaming (ENG-7) are pure-web/browser work that close the gap to openDAW/Soundation-class web DAWs — and both have usable scaffolding already (a capability-negotiation predicate for SAB, a buildOpfsLayout path layout + a proven worklet ring-buffer producer/consumer for the AI-generator stream) that the real implementations can build on. MIDI-learn (ENG-21) is table-stakes UX buildable on the Web MIDI plumbing that already exists. The true XLs — native I/O (ENG-1) and multicore scheduling (ENG-4) — are gated on a Tauri/native shell and only matter together; they define the latency-and-scale ceiling but are not locally unit-testable today.

Where Euterpe leads#

Euterpe's broadcast-grade metering is at or above the bar most DAWs expose in-stock: a single streamed snapshot carries integrated/short-term/momentary LUFS, sample-peak, BS.1770-4 4× true-peak (dBTP), inter-channel correlation, live EBU-3342 LRA and an honest CPU-load fraction at ~23 Hz — a more complete loudness picture than the default meters in several flagship DAWs, and all computed from real f64 integrators rather than approximations. The DSP-correctness discipline (134 tests asserting known-correct values, forbidden unsafe, explicit denormal flushing in every feedback path) is genuinely strong and is the foundation the missing architecture should be built on, not replaced.

Verification notes#

I adversarially re-checked all six headline P1 gaps against the source, defaulting to skepticism that each might already be wired. All six are confirmed-absent — no gap was refuted or downgraded. Two evidence refinements were made where adjacent infrastructure exists but does not satisfy the claim:

• ENG-1 (native I/O) — confirmed-absent. Grep for cpal/coreaudio/asio/wasapi/jack/alsa/portaudio across all nine libs/euterpe Cargo.toml files returned nothing. mrt2-native/Cargo.toml is a napi-rs Node bridge (deps mrt2-core/mrt2-engine/napi/serde) for the generative engine — explicitly not an audio driver.
• ENG-N1 (SharedArrayBuffer transport) — confirmed-absent; evidence refined. Worklet transport is port.onmessage/port.postMessage (engine-processor.template.js:37/38/453/509). The only SharedArrayBuffer references (shell-runtime.ts:194/200) are a capability-negotiation predicate gating a "multi-track" feature on host support, not a lock-free command/meter ring buffer; no Atomics/crossOriginIsolated/COOP/COEP anywhere. Gap stands.
• ENG-4 (multicore) — confirmed-absent. engine.rs track processing is serial for loops (:313/:422/:430/:782/:856/:870/:978/:993); no par_iter/rayon/thread::spawn; no rayon/crossbeam in any Cargo.toml.
• ENG-7 (disk/OPFS sample streaming) — confirmed-absent; evidence refined. sampler.rs:20 holds data: Vec<f32> and load() (:70) replaces the whole Vec. The existing ring-buffer "streaming track" (audio-engine.ts:677 / realtime-stream-bridge.ts) is a live AI-generator PCM feed, not disk-file streaming; shell-runtime.ts:391 buildOpfsLayout only returns directory path strings + quota accounting — scaffolding, not a streamed sampler voice. Gap stands; recommendation updated to reuse that scaffolding.
• ENG-3 (PDC) — confirmed-absent. latency() exists only on Oversampler/FirLowpass (oversample.rs:67/142); engine.rs has zero latency/compensate/predelay references; the align hits in dsp-graph are an unrelated bypass-vector comment (track.rs:1122) and clip-loop alignment (clip.rs:371).
• ENG-21 (MIDI-learn) — confirmed-absent. web-midi.ts decodes only note-on/off and explicitly returns null for control-change; no 0xB0/learn/CC-binding store. The "learn" in daw-session.ts:550 is "learn the track index" (creation order); other "cc" hits are clearNoteClip substrings.

6.4 Mixing, Routing & Metering (MIX)#

14 residual gaps — P0:1 P1:8 P2:4 P3:1

At HEAD (2026-06-07) Euterpe's mixing and metering surface is at or near flagship parity on the per-channel and metering axes, and trails the SOTA bar only on structural routing, immersive audio, plugin hosting, and the deeper automation/sidechain/send flexibility that mixing pros expect. The native DAW (apps/euterpe-studio-web/src/daw/daw-session.ts + the Rust/WASM libs/euterpe/audio-engine) ships a real channel strip (gain, constant-power pan, mute/solo, a 3-law pan selector wired to dsp_core::PanLaw, post-fader reverb+delay sends with automation, a reorderable 10+ insert rack), a master chain (5-band EQ + stereo-linked compressor with a sidechain key-track, a 3-band Linkwitz-Riley multiband-dynamics processor, limiter, and M/S width), and a metering suite that is genuinely SOTA-adjacent and fully live end-to-end: BS.1770-4 4x-oversampled true-peak, phase correlation, integrated/short-term/momentary LUFS, app-side LRA, DSP CPU load, a goniometer/vectorscope, a log-FFT spectrum, and a scrolling loudness-history graph. A heavy recent wave closed roughly a dozen items the prior doc marked missing — per-insert-parameter automation incl. EQ band-gain (MIX-7), automation Write mode (MIX-6), the non-destructive monitor section (MIX-11), master multiband (MIX-23), the pan-law selector (MIX-17), the goniometer (MIX-14) and correlation meter (MIX-13), short-term/momentary LUFS (MIX-5), loudness history (MIX-24), mix snapshots with A/B (MIX-8), track folders (MIX-25), per-clip gain (MIX-10), and the true-peak/LRA/CPU meters (ENG-12/15/20).

The decisive structural finding: libs/euterpe/studio/src/mixer/mixer.ts is now a real 2003-line, unit-tested (mixer.spec.ts) implementation of VCA groups (createVCAGroup, line 1229), bus channels (createBusChannel, line 754), a routing matrix with feedback detection (createRoutingMatrix, line 1081 / wouldCreateFeedbackLoop, line 1201), and surround pan (calculateSurroundPan, line 332) — but the DAW app never imports @euterpe/studio (verified: the app's only @euterpe/* imports are audio-engine-web, core, genesis, master, transcribe; the lone '@euterpe/studio' string in app src is a doc-comment for the unrelated @euterpe/studio-web package). So the routing layer that would lift Euterpe to parity already exists as tested library code and is purely a wiring job, not new DSP. The remaining true gaps cluster into routing (present-unwired, local), immersive audio + plugin hosting (XL, native), and automation/sidechain/send depth + provenance-on-export.

Remaining gaps#

P0 — table stakes

P1 — expected by pros

P2 — valuable

P3 — nice to have

Where Euterpe leads#

Euterpe's metering suite is unusually deep for a browser DAW and competitive with dedicated tools (iZotope Insight, Voxengo SPAN): true-peak (BS.1770-4 4x-oversampled), integrated + short-term + momentary LUFS (the full EBU R128 I/S/M set), live LRA, phase correlation, goniometer/vectorscope, log-spaced FFT, scrolling loudness history, and a DSP CPU-load readout — all computed in a real Rust/WASM engine and pulled live by the worklet, not approximated in JS. The 3-band Linkwitz-Riley master multiband, the selectable pan-law (incl. the -4.5 dB compromise law many DAWs omit), per-insert-parameter automation down to individual EQ band-gain, and the offline-render-then-measure Auto-Mix driving the real @euterpe/master assistant are all genuinely strong. The gap to the leaders is concentrated in structure (buses/VCA/routing — which already exists in mixer.ts and just needs wiring), immersive audio, and native plugin hosting, not in the signal-processing or metering core.

Verification notes#

All nine headline claims were adversarially re-checked against the codebase; every gap stands. One evidence correction.

• MIX-2 — confirmed-absent. createBusChannel (mixer.ts:754) is real + tested (mixer.spec.ts:51,797) but @euterpe/studio is never imported by the app (only doc-comment in index.ts:2 for the different @euterpe/studio-web). Engine has exactly two fixed shared aux buses (engine.rs:45-56); folders don't sum (daw-session.ts:2006-2076, 'audio unchanged → no engine command').
• MIX-1 — confirmed-absent. createVCAGroup/addChannelToVCA/setVCAFader (mixer.ts:1229/1242/1259) real + tested (mixer.spec.ts:82), zero real VCA refs in app src (only an unrelated 'vcall' in piano-roll.spec.tsx:64).
• MIX-3 — confirmed-absent. createRoutingMatrix/wouldCreateFeedbackLoop (mixer.ts:1081/1201) real + tested (mixer.spec.ts:71,1005), no routingMatrix/patchBay in app.
• MIX-4 — confirmed-absent. channel-strip.tsx:178-195 has exactly two fixed post-fader sends (Reverb/Delay); engine.rs:274/289 both post-fader; setSendType lives only in unwired mixer.ts:701.
• MIX-26 — confirmed-absent. types.ts:455 automationMode is exactly 'read' | 'write' (setAutomationMode action types.ts:620 likewise); no touch/latch/trim tokens.
• MIX-27 — confirmed-absent. Sidechain key bus exists only on the master comp (engine.rs:57/304-305); no sidechain in insert-rack.tsx; dsp-core compressor has no sidechain input (only a tremolo.rs:2 doc-comment mentions 'sidechain').
• MIX-28 — confirmed-absent. libs/euterpe/spatial (ambisonics/atmos/binaural/spatial-upmix/vr-audio) + mixer.ts:332 calculateSurroundPan exist but are unused by the app; bwf.ts has no 5.1/7.1/multichannel/ADM.
• MIX-29 — confirmed-absent. Insert factory in daw-session.ts is all first-party DSP; no vst/clap/plugin-host refs (the 'clap' hits are the drum-synth clap voice).
• MIX-35 — partial-exists, EVIDENCE CORRECTED. The DAW-export-relevant claim stands: daw-app.tsx export (387/510/593) writes only the one-line provenance label + ISRC (metadata-tags.ts:37,176 — no ISWC/UPC/DDEX), and binds no signed manifest/watermark to the render. But the prior draft's 'no C2PA manifest writer … anywhere / only doc-comment mentions' was overstated: a real but hash-modeled (not crypto-signed JUMBF) buildC2paManifest/verifyC2paManifest exists in libs/euterpe/elevenlabs/src/inpaint-finetune/inpaint-finetune.ts:736-795 (explicitly 'models a detached signing key with no live network or key material'), and C2PA/SynthID benchmark/eval infra exists in libs/euterpe/evals/ (provider-benchmarks.ts:837, automated-eval.ts:755). None of it is wired to the DAW export and there is no SynthID watermark writer in the app or audio engine — so the gap holds as partial; the title/evidence now scope the claim to the DAW export path and acknowledge the unwired manifest builder.

6.5 Effects, Instruments & Plugin Hosting (FX)#

8 residual gaps — P0:1 P1:2 P2:3 P3:2

Euterpe's FX dimension has effectively closed the build-out gap from the prior (2026-06-06) audit and now sits at or near built-in-effects parity with the flagship field. Synthesis is wired end-to-end natively in Rust — not through the (real but unused) @euterpe/synth or the broader @euterpe/studio TS libraries: an 8-voice subtractive PolySynth plus FM phase-modulation and single-cycle wavetable voice modes (dsp-core/src/voice.rs), additive synthesis as 16 harmonic drawbars, formant/vowel-morph riding that additive path, a real overlapping-grain granular cloud on the Sampler (sampler.rs), and TS-synthesized drum one-shots — all confirmed reachable through synth-panel → reducer → session-rebuild → worklet → dsp-wasm → dsp-core. Built-in inserts grew from 10 to 15 (tremolo, saturator, flanger, autowah, ringmod, each a dedicated Rust DSP module with per-param sliders) plus a master 3-band Linkwitz-Riley multiband compressor / dynamic-EQ, with oversampling/anti-aliasing and auto-makeup gain on the drive effects. The previously-"missing" FX-8 macros, FX-10 preset libraries (synth + FX-chain, factory + user save/load), and the P0 FX-17 arrangement timeline are all shipped and wired.

A structural caveat now sharpened by this verification pass: there exists a large, parallel, present-unwired @euterpe/studio TS library (libs/euterpe/studio/src/{instruments,effects,runtime-sota,...}) that already contains a zone-mapped SampleMapping, a ModulationRoute type, carrier/modulator vocoders, and CLAP/VST3/AUv3/AAX/ARA host-planning functions. Although @euterpe/studio is listed as a workspace dependency and transpiled, the running DAW (apps/euterpe-studio-web/src) imports none of these modules — it reimplemented its engine in src/daw + Rust dsp-core. So those library capabilities do not satisfy the gaps below; they are blueprints/donor code, not wired features. The genuine residual gaps remain the plugin-hosting cluster and a handful of deep sound-design / tracking features.

Remaining gaps#

P0 — table stakes for pro adoption

P1 — expected by professionals

P2 — valuable

P3 — nice to have

Where Euterpe leads#

• Genuinely native DSP, not a wrapper. Every built-in synth voice mode and all 15 inserts are hand-written Rust with documented transfer functions (LR4 magnitude-flat multiband reconstruction, tube even-harmonic saturation, WSOLA time-stretch), compiled to WASM and unit-tested for domain correctness — a stronger first-party-effects story than DAWs that lean on bundled third-party plugins.
• Synthesis breadth in the box. Subtractive + FM + wavetable + additive + formant + granular + drum synthesis are all wired into one running web DAW — coverage that several flagship DAWs only reach via paid add-on instruments.
• Provenance-aware exports. provenance.ts already labels AI-authored material for the 2026 disclosure regimes (EU AI Act Art. 50, CA SB 942), ahead of the curve for the cross-dimension C2PA/SynthID work — though that AI-provenance maturity belongs to the AI dimension, not FX.

Verification notes#

• FX-11 (plugin hosting) — verdict: confirmed-absent, evidence sharpened. Euterpe's Tauri commands are file-I/O only (apps/euterpe-studio-web/src-tauri/src/commands.rs:36,48,60,89) and its shell Cargo.toml pulls in no host crate and no Neith. Two refutation candidates were chased and dismissed: (1) libs/euterpe/studio/src/runtime-sota/runtime-sota.ts planClapHost/planVst3Host/planAuV3Host/planAaxHost/planAraHost (lines 98/146/173/198/222) are pure capability-planning math — no process/scan/instantiate/dlopen, and not imported by the DAW (zero from '@euterpe/studio' imports in app src); (2) real CLAP+VST3 hosts exist as libs/neith/clap-host + libs/neith/vst3-host (dlopen/clap_entry/factory/lifecycle) but are a separate Neith domain, unbridged into Euterpe (grep neith in euterpe Cargo.tomls = empty). Recommendation upgraded to bridge the existing Neith host rather than write one from scratch.
• FX-7 (modulation matrix) — verdict: partial-exists, status unchanged. Running engine modulation is only the cutoff sine LFO (dsp-core/src/voice.rs:36-40,165) + FM + filter env; macros are a static fan-out. A ModulationRoute {source,destination,amount} type and LFOConfig/LFOShape do exist at libs/euterpe/studio/src/instruments/types.ts:71,63,33 but the whole module is present-unwired (no app import), so it doesn't close the gap. Evidence updated to credit the donor schema.
• FX-18 (take comping) — verdict: confirmed-absent, status unchanged. clip-recorder.ts:32-71 accumulates one ClipNote[] and finish() returns a single clip; the only "comping" grep hits are chord-voicing harmony comping (chord-voicings.ts:66), unrelated. Gap stands.
• Cross-cutting correction (affects FX-5, FX-9s, FX-N2 evidence): the audit's recurring "Euterpe lacks X" claims for the FX dimension are all scoped to the running DAW (apps/euterpe-studio-web/src/daw + dsp-core). The verification confirmed the parallel @euterpe/studio/@euterpe/voice libraries already contain zone-mapped sampling (instruments/types.ts:80-95), vocoders (studio/effects/effects.ts:1864, voice/vocal-processing.ts:2361), and MPE config — but none are imported by the DAW, so the gaps stand. Each affected gap's evidence now names the unwired donor so the eventual fix can port rather than reinvent.

6.6 AI Generation & Assistance (AI)#

16 residual gaps — P0:3 P1:6 P2:7 P3:0

Euterpe's AI dimension has moved close to 2026 parity, and the picture is materially better than the 2026-06-06 doc: roughly 30 commits since then closed items previously marked partial or missing. Verified WIRED in the DAW are the full symbolic-generation core (melody-from-key, eight melodic variations, counter-melody harmonization, and context-conditioned clip inpainting flowing from piano-roll.tsx into @euterpe/genesis/melody-gen + @euterpe/genesis/inpainting), a real fail-closed Anthropic LLM copilot (app/api/copilot/route.ts with server-side validateActions and a 34-action whitelist), and — the biggest correction — realtime MRT2 generation streamed into the master mix via realtime-stream-bridge.ts and a Rust StreamSource ring buffer, so generated audio passes through inserts/sends/automation like any source. Also wired: classic HPSS stem split, Krumhansl-Schmuckler key + autocorrelation tempo detection, audio→MIDI transcription, mix-assistant auto-leveling, reference-track tone matching, genre mastering + LUFS targeting, per-platform format masters with compliance verdicts, and master multiband dynamics. The adversarial stub scan over the DAW app surface returned zero actionable stubs.

The residual gaps cluster into three kinds. First, several large, real generation libraries exist but are not imported by the DAW — @euterpe/genesis/text-to-music (2651 LOC, barrel-exported at genesis/src/index.ts:8, zero app imports), @euterpe/voice (cloning + singing), @euterpe/accompany/virtuoso, genesis style-transfer/sfx-foley/stems, and — newly corrected — the @euterpe/studio pitch-correction engine (effects.ts:1577-1799 createPitchCorrection/processPitchCorrection), which the app never imports. So these capabilities are built but unreachable. Second, genuinely absent SOTA features with no implementation anywhere in the DAW path: audio/waveform inpainting, cross-channel masking-aware EQ, comping take-lanes, speech-to-text, spatial/Atmos, external-plugin hosting, and real-time collaboration. Third — and most credibility-critical — provenance is a label-only string (provenance.ts:30-44), with no cryptographic C2PA manifest on export and no SynthID watermark, even though the export path already writes BWF bext/iXML chunks (bwf.ts); SynthID/C2PA exist in the repo only as provider scoring fields in libs/euterpe/evals, not as an export-side manifest writer. Two architectural limitations also surfaced: the copilot cannot write editable MIDI notes to the arrangement (its 34-action whitelist stops at chords/patterns/arrangement-mode; the genesis melody generators are reachable only via the piano-roll UI), and the realtime AI stream is downmixed to mono (realtime-stream-bridge.ts:25-32) before entering the engine, discarding the generator's stereo image.

Remaining gaps#

P0 — table stakes / blocking

P1 — expected by pros

P2 — valuable

Where Euterpe leads#

Euterpe's realtime MRT2 generation flowing through the actual mix graph (track inserts → sends → automation → master) rather than a re-imported MP3 is genuinely ahead of the cloud-round-trip pattern most consumer tools still use, and matches the 2026 "intelligence in the timeline" thesis. The fail-closed, server-re-validated LLM copilot is architecturally sound (no fabricated audio, no client-trusted actions). Per-platform format masters with real compliance verdicts (Spotify/Apple/YouTube/TikTok/club/CD/vinyl) and the reference-track EQ match are at or near the iZotope/LANDR assisted-mastering bar. The honest-by-construction provenance model (re-marking hand-edited patterns as manual) is the right semantic foundation — it just needs the cryptographic C2PA/SynthID layer (AI-19) on top to be credible against 2026's converged standard.

Verification notes#

Adversarial re-verification of the nine headline gaps against the codebase (libs/euterpe + apps/euterpe-studio-web/src), citing file:line:

• AI-19 (C2PA/SynthID) — confirmed-absent (gap stands). provenance.ts:30-44 returns only a label string; daw-app.tsx:387,510,593 stamp only that label into the export comment; bwf.ts:3-35 writes only EBU bext/iXML chunks (no C2PA/JUMBF). The only SynthID/C2PA code in the repo is provider scoring in libs/euterpe/evals/src/provider-benchmarks/{types.ts:257-260,provider-benchmarks.ts:808-845} — not an export manifest writer.
• AI-8 (text-to-music) — confirmed-absent / present-unwired. Barrel-exported genesis/src/index.ts:8 (textToMusic, 2651 LOC); zero app imports. App imports genesis only via melody-gen (generate-clip.ts:21, piano-roll.tsx:27) and inpainting (clip-inpaint.ts:9).
• AI-N1 (copilot writes MIDI) — confirmed partial. copilot.ts:17-52 is exactly 34 actions; no melody/bassline/harmonize/placeClip/generateClip. The genesis generators are reachable only from piano-roll.tsx:17-18,235,303.
• AI-4 (pitch correction) — CORRECTED: missing → present-unwired. A real implementation exists in libs (libs/euterpe/studio/src/effects/effects.ts:1577-1799 createPitchCorrection/processPitchCorrection; effects/types.ts:303-322; also libs/euterpe/voice/src/vocal-processing + voice-conversion), but the DAW app never imports @euterpe/studio and INSERT_KINDS (copilot.ts:54-70) has no pitch node. Caveat noted in evidence: effects.ts:1763 documents the lib retune is a cents-shift approximation (not yet PSOLA/phase-vocoder) and monophonic; DNA-class polyphony exists nowhere. Status, evidence, title, and recommendation updated accordingly.
• AI-12 (voice cloning/singing) — confirmed present-unwired. libs/euterpe/voice/src/{voice-cloning,text-to-singing} real; zero app imports.
• AI-7 (audio/waveform inpainting) — confirmed-absent. Only symbolic MIDI inpainting wired (clip-inpaint.ts:28 on MusicNote[], piano-roll.tsx:303).
• AI-N2 (cross-channel masking EQ) — confirmed-absent. No analyzer in app or DAW libs surface; grep hits are unrelated (telemetry-launch, a spec string).
• AI-N5 (accompany/virtuoso) — confirmed present-unwired. session-player.ts is 55 LOC (wired daw-session.ts:24); @euterpe/accompany/@euterpe/virtuoso have zero app imports.
• AI-14 (candle forward-pass) — confirmed partial. mrt2-engine/src/lib.rs:13-16 + weights.rs:49 parse safetensors headers only; forward pass gated by INFERENCE_BACKEND_LINKED, reports not_configured until linked; realtime path runs through the BFF MagentaRtProvider.

Net change to the gap list: no gaps were already-present (none removed). One status correction — AI-4 downgraded from missing to present-unwired (a real @euterpe/studio pitch-correction lib exists, just unwired) with title/evidence/recommendation adjusted to "wire the existing engine" rather than "build from scratch." All other eight headline claims confirmed as drafted.

6.7 UX/UI & Workflow (UX)#

15 residual gaps — P0:2 P1:8 P2:4 P3:1

The 2026-06-06 picture is now substantially out of date: across the ~30 intervening commits, nearly every UX item that doc flagged as missing/partial/polish has shipped and is wired into the live DAW (apps/euterpe-studio-web/src/components/daw/daw-app.tsx, 1622 LOC). The three former P0 gaps are done — a real 895-LOC clip arrangement timeline (arrangement-view.tsx: drag/move/resize, magnetic + transient + selectable grid snap, markers, loop region, split-at-playhead, duplicate, box-select, MIDI export), a fuzzy command palette over a 24-command registry (command-palette.tsx + daw-commands.ts), and fully customizable keyboard shortcuts with a rebind/conflict-detection panel (keybindings.ts, keyboard-shortcuts-panel.tsx). Also confirmed wired and production-grade: per-track macros, a linear undo-history navigator (honestly self-documented as non-branching), a contextual help overlay plus ~124 inline tooltips, project templates, three themes including a WCAG-AAA high-contrast set, a deep accessibility layer (Okabe-Ito palettes, contrast utilities, reduced-motion, haptics, ARIA), automation lanes with shape presets and Write mode, local autosave/restore, count-in, MIDI-region regeneration in the piano roll, a whitelisted-tool LLM copilot, real generative MIDI (generate-clip.ts), a real (classical-DSP) stem separation module, and — newly confirmed in this verification pass — a wired AI Session Player (named bass/arp/chords accompaniment personas in step-grid.tsx, dispatched through the reducer). On the pure-UX cluster — actions, keyboard, help, theming, accessibility, timeline, macros, undo, templates — Euterpe is now at or near parity with mainstream desktop DAWs, and on a few axes (global command palette, WCAG-AAA, an honest accessibility tree) it meets or beats them. The residual gaps are the heavier-architecture surfaces.\n\n#### Remaining gaps\n\nP0 — table stakes still missing\n\n| id | gap | pillar | status | actionability | effort |\n|----|-----|--------|--------|---------------|--------|\n| UX-23 | Session / clip-launch grid (scenes + follow-actions + capture) | UX | missing | local | XL |\n| UX-5 | Unified assignable modulation system (mod-matrix / free LFOs / followers) | UX | partial | local | XL |\n\nThe "session mode" toggle in the arrangement view is only a boolean playback toggle (song-arrangement vs step-grid), not an Ableton-style clip×scene launcher — there are no launch cells, scene column, follow-actions, or retrospective capture. And while macros and automation lanes are done, there is still no modulation source (free LFO, envelope, step-mod, follower) routable to arbitrary parameters; only a fixed per-synth cutoff LFO exists and the macro resolver is a static linear map. Both are the clearest "behind the SOTA bar" items.\n\nP1 — expected by pros\n\n| id | gap | pillar | status | actionability | effort |\n|----|-----|--------|--------|---------------|--------|\n| UX-1 | Resizable / dockable workspace + saveable screensets | UX | missing | local | L |\n| UX-24 | MPE / per-note expression (pressure / glide / timbre) | UX | missing | local | L |\n| UX-7 | Unified semantic asset/sample/preset browser (embeddings + similarity) | AI | partial | local | L |\n| UX-10 | Take comping & loop-recording | UX | missing | local | L |\n| UX-15 | VST3 / CLAP / AU (or in-browser WAM) plugin hosting | Other | missing | native-desktop | XL |\n| UX-25 | Neural 4-way stem separation | AI | partial | local | L |\n| UX-26 | AI session players — chord-reactive / live-following, intensity controls, drums/keys personas | AI | partial | local | L |\n| UX-22 | Real-time multiplayer (CRDT) collaboration | Other | missing | backend | XL |\n\nThe left work column is a hard-coded 380px with no resize/dock/screenset persistence; notes carry no continuous per-note expression and Web MIDI input collapses all channels to one track (so MPE input is precluded too); the sampler still loads via a raw file picker (no unified browser, no similarity search — the current branch is feat/hestia-epicure-embeddings, so embedding infra may be a wire-up away); recording is single-pass (no take lanes/comping); the insert chain is Euterpe-native only; stem separation is classical HPSS 2-way rather than neural 4-way; and there is no live co-editing. Correction vs the draft: UX-26 is not an absence of session players — a real wired Session Player with bass/arp/chords personas already ships (session-player.ts → step-grid.tsx → reducer); the genuine residual is that it is one-shot over a hard-coded I–V–vi–IV progression with no chord-track reactivity, complexity/intensity controls, live-follow mode, or drummer/keys personas. Status is correctly partial, but the recommendation is now to promote the existing wired player, not build one from scratch.\n\nP2 / P3 — valuable to nice-to-have\n\n| id | gap | pillar | status | actionability | effort |\n|----|-----|--------|--------|---------------|--------|\n| UX-27 | In-DAW notation / score editor | Other | missing | local | L |\n| UX-11 | Touch / multitouch / pen-pressure input | UX | partial | browser | M |\n| UX-12 | Multi-window / multi-monitor detached editors | UX | missing | native-desktop | L |\n| UX-28 | Wire (or retire) the unimported studio / studio-runtime libs | Other | present-unwired | local | M |\n| UX-29 | DAWproject open-interchange round-trip in the UI | Other | partial | local | S |\n\nUX-28 is an internal-coherence finding: libs/euterpe/studio and libs/euterpe/studio-runtime are real, substantial view-model/runtime libraries (timeline/automation/mixer, plus a creator-experience onboarding/idea-board/export-wizard/coproducer-copilot suite) that are imported nowhere in the app — the shipping DAW reimplements these self-contained in src/daw. They should be wired into the shell or formally deprecated so "present" doesn't read as "shipped."\n\n#### Where Euterpe leads\n\nOn the UX axis Euterpe already meets or exceeds mainstream desktop DAWs in several places the benchmark itself flags as field gaps: a global fuzzy command palette (Cubase users are still requesting one as of v15; Studio One only has a command box), a complete keyboard command surface + ARIA/accessibility tree built in from day one (Reaper needs the third-party OSARA project to approach this), WCAG-AAA high-contrast theming with color-blind-safe Okabe-Ito palettes and reduced-motion/haptics, and an honest, fully-navigable linear undo history (most DAWs hide undo behind a menu; true branching undo is absent field-wide, and Euterpe's is at least a first-class, clickable navigator). For a browser/WASM DAW it also already ships real on-device DSP (HPSS separation, mastering, generative MIDI) plus a wired generative session player, rather than the cloud-only stem/master story of the BandLab/Soundtrap tier.\n\n#### Verification notes\n\nEach headline claim was re-checked against libs/euterpe + apps/euterpe-studio-web/src with citations:\n\n- UX-23 (session/clip grid) — confirmed-absent. arrangementMode is a single boolean (types.ts:437, action types.ts:587) documented as a playback toggle (arrangement-view.tsx:95-101), not a launcher. No sceneLaunch/launchClip/followAction/retrospective/capturePerformance hits. Gap stands.\n- UX-5 (modulation) — partial-exists, draft accurate. macros.ts:33 resolveMacroValue is a static linear map; only the fixed per-synth cutoff LFO (types.ts:44/46) + static FM ratio (types.ts:53) exist; no mod-matrix/free-LFO source. Status/evidence kept.\n- UX-1 (screensets) — confirmed-absent. daw-app.tsx:1505 hard-codes width:380, flexShrink:0; no screenset/resizable/splitter. Gap stands.\n- UX-24 (MPE) — confirmed-absent. No noteExpression/aftertouch model; web-midi.ts:19-20 explicitly ignores the channel nibble (every channel → selected track), which precludes MPE input. Evidence strengthened.\n- UX-7 (asset browser) — partial-exists, draft accurate. Preset libs exist; folders-panel.tsx is a track-grouping layer (MIX-25), not a browser; no similarity/embedding search. Kept.\n- UX-10 (take comping) — confirmed-absent. clip-recorder.ts has no take/comp/loop; audio-capture.ts 'take' is a single recording. Gap stands.\n- UX-15 (plugin host) — confirmed-absent. No VST3/CLAP/AU/WAM anywhere (only the unrelated 'clap' drum-synth). Gap stands.\n- UX-25 (neural stem) — partial-exists, draft accurate. stem-separation.ts:2 self-documents HPSS-not-Demucs; output is 2-way harmonic/percussive (stem-separation.ts:53-55,63). Kept.\n- UX-26 (session players) — partial-exists, CLAIM CORRECTED. Contrary to the draft's "no persistent style-player / no bass/keys personas," a real Session Player IS wired: session-player.ts:10 (bass/arp/chords personas) → UI in step-grid.tsx:122-147 → reducer daw-session.ts:1620-1641 → export daw/index.ts:41. The gap was rewritten to the narrower true residual (one-shot over hard-coded I–V–vi–IV at step-grid.tsx:138; no chord-track reactivity, intensity controls, live-follow, or drums/keys personas), and the recommendation now says "promote the existing wired player," not build one.\n- UX-22 (CRDT collab) — confirmed-absent. No yjs/automerge/crdt; the 'presence' hits are EQ-band labels (mix-assistant-bridge.ts:43, format-master.ts:165) + a billing flag; @euterpe/collab is not in the app's import set. Gap stands.

6.8 Recording & Performance (REC)#

17 residual gaps — P0:0 P1:8 P2:7 P3:2

Euterpe's Recording & Performance surface has advanced well past what the 2026-06-06 audit recorded, and several items that doc marked "missing"/"partial" are verified shipped and wired at HEAD. The arrangement timeline (REC-1) is fully built: ArrangementView (arrangement-view.tsx, ~38KB) renders a bar/beat ruler with clip drag/resize, marquee multi-select, bar/beat/magnetic + transient snap, per-clip gain/fades/color and a playhead, mounted at daw-app.tsx:1554 and flowing through setArrangement into the Rust ArrangementClip scheduler (clip.rs:219), with auto-crossfade (ARR-8) and transient-snap (ARR-6). Core tracking is real end-to-end — audio capture (getUserMedia → ScriptProcessor → CaptureBuffer → engine.loadSample, fail-closed on permission denial, daw-app.tsx:792-847) and polyphonic MIDI recording into ClipRecorder. Count-in (REC-7), automation Write-mode live capture (REC-15), automation shape presets (REC-20), glide/portamento (REC-19), mix snapshots (REC-18), the two-tone metronome (REC-10) and undo/redo (REC-16) are all shipped and wired. A real AI Session Player (REC-N2) is also shipped and wired — session-player.ts generateAccompaniment lays bass/arp/chords parts from chord symbols using @euterpe/core voicings, dispatched from "Session player" buttons in step-grid.tsx:136, handled in daw-session.ts:1620, and unit-tested (daw-session.spec.ts:1339); its residual vs Logic is drum/keys styles, complexity/intensity, live chord-track reactivity and commit-during-performance. Beyond the REC list Euterpe also carries WSOLA warp (independent time-stretch + pitch-shift), HPSS + Mid/Side stem separation (honestly labelled classic DSP), and real generative MIDI (functional-harmony melody/chord generation + clip regeneration). The residual gaps cluster in three areas: pro recording workflows (comping, punch, multi-track, monitoring), the live-performance paradigm (Session/clip-launch view, looper, control surfaces), and AI-for-recording where the field has moved on (neural stem separation, richer AI Session Players, speech-to-text). One root cause is structural: the Web MIDI parser handles note-on/off only (web-midi.ts; web-midi.spec.ts:29-30 asserts CC/pitch-bend toBeNull), which simultaneously blocks MIDI-learn, control surfaces, and expressive-controller capture.

Remaining gaps#

P1 — expected by pros / table-stakes the field has converged on

P2 — valuable

P3 — polish

Where Euterpe leads#

Euterpe is at or near parity on the linear-arrangement core and ahead of where the prior audit placed it. Its arrangement timeline with transient snap + auto-crossfade, samples-accurate engine-side count-in, Write-mode automation capture with shape presets, a real (RMS-tested) metronome click, WSOLA independent time/pitch warp, and per-voice glide are all genuinely wired — not fixtures. Its generative-MIDI stack (functional-harmony melody/chord generation, counter-melody/variation, region regeneration) and a wired, UI-surfaced AI Session Player (bass/arp accompaniment from chord symbols) plus honestly-labelled HPSS/M-S separation give it a real head start toward the AI gaps (REC-N1/N2/N4): the generator substrate already exists, so a richer Session Player and on-device neural separation are extensions rather than greenfield. The frontier the field has pulled ahead on is the non-linear/live paradigm (Session view, looper, control surfaces) and AI-for-recording — those are the real residual gaps.

Verification notes#

Eight headline claims were adversarially re-checked against the code at HEAD; cited file:line for each:

• REC-4 — confirmed-absent. No clip-launch grid/scenes/follow-actions. grep for sessionview/cliplaunch/clipslot/followaction is empty; 'scene' hits are only daw-controller.ts:139 defaultSceneActions (a starter two-synth-track setup) and BWF/dawproject <SCENE> XML; the only arrangement surface is the linear ArrangementView (daw-app.tsx:1554). Gap stands.
• REC-2 — confirmed-absent. No takes[]/comp-lane/loop-record; all 'TAKE' hits are BWF iXML metadata. RecordingSession holds a single this.track; daw-app.tsx:800-803 overwrites one capture buffer per track. Gap stands.
• REC-N1 — confirmed-absent (partial status correct). stem-separation.ts is HPSS + M/S only (header literally "not a neural Demucs"). The only 4-stem "separator," libs/euterpe/conservatory/reference-ear-training.ts splitStems (line 176), is a quality model returning estimatedSdrDb/energyFraction metadata, not an audio separator. No demucs/onnxruntime/spleeter in the app. Gap stands.
• REC-N2 — CORRECTED to partial-exists (status/title/evidence updated). A real style-parameterized AI Session Player is shipped and wired: session-player.ts generateAccompaniment (bass/arp/chords via @euterpe/core voicings) → action types.ts:550 → handler daw-session.ts:1620 (real PatternState + setPattern command) → "Session player" buttons step-grid.tsx:136 → tested daw-session.spec.ts:1339. The gap was retitled/rescoped to the genuine residual (drum/keys styles, complexity/intensity, live chord reactivity, commit-during-performance) and effort downgraded L→M. The prior draft's evidence understated the existing wiring.
• REC-6 — confirmed-absent. parseMidiMessage decodes 0x90/0x80 only; web-midi.spec.ts:29-30 asserts 0xB0 and 0xE0 toBeNull(). No midi-learn/ControlMapping anywhere. Gap stands.
• REC-8 — confirmed-absent (present-unwired status correct). daw-app.tsx:837-840 sets sink.gain.value = 0 with the comment "pulls without monitoring the input back to the speakers"; the capture graph is fully built, only the monitor return is silenced; no monitorMode/cueMix toggle. Gap stands.
• REC-12 — confirmed-absent. RecordingSession.arm() sets a single track and rejects a second arm (audio-capture.spec.ts:55); one getUserMedia source per record. A multitrack-record Feature enum (identity-billing/types.ts:136) and a multi-track shell-runtime capability gate exist but are labels with zero capture-side implementation (the Feature enum has no .tsx usage). Evidence amended to note these labels. Gap stands.
• REC-N3 — confirmed-absent. Same root as REC-6: CC/pitch-bend/aftertouch return null; ClipRecorder captures pitch+velocity+timing only; no MPE/channel-per-note. Gap stands.

6.9 Collaboration & Cloud (COLLAB)#

15 residual gaps — P0:2 P1:7 P2:4 P3:2

Euterpe remains a fundamentally single-user, local-first DAW sitting on top of an exceptionally large, real, but almost entirely unwired collaboration/cloud library substrate. Two things shipped recently that move the needle locally: the COLLAB-19 autosave + restore slice (commit 63fbcf4f3c, 2026-06-07) — daw/local-autosave.ts persists the serialized project to localStorage, debounced ~1s after each edit (daw-app.tsx:1266), with a ↺ Restore transport button (transport-bar.tsx:748) — and the single-user realtime cloud/streaming seam (@euterpe/api realtimeStreaming wired into the BFF /v1/generation/realtime route, realtime-music-route.ts:14,49-53, fail-closed). Both are genuinely wired and genuinely valuable, but neither is multiplayer: the realtime route is producer→single-DAW AI generation streaming, not project co-editing.

The defining finding holds and was re-verified by grep: there are zero production imports of @euterpe/collab, @euterpe/projects, or @euterpe/distribution anywhere in apps/euterpe-studio-web/src (only doc-comment mentions). The substrate is SOTA-grade and idle — sync-engine.ts has working OT (transformOT:366), CRDT merge (mergeSequence:320), conflict resolution (resolveConflict:473) and presence (createPresence:510); projects/versioning-lineage.ts is a real git-like VCS (1359 LOC: FNV-1a + Merkle content hashing, commit DAG, LCA 3-way merge, semver, tamper-evident export chains) imported only within its own package; rights-mgmt.ts + distribution-sota.ts implement split sheets, PRO/IPI registration and royalty accrual (zero app imports). None of it has a transport, a server replica, or a UI. The collab BFF stores that exist (yemaya/presence-store, cursor-transform-store, crdt-merge-store, bellona/sync-conflict-store, library/share-policy-store) are real but admin-gated /v1/admin/* consoles bound to Yemaya/Bellona/library journeys — none link to Euterpe. Net: this is the single largest unwired surface in the product — a near-complete collaboration engine with no plumbing.

One correction to the prior PWA framing (COLLAB-19): the PWA manifest is already wired — app/layout.tsx declares manifest:'/manifest.webmanifest' and public/manifest.webmanifest is a complete, real manifest (192/512/maskable icons, shortcuts, .eup/.wav/.midi filehandlers, web+euterpe protocol_handler, window-controls-overlay display_override) — and shell-runtime _is imported by a component (app/page.tsx uses resolveLayout for responsive panel layout). What remains genuinely unwired is the offline runtime: no service-worker registration exists anywhere (no serviceWorker.register, no sw.js), and shell-runtime's OPFS/precache/recovery functions (buildOpfsLayout:391, buildPrecacheManifest:422, resolveRecovery:846, selectRecoveryPoint:994, evaluateInstallEligibility:448) are called by no component. So COLLAB-19 stays partial, but the remaining work is the SW + OPFS runtime, not the manifest.

Remaining gaps#

Critical path. Everything chains off two backend unlocks. COLLAB-2 (cloud project store: Postgres metadata + MinIO/S3 blobs, content-addressed via the already-built storage-indexing.computeCasKey) and COLLAB-1 (a project-sync WebSocket with an authoritative server replica that broadcasts sync-engine.transformOT ops into the daw-session reducer). Once those land, COLLAB-5/6/8/9/4 are mostly UI + rebinding the existing admin stores to the Euterpe namespace. Two P1s are buildable locally now with no server: COLLAB-3 (wire versioning-lineage into a single-user History panel) and COLLAB-8 (a conflict dialog over resolveConflict) — strong incremental wins. COLLAB-19 is the one already-partial item; the manifest is done, so finishing it means registering a service worker and wiring shell-runtime's OPFS/recovery functions (currently called by no component).

Where Euterpe leads#

The substrate is well ahead of where most web DAWs start: a real OT+CRDT engine, a tamper-evident git-like VCS with Merkle hashing and 3-way merge, in-DAW split sheets with PRO/IPI registration and royalty accrual, and content-addressed storage — capabilities BandLab/Soundtrap/Soundation mostly don't expose (split sheets and per-project version DAGs in particular are differentiators, not parity items). The gap is entirely wiring, not algorithms: when COLLAB-1/2 land, Euterpe can leapfrog the incumbents on version control and rights, where they are weakest. The local autosave/restore + the fail-closed realtime AI-generation streaming seam are also genuinely shipped and correct.

Verification notes#

Every headline claim was adversarially re-checked against libs/euterpe + apps/euterpe-studio-web/src + apps/oshun/bff/src:

• COLLAB-2 — confirmed-absent. No BFF Euterpe project route; the only euterpe references in apps/oshun/bff/src are the 4 generation/realtime-music files. storage-indexing imported only by the package barrel. Local-only persistence (local-autosave.ts + project-io.ts) confirmed.
• COLLAB-1 — confirmed-absent (present-unwired stands). sync-engine.ts transformOT:366/mergeSequence:320 verified; zero app imports (the app/daw/page.tsx:11 hit is an unrelated asset-sync doc comment); no project-sync WS; daw-session.ts has no remote-op path.
• COLLAB-5 — confirmed-absent. Zero presence/cursor/createPresence references in any DAW component.
• COLLAB-3 — confirmed-absent (present-unwired stands). versioning-lineage.ts is real VCS code (FNV-1a:60, Merkle hash §38.38.3.1:112), imported only within its own package; no version/branch/merge UI (undo-history.tsx is just an undo stack).
• COLLAB-19 — partial-exists, TWO claim corrections. Corrected: the PWA manifest is already wired (app/layout.tsx + public/manifest.webmanifest), and shell-runtime is imported by app/page.tsx (resolveLayout). Still genuinely unwired: no service-worker registration, and the OPFS/precache/recovery functions are called by no component. Status remains partial; the recommendation was updated to drop "add a manifest" and focus on the SW/OPFS runtime.
• COLLAB-9 — confirmed-absent (present-unwired stands). identity-billing.ts:346 maps collaboration→pro (tested) but is imported by no DAW component/module — no entitlement gate enforced.
• COLLAB-4 — confirmed-absent. No share UI in the DAW and no Euterpe share route in the BFF.
• COLLAB-6 — confirmed-absent. No comment/annotation UI in the DAW.
• COLLAB-8 — confirmed-absent. resolveConflict:473 exists; no conflict dialog in the DAW.

6.10 Interop, Formats & Ecosystem (IO)#

18 residual gaps — P0:1 P1:7 P2:7 P3:3

The 2026-06-06 audit is materially stale for interop: a string of items it called "missing"/"partial" have since shipped and are wired into the DAW UI. Euterpe now has full DAWproject (.dawproject) import + export (dawproject.ts, wired daw-app.tsx:337/:966), Broadcast WAV with a real EBU-Tech-3285 bext + iXML chunk, export dithering (TPDF + 2nd-order noise shaping to the 16-bit grid), distribution metadata (RIFF INFO / iXML USER / ID3v2.4 sidecar / validated ISRC), platform-format mastering chains (Spotify −14, Apple −16, YouTube, TikTok, club, CD Red Book, vinyl/RIAA) with a measured BS.1770 compliance verdict, batch multi-format export, per-track stem export (web + native Tauri folder), SMF format-1 import/export for both patterns and the arrangement timeline, Web-MIDI hardware input, symbolic/MIDI region AI-inpainting via @euterpe/genesis, a fail-closed MRT2 realtime cloud/on-device generator track, a v2 JSON project format with a real arrangement timeline, an HPSS + M/S stem separator, a wired AI mix-assistant + reference-match master, a real WSOLA sampler warp (time-stretch + pitch-shift, timestretch.rs → loadSampleWarped → sampler UI), and an LLM copilot DAW-control route with a 37-action server-validated whitelist. Lossy codecs are honestly refused with a fail-loud comment — a correct seam, not a stub. The residual gaps are now concentrated on the ecosystem side, where the SOTA bar is high.

Remaining gaps#

P0 — table stakes

P1 — expected by pros

P2 — valuable

P3 — nice to have

Where Euterpe leads#

Euterpe is genuinely ahead of the field on distribution-and-delivery interop: the platform/format mastering chains (Spotify/Apple/YouTube/TikTok/club/CD/vinyl) ship a measured BS.1770 loudness + true-peak compliance verdict on export with a one-click batch pack — most flagships make you target loudness manually or via a separate plugin. Its Broadcast WAV is a complete EBU-Tech-3285 bext (64-bit TimeReference, v2 loudness block, UMID, CodingHistory) + iXML implementation, matching field-recorder-grade metadata. And it is DAWproject-native on both import and export — putting it in the small adopter club (Bitwig, Cubase 14, Studio One, Nuendo, n-Track) that Logic/Ableton/Pro Tools/FL are conspicuously outside of. The honest fail-loud refusal of fake codecs (format-master.ts:11) is also a correctness posture most DAWs don't bother to make explicit. The work to close the headline gaps is plugin hosting (IO-4), arrangement-clip warp + comp (IO-N2/IO-11), MIDI 2.0/MPE (IO-3), and lifting DAWproject fidelity (IO-N3) from a partly-lossy subset to a real round-trip.

Verification notes#

An adversarial pass tried to refute each P0/P1 headline by finding the capability in code (Grep/Read across libs/euterpe + apps/euterpe-studio-web/src). Verdicts:

• IO-4 (plugin hosting) — confirmed-absent. insert-rack.tsx:14-30 hardcodes 15 built-in DSP insert types with no "load plugin" slot. The only host references are the unwired @euterpe/studio runtime-sota helpers: planClapHost (runtime-sota.ts:98) and planAraHost (:218) return plan descriptors (version gates + thread-pool math), not real hosts, and are never imported by the app (index.ts:2 is a @module docblock only). Gap stands.
• IO-N1 (ARA2) — confirmed-absent. No ARA in apps/euterpe-studio-web/src; only the unwired planAraHost descriptor + types.ts:14,130 docs in @euterpe/studio. Gap stands.
• IO-N2 (warp/time-stretch) — corrected to partial. The prior draft's "no warp anywhere" headline was wrong: a real WSOLA time_stretch/pitch_shift (dsp-core/src/timestretch.rs:95,176) is wired through audio-engine.ts:666 loadSampleWarped → daw-app.tsx:707 warpSample → sampler-panel.tsx:400-454 Warp UI. The genuine remaining gap is per-clip warp markers on arrangement audio clips (none in arrangement.ts/types.ts) and grid-following stretch — title/status/evidence corrected accordingly (status → partial, effort → L).
• IO-11 (take/comp) — confirmed-absent. clip-recorder.ts (73 lines, read in full) is single-take; the take/comp/punch hits elsewhere are unrelated (compressor sidechain, BWF <TAKE> metadata, a "punch" FX-preset alias, chord "comping"). Gap stands.
• IO-3 (MIDI 2.0/MPE) — confirmed-absent. web-midi.ts:19 explicitly ignores the channel nibble (fatal for MPE) and decodes only note-on/off; midi-import.ts:146 ignores CC/pitch-bend/aftertouch. Gap stands.
• IO-N3 (DAWproject fidelity) — partial, evidence corrected. Two prior sub-claims were wrong: dawproject.ts does emit <Transport>/<Tempo> (:141, round-tripped on import :216-219) and does emit a <Scenes/> element (:152, though empty). The real lossy items remain: <Automation>, audio-clip <Fades>/<Crossfade>, <Device>/plugin-state, note-expression, and <Send> entries — all modelled by the engine (sends types.ts:279-282, automation breakpoints types.ts:304-306) but not serialized; <TimeSignature> is hardcoded 4/4 (:142). Gap kept as partial with corrected title/evidence.
• IO-N4 (neural stems) — partial confirmed. stem-separation.ts:2 is real Fitzgerald-2010 HPSS + M/S (2-band), honestly labelled "not a neural Demucs"; no ONNX/Demucs in-app (the 4-stem refs are a separate ear-training/video domain). Gap stands as partial.
• IO-N5 (clip launcher) — confirmed-absent. No session-view/scene/follow-action component or model; the only grid is step-grid.tsx. Gap stands.

6.11 Platform, Accessibility & Hardware (PLAT)#

14 residual gaps — P0:0 P1:4 P2:7 P3:3

Accessibility moved decisively this window, and via a cleaner path than the prior doc predicted: the shipped a11y lives in app-local modules (daw/accessibility.ts, daw/daw-a11y.ts), not the still-unwired @euterpe/access library. Reduced-motion now gates the spectrum/goniometer rAF loops, an Okabe-Ito color-blind selector overlays accent tokens onto the live theme, haptics fire on record-arm, the high-contrast theme was tuned to WCAG AAA with a contrast-asserting spec, and ~145 ARIA attributes plus several aria-live status regions (transport-bar, arrangement-view, keyboard-shortcuts-panel) give moderate screen-reader coverage. Mono-compatibility is genuinely shipped (a master mid/side fold in the Rust engine with a passing test, plus a monitor mono/dim path). On platform, a real Tauri v2 desktop shell with unit-tested native file I/O, COOP/COEP for SharedArrayBuffer/WASM threads, a rebindable keymap + command palette + help overlay, Web MIDI note input, and a PWA manifest are all in place. Crucially — and missing from the input bundle — interop is not absent: daw/dawproject.ts ships both export and import (wired into the toolbar and command palette), alongside MIDI import/export and BWF metadata. So Euterpe is a credible near-native web DAW; the residual gaps cluster in native I/O latency, true offline, deep interop coverage, hardware control, and blind-producer parity.

Remaining gaps#

The highest-leverage, locally-buildable wins are the ones where the data layer already exists but is unimported: registering a service worker over shell-runtime.buildPrecacheManifest/OPFS (PLAT-5), wiring resolveLayout for responsive widths (PLAT-4), and exposing the authored Ableton/Logic/Pro Tools shortcut profiles (PLAT-N6). PLAT-2 (native audio via cpal in the Tauri core) is the single biggest latency unlock but is XL and desktop-only. PLAT-9 (treegrid piano-roll) is the gap that separates Euterpe from Reaper+OSARA gold-standard blind-producer parity and is pure-DOM/ARIA, locally testable.

Where Euterpe leads#

Euterpe is at or near parity on several platform axes that many DAWs lag on: the SharedArrayBuffer + WASM/SIMD (Rust-on-the-audio-thread) architecture with COOP/COEP isolation is exactly the 2025-26 SOTA web-DAW pattern (openDAW/Soundation/web-synth), and it ships DAWproject import/export — an interchange format the conspicuous flagships (Logic, Ableton, Pro Tools, FL) still do not support at all. Its app-local accessibility (reduced-motion, Okabe-Ito color-blind mode, AAA-verified high-contrast, contrast-asserting tests) is more deliberate than the typical web DAW, and the master/monitor mono-compatibility audition with an engine-level mid/side fold is a touch most browser DAWs lack.

Verification notes#

All four headline claims were adversarially re-checked against the source; every one stands. No gap was removed or downgraded to polish.

• PLAT-2 (Native low-latency audio I/O) — confirmed-absent. src-tauri/Cargo.toml depends only on tauri-plugin-dialog/fs/opener (+ serde/base64/euterpe-desktop-core). The desktop-core crate (src-tauri/core/Cargo.toml) depends on ONLY serde+serde_json and is self-described as 'No Tauri/OS deps'; its sole lib.rs does path-safety + project-file validation, not an audio thread. Repo-wide grep for cpal/coreaudio/asio/alsa/wasapi = zero hits. Gap unchanged.
• PLAT-5 (Service worker + OPFS PWA) — confirmed present-unwired. No serviceWorker.register/workbox/next-pwa/self.addEventListener anywhere; next.config.mjs only sets COOP/COEP headers. The shell-runtime builders (buildPrecacheManifest/buildOpfsLayout/resolveLayout) are re-exported solely by the shell-runtime/index.ts barrel, and that barrel is imported by NO DAW component (the only external 'shell-runtime' reference is a doc-comment at src/index.ts:8). shell-runtime.ts:452 still reports no-service-worker as an install blocker. Evidence corrected: the recommendation now cites buildOpfsLayout (the actual exported name) rather than OpfsLayout. Gap unchanged.
• PLAT-1 (MIDI CC/Learn/MPE) — confirmed partial. web-midi.ts:23-38 decodes only 0x90/0x80; web-midi.spec.ts:29 asserts a CC message decodes to null; midi-import.ts:146 comment confirms CC/pitch-bend/aftertouch/program are ignored. No MIDI-Learn/MPE/control-surface code exists. Gap unchanged.
• PLAT-9 (treegrid piano-roll + skip-link) — confirmed partial. Repo-wide grep for role=treegrid/role=grid/aria-rowindex/aria-colindex/skip-link = zero hits. piano-roll.tsx carries aria-label only on toolbar selects; its note grid is pointer-only (onPointerDown/Move/Up at 555-557) with no onKeyDown/tabIndex/grid role. aria-live status regions DO exist (transport-bar 135/549, arrangement-view 643, keyboard-shortcuts-panel 168) so general a11y is real, but blind-producer keyboard note editing is not met. Minor input-summary correction: there are at least three (not two) aria-live regions and ~145 (not ~141) aria attributes. Gap unchanged.

6.12 Mastering & Distribution (MASTER)#

14 residual gaps — P0:1 P1:4 P2:7 P3:2

Euterpe's mastering and export chain is now one of the more complete dimensions in the DAW, and a burst of MASTER commits on 2026-06-06/07 closed most of what older docs flagged as missing. The shipped export flow (daw-app.tsx::masterExport) is a real end-to-end chain — offline render, 10-genre masterBounce, optional reference tone-match (octave-band FFT + matchEq + RBJ biquads), then either a 7-target platform delivery chain (Spotify/Apple/YouTube/TikTok/Club/CD/Vinyl, each a real BS.1770-4 loudness + true-peak + format-conditioning chain returning a measured compliance verdict) or a true-peak-clamped LUFS normalize, then TPDF + 2nd-order noise-shaping dither to 16-bit, then WAV / Broadcast-WAV (real EBU 3285 bext + iXML) with RIFF LIST/INFO + validated-ISRC + ID3v2.4-sidecar metadata. Live BS.1770-4 master metering is fully wired and real (integrated/short-term/momentary LUFS, 4×-oversampled true-peak dBTP, phase correlation, EBU-3342 LRA) with a loudness-history graph, a master EQ + compressor panel, a multiband-dynamics panel, a Mixing-Assistant report with an apply-fixes bridge, batch multi-format .zip export with per-target verdicts, and per-track stem export (browser + native Tauri). The residual gaps are not in the core loudness/format pipeline — they are AI assist, immersive audio, provenance, and codec/distribution reach, several of which are already built in the shared libraries and merely unimported by the app.\n\nAn adversarial re-verification of the five headline gaps (MASTER-N1/11/N2/18/9) confirms all five stand. The app's @euterpe import census is only five libraries — audio-engine-web, core, genesis, master, transcribe — so both @euterpe/spatial (ADM-BWF) and @euterpe/distribution (DDEX ERN, ISWC) are genuinely unimported; and within @euterpe/master the app calls exactly two frontierMastering.* members (allLoudnessPresets, matchEq), so recommendChain/dynamicEqResponse/masterStems/checkLoudnessCompliance are all genuinely uncalled. The C2PA/SynthID surface exists only as eval scoring fields, never as an export writer, and there is no lossy/lossless codec dependency anywhere in the app, the libs, or node_modules. One evidence correction: the DDEX ERN creator in @euterpe/distribution is exported as createDdexErn (not createErn) — corrected in MASTER-18.\n\n#### Remaining gaps\n\n| ID | Gap | Pillar | Sev | Status | Effort |\n|----|-----|--------|-----|--------|--------|\n| MASTER-N1 | AI Master Assistant — one-click full-chain recommendation (recommendChain exists in @euterpe/master, app only uses matchEq/allLoudnessPresets) | AI | P0 | present-unwired | M |\n| MASTER-11 | Dolby Atmos / ADM-BWF authoring + Near/Mid/Far binaural metadata + Apple-Atmos validator (@euterpe/spatial real, never imported) | Other | P1 | present-unwired | L |\n| MASTER-N2 | C2PA Content Credentials manifest + SynthID propagation on AI-touched exports (provenance.ts is a label-only badge, nothing signed/embedded) | AI | P1 | partial | M |\n| MASTER-18 | DDEX ERN 4.3 + ISWC/UPC + MEAD AI-disclosure flags (@euterpe/distribution has createDdexErn/validateIswc, unimported; app tags ISRC/RIFF/ID3 only) | Other | P1 | present-unwired | M |\n| MASTER-9 | Lossy/lossless codec export — MP3/AAC/FLAC/Ogg (WAV/PCM only; no encoder dep anywhere) | Other | P1 | missing | L |\n| MASTER-6 | Broadcast/podcast/audiobook chains — EBU R128 / ATSC A/85 / ARIB / OP-59 (masterForBroadcast/Podcast/Audiobook real, not in EXPORT_TARGETS) | Other | P2 | present-unwired | S |\n| MASTER-N3 | Streaming coverage gap (no Amazon/Tidal/Deezer) + no −2 dBTP universal-master option | Other | P2 | partial | S |\n| MASTER-17 | Offline-render progress / ETA / cancel UI (renderOffline awaited with no progress callback) | UX | P2 | missing | M |\n| MASTER-15 | Mastering-chain parameter automation over time (master multiband/limiter/loudness-target lanes) | Other | P2 | missing | L |\n| MASTER-N4 | Live multi-platform compliance dashboard — per-platform pass/fail badges off the live meter (checkLoudnessCompliance unused live) | UX | P2 | partial | M |\n| MASTER-8 | Dedicated stem-mastering workflow — isolate/process/recombine (masterStems unwired; distinct from per-track export) | Other | P2 | present-unwired | M |\n| MASTER-N5 | Dynamic / spectral EQ on the master (dynamicEqResponse unwired; master EQ is static bands) | Other | P2 | present-unwired | M |\n| MASTER-12 | Distribution-platform integration (DistroKid/TuneCore/CD Baby) | Other | P3 | missing | L (cloud-cred) |\n| MASTER-7 | Bundled curated genre-reference library (reference match is user-upload only) | UX | P3 | partial | M |\n\nThe single most strategic gap is MASTER-N1: frontierMastering.recommendChain already constructs a full ordered mastering chain (EQ → dynamic-EQ → multiband → exciter → imager → limiter) with rationales from a source-vs-reference gap analysis — an Ozone-Master-Assistant-class flow — yet the app never calls it. Wiring it (plus dynamicEqResponse, MASTER-N5) is pure web work and would move Euterpe from "manual master with good metering" to "AI-native master" in one slice. The next tier (MASTER-11/N2/18) are the immersive-audio and provenance/distribution table-stakes that 2026 flagships and the hardening AI-disclosure regimes assume; notably the spatial ADM-BWF and DDEX ERN code already exist in the libs and only need importing.\n\n#### Where Euterpe leads\n\nFor stereo loudness mastering and standards compliance, Euterpe is at or near parity with flagship DAWs and ahead of many: a fully real BS.1770-4 metering suite (integrated/short-term/momentary LUFS, 4× true-peak, correlation, EBU-3342 LRA) with a loudness-history graph; seven real per-platform delivery chains each returning a measured compliance verdict; real TPDF + 2nd-order noise-shaping dither; genuine Broadcast-WAV (EBU 3285 bext + iXML); validated-ISRC + RIFF/ID3 metadata; and batch multi-format export — all wired into the transport UI rather than living in a separate cloud tool. The mix-assistant-with-apply-fixes bridge is a credibly AI-assisted touch already in place. The gaps above are about reach (immersive, codecs, distribution, provenance) and surfacing already-built AI/library power, not about the soundness of the core mastering pipeline.\n\n#### Verification notes\n\n- MASTER-N1 (recommendChain unwired) — CONFIRMED-ABSENT. recommendChain is exported at libs/euterpe/master/src/frontier-mastering/frontier-mastering.ts:153 (barrel index.ts:19). A full census of frontierMastering.* calls in apps/euterpe-studio-web/src returns exactly two members — allLoudnessPresets (daw/loudness-target.ts:20) and matchEq (daw/reference-match.ts:142); grep -rcn recommendChain across all app src = zero. Gap stands.\n- MASTER-11 (spatial ADM-BWF unwired) — CONFIRMED-ABSENT. generateAdmXml (libs/euterpe/spatial/src/atmos/atmos.ts:959, emits ITU-R_BS.2076-2) and exportAdmBwf (atmos.ts:1064) are real and barrel-exported (spatial/src/index.ts:8), but the app's @euterpe import census lists only audio-engine-web/core/genesis/master/transcribe — zero @euterpe/spatial import. Gap stands.\n- MASTER-N2 (C2PA/SynthID) — PARTIAL-EXISTS (status already 'partial', kept). provenance.ts:30-44 is label-only; consumed as a UI badge at transport-bar.tsx:326. No C2PA/SynthID/manifest in the export path (daw-app.tsx, wav.ts, metadata-tags.ts); C2PA/SynthID exist only as eval scoring fields (libs/euterpe/evals/.../provider-benchmarks.ts:812-845). Gap stands as 'partial'.\n- MASTER-18 (DDEX/ISWC unwired) — PARTIAL-EXISTS / evidence corrected. Lib code real: DDEX_ERN_SCHEMA_VERSION='4.3' (distributor/index.ts:394), ERN creator createDdexErn (distributor/index.ts:586 — the draft's createErn name was wrong, now corrected), validateIswc (metadata/index.ts:1296). App has ISRC only (metadata-tags.ts:36); zero @euterpe/distribution import. The unwired-by-app claim is fully confirmed; status kept 'present-unwired'.\n- MASTER-9 (codec export missing) — CONFIRMED-ABSENT. No lame/fdk/flac/opus/vorbis implementation in app or libs; no codec dependency in any package.json or node_modules; AudioCodec is a type-only union at libs/euterpe/distribution/src/dsp-integration/index.ts:21. Gap stands.

6.13 AI Provenance, Rights & Monetization (RIGHTS)#

13 residual gaps — P0:2 P1:6 P2:3 P3:2

Euterpe's RIGHTS dimension is unchanged since the 2026-06-06 audit — code-verified, nothing in provenance/chain/distribution/protect shipped between that doc and HEAD (the only in-window commits were adjacent DAW work: ENG-5 f64 delay/reverb, ARR-6 transient-snap, MIDI-17 trig conditions, MIX-7 EQ automation). The picture remains two non-intersecting worlds. World A is a genuinely large, real library layer (libs/euterpe/{provenance,chain,distribution,protect,agents}) with passing specs and real domain algorithms — verified directly: spread-spectrum watermark embed/detect (watermark-capture.ts:516/555), a JUMBF hashed-URI C2PA manifest builder (buildC2paManifest, :765), on-chain rights registration (chain/rights-registry/index.ts, 838 LOC), DCF/NPV valuation + constant-product AMM (chain/royalty-liquidity/royalty-liquidity.ts, 778 LOC), GDPR/CCPA purge (compliance-ops.ts, 1324 LOC), and melody/lyric similarity (copyright-safety.ts:348/403). World B is the actual DAW (apps/euterpe-studio-web), and it imports none of it: package.json lists only 8 @euterpe/* deps (none of provenance/chain/distribution/protect), there is no transitive re-export of those four libs from any of the 8 deps, and a repo-wide grep for every World-A function name returns zero app hits.

What is actually wired in the DAW is thin but honest: a 45-LOC daw/provenance.ts whose summarizeProvenance() derives a plain-text AI-disclosure label from the PatternOrigin enum, embedded into the WAV ICMT comment at export (daw-app.tsx:387/510/593) with a matching ai-provenance-badge in the transport bar (transport-bar.tsx:326-328); and real distribution metadata (metadata-tags.ts builds spec-valid RIFF LIST/INFO + ID3v2.4 with validated ISRC, surfaced in a transport-bar panel with exactly 5 fields + ISRC at transport-bar.tsx:575-607 and appended to the WAV at daw-app.tsx:560). Those are correctly counted as wired and are not gaps.

Two library-level caveats were re-confirmed against source and correct the prior doc's optimism: signClaim (watermark-capture.ts:832) is an FNV-1a-HMAC-shaped keyed digest explicitly documented as such — not Ed25519, so C2PA signing is not crypto-grade; and embedWatermark (watermark-capture.ts:516-532) operates on an abstract carrier-energy scalar (hostEnergy), not a Float32/PCM buffer, so it cannot watermark a real mixdown as written. The root cause of every unwired gap is the same: DawSession (daw/types.ts:406-456) carries only PatternOrigin — no prompt/model/settings/content-hash, no provenanceLog, no splits/license/territory fields — so even though buildC2paManifest and embedWatermark exist and pass tests, there is no data to feed them and no call site.

Remaining gaps#

The P0/P1 cluster (RIGHTS-1/-2/-5/-N1/-3/-4/-11/-15) is striking because it is almost entirely local-actionable: the SOTA-grade algorithms already exist in-tree and pass tests — the work is a DawSession provenance-substrate extension plus dependency wiring, not new research. The single highest-leverage move is to add a provenanceLog to DawSession, populate it at every generate/transcribe/accompaniment call, add @euterpe/provenance as an app dependency, and route it through buildC2paManifest (after upgrading signClaim toward a real signature and generalizing embedWatermark to PCM) at export. That one substrate unlocks RIGHTS-1, -2, -4, -11, and -15 at once and converts the current free-text ICMT label into a machine-readable, cryptographically-attested credential.

Where Euterpe leads#

Euterpe's library substrate genuinely exceeds the SOTA DAW bar — no flagship DAW (Logic, Cubase, Pro Tools, Studio One) ships an in-tree C2PA manifest builder, watermark embed/detect with a transform-robustness battery, on-chain rights registry, royalty AMM, or a melody/lyric similarity engine. The prior headline ("most complete foundational provenance lib of any DAW, ~95% unwired") is accurate and intact: the lead is latent, gated entirely on wiring it into the DAW session and export path.

Verification notes#

Adversarial pass attempted to refute each of the 8 headline gaps by hunting for an existing/wired implementation in apps/euterpe-studio-web/src + libs/euterpe. All 8 stand. Verdicts:

• RIGHTS-1 — confirmed-absent. buildC2paManifest exists (watermark-capture.ts:765) but is never imported by the app; no @euterpe/provenance dep, no transitive re-export, zero grep hits, no DawSession substrate (types.ts:406-456). Gap stands.
• RIGHTS-2 — confirmed-absent. embedWatermark/detectWatermark (:516/:555) real but unimported; verified embedWatermark operates on a scalar hostEnergy (line 526), not a PCM buffer. Gap stands.
• RIGHTS-5 — confirmed-absent. scanCopyrightedPrompt (:213) real; generator-panel.tsx has zero copyright/safety/similarity references; no dep. Gap stands.
• RIGHTS-N1 — confirmed-absent (missing). TrackMetadata (metadata-tags.ts:23-38) and the panel (transport-bar.tsx:575-607) carry only title/artist/album/year/genre + ISRC; no ISWC/UPC/aiDisclosure anywhere in the app. Gap stands.
• RIGHTS-3 — confirmed-absent. rights-consent.ts (1111 LOC, validateSplitSheet:501, evaluateTerritory:570, advanceSampleClearance) real; no clearance panel and no import in the app. Gap stands.
• RIGHTS-4 — confirmed-absent. royalty-agent (1012 LOC), royalty-liquidity (778 LOC), validateSplitSheet real; DawSession has no splits field and no split panel exists. Gap stands.
• RIGHTS-11 — partial-exists (evidence corrected, gap unchanged). The lib is real but the prior evidence's function name verifyProviderAttestation does not exist; the actual provider-proof functions are captureProviderAttestation (provider-proofs.ts:1120), verifyForDownstream (:1003), and captureWatermarkEvidence (:255), and the importable detector is detectWatermark (watermark-capture.ts:555). The app-side claim is fully confirmed-absent (sampler/realtime have zero detect/verify calls, no dep). Evidence + recommendation corrected to cite the real symbols; status (present-unwired) is unchanged.
• RIGHTS-15 — confirmed-absent. melodySimilarityPreflight/lyricSimilarityScan/postGenerationSimilarityScan (:348/:403/:425) real; generate-clip.ts has no similarity scan (its only provenance mention is a comment at :73 about a chord-label string) and no import. Gap stands.

Net correction: one evidence-precision fix (RIGHTS-11 function names) and an evidence-precision note added to RIGHTS-1's recommendation re: signClaim. No gap was downgraded to polish or removed as already-present — every headline claim of absence holds against the code.

7. Cross-cutting gaps, entirely-missing areas & three-pillar verdict#

Cross-cutting & entirely-missing capability areas#

Re-classification of the 15 prior 'entirely-missing' areas (current codebase)#

Several areas have moved from absent to partial because a substantial library now exists — but is not wired into the DAW product (the app apps/euterpe-studio-web/src imports only 5 of ~25 @euterpe libraries: audio-engine-web, master, core, genesis, transcribe).

Cross-cutting gaps the 13 dimensions did not isolate#

1. Provenance is a text LABEL, not a C2PA manifest or audio watermark (P0). apps/.../daw/provenance.ts summarizeProvenance() returns "a one-line content-credentials label suitable for export metadata." The identical gap recurs across MIX-35, AI-19, RIGHTS-1, RIGHTS-2, MASTER-N2 — five P0/P1 items collapse to one fix: a signed C2PA manifest + imperceptible PCM/SynthID watermark on exported audio.
2. Unwired-library debt is the structural root cause (P0). ~20 substantial libs exist but the product imports 5; this single fact explains the bulk of "lib exists, unwired" sub-gaps (UX-28, MASTER-8/11/18, ARR-N3, AI-N5, IO-N3…).
3. The Session/Clip-launch View is one missing surface counted six times (ARR-7, UX-23, IO-N5, REC-4, MIDI-13, REC-N2) — the defining nonlinear-performance hole.
4. No cloud / collaboration layer exists at all (P0). Zero CRDT/presence (all 'presence' hits are EQ-band false positives); the only WebSocket is the MRT2 generation stream. COLLAB-1/2/5 + UX-22 + IO-13 + AI-16 are genuinely greenfield.
5. No unified modulation system (P0) — UX-5/FX-7; its absence also explains why "modular" reads absent.
6. Plugin hosting (VST3/AU/CLAP) repeats in every dimension as a native-desktop platform boundary, correctly un-fixable on the current web target.

Three-pillar verdict#

(a) AI integration / utilization — NOT yet SOTA. Strong, differentiated foundation: on-device MRT2 realtime generation wired live into the mixer (generator-panel.tsx, fail-closed) + transcribe + genesis. But the AI surface is realtime-stream-only — no one-shot text→editable clip (AI-8) and no agentic copilot writing MIDI into the arrangement (AI-N1), and neural stem-separation / polyphonic pitch-correction are unwired. Biggest blocker: export provenance is a one-line string, not a signed C2PA manifest + audio watermark — an AI-native DAW that cannot attribute or watermark its own output is not credible as SOTA.

(b) UI/UX — NOT yet SOTA. The linear DAW UX is solid and broad (25 real components: arrangement, piano-roll, channel-strip, synth/sampler, automation, master EQ/multiband, command palette, a11y, customizable keymap). But the modern-DAW-defining nonlinear surface is entirely absent, alongside bus/aux mixer architecture (MIX-2), unified modulation UI (UX-5), take-comping (UX-10), dockable screensets (UX-1), notation, semantic asset browser (UX-7), i18n, and multi-window. Biggest blocker: the missing Session/Clip-launch View — the surface that separates a linear editor from a modern performance DAW.

(c) All-other-DAW-aspects — NOT yet SOTA (most gaps live here). Engine internals are strong (Rust dsp-graph, f64 paths, real master/loudness/dither/goniometer, DAWproject I/O). But structural unwired-library debt dominates (5 of ~25 libs imported), native-bound gaps cap pro parity (VST3/AU/CLAP hosting, CoreAudio/ASIO, multicore scheduler), and there is no cloud/collaboration backend whatsoever. Biggest blocker: the total absence of cloud project storage + real-time collaboration (COLLAB-1/2, P0) — every other "other" gap is incremental by comparison.

Status of the 15 prior "entirely-missing capability areas" (re-checked at HEAD):

Appendix A — 2026 SOTA benchmark digests#

The external reference these gaps were measured against. Six web-research passes; each digest names which vendors ship what.

A.1 2026 flagship-DAW competitive benchmark: where the nine market leaders converge and diverge across arrangement, MIDI/composition, audio engine, mixing, modulation/effects, session/clip workflows, and the new wave of on-device AI#

By 2026 the flagship DAW field has converged on a shared baseline — on-device AI stem separation, generative MIDI, a creative modulation system, and Melodyne/ARA-grade audio editing are now table stakes rather than differentiators — while each vendor still keeps one or two defensible moats.

AI stem separation is universal: Logic 11 (Stem Splitter, 4-way: drums/bass/vocals/other, on-device M-series), Ableton Live 12.3/12.4 Suite (Vocals/Drums/Bass/Others, local, powered by Music AI/Moises, Jan-May 2026), Studio One 7 (4-way un-mix, Oct 2024), FL Studio 21.2/2025 (vocals/music/bass/drums, cloud ML), and Pro Tools (ARA-based). Apple is the clear AI leader for music creation: Logic Pro 11 Session Players extend Drummer to AI Bass Player (8 styles, complexity/intensity, reacts to chord track in real time) and Keyboard Player; ChromaGlow (5 AI-modeled saturation styles on Apple silicon) and Mastering Assistant (auto EQ/dynamics/loudness, Transparent/analog character presets, now to 192 kHz) push AI into mixing/mastering. Pro Tools 2025.6+ leads on AI for post/dialogue: Speech-to-Text (offline + batch transcription, word-searchable sessions), AutoBeat Lite (12-track generative MIDI beat engine), and the ARA2 VoiceWunder speech-synth plugin (74 languages); 2025.10 adds the SoundFlow AI Session Assistant.

Generative/creative MIDI is the other convergence axis. Ableton Live 12 leads with MIDI Generators (melody/chord/rhythm with constraints, scale-aware) and MIDI Transformations (ornaments, articulations, strum/guitar sim), plus Sting and Patterns generators in 12.2 — all extensible via Max for Live MIDI Tools. Cubase 14 counters with a full creative-automation overhaul: six Modulators (LFO, Envelope Follower, Shaper, Macro Knob, Step Modulator, ModScripter) routable to nearly any audio/instrument/MixConsole parameter and MIDI-note-triggerable, plus a new Drum Machine + Pattern Editor. Bitwig remains the modulation king — its program-wide Unified Modulation System (modulators on devices, mixer and project level) plus 5 MSEG modulators (Segments/Curves/Scrawl/Slopes/Transfer) and The Grid modular environment are unmatched for sound design; 5.3 (Feb 2025) added 25 drum devices (808/909/digital families) and a Stepwise sequencer.

Notation/composition: Cubase 14's headline is a Dorico-powered Score Editor (shares Dorico's transcription engine, cleans up live-performance irregularities) — the strongest in-DAW notation among the group. Logic adds a Chord Track; Studio One 7's Chord Track drives instrument parts and audio playback, detecting chords from polyphonic audio via Melodyne.

Audio editing/comping/warp: REAPER 7 brought Swipe Comping (multi-take composites, A/B, crossfades) and new polyphase pitch/time-stretch. FL Studio 2025 finally added in-Playlist per-instance stretch/pitch/reverse. Cubase (VariAudio/AudioWarp), Studio One 7 (ARA Melodyne comping — takes editable before comp is finalized), and Pro Tools (audio comping + MIDI/Instrument Playlists for takes) round out a mature field. Pro Tools also brought non-linear Sketch sessions for loop/idea capture before the timeline.

Session/clip-launch & live: Ableton remains the Session View archetype (follow actions, scene launch); Bitwig's Clip Launcher with Next Actions and background recording, and Studio One 7's new Integrated Launcher (grid of audio+MIDI cells, capture performances to timeline) bring the paradigm to traditionally-linear DAWs. Bitwig 5.3 added Master Recording.

Audio engine, formats, immersive: Pro Tools Ultimate leads raw scale (2048 audio / 1024 MIDI / 512 instrument tracks, 256 I/O) and immersive breadth — 2025.10-12 added native Sony 360 Reality Audio and UWA Audio Vivid alongside Dolby Atmos with cross-format conversion in one session. Logic 11.1/11.2 added the Quantec Room Simulator and iPhone-captured Spatial Audio + per-channel Elevation. The DAWproject open interchange format (Bitwig-originated) is now adopted by Cubase 14 and Studio One, easing cross-DAW transfer. REAPER 7's FX Containers (nested, parallel plugin chains saved as one slot), 128 audio channels + 128 MIDI buses per track, and Retroactive MIDI Recording give it the most flexible routing per dollar.

Net: the moats in 2026 are — Logic = best on-device music-creation AI (Session Players + ChromaGlow + Mastering Assistant); Pro Tools = scale + immersive + post/dialogue AI; Bitwig = deepest modular modulation/sound-design; Ableton = generative MIDI + live performance + clip workflow; Cubase = Dorico notation + creative modulators; REAPER = routing flexibility + value; Studio One/FL = fast-converging all-rounders.

Emerging trends: On-device AI is replacing cloud AI for privacy/latency: Logic Stem Splitter + Ableton 12.3 stem separation explicitly run LOCALLY (audio never leaves the project); FL Studio's cloud-only stem model is now an outlier requiring internet. · AI is moving from production into mixing/mastering: Logic's Mastering Assistant + ChromaGlow and Pro Tools' SoundFlow AI Session Assistant show the AI frontier shifting from generation to automated mix/master decisioning. · Generative MIDI as a core differentiator: Ableton MIDI Generators/Transformations, Pro Tools AutoBeat Lite, and Cubase Modulators signal generative composition tooling baked into the timeline, not bolted on as plugins. · Adaptive virtual band members: Logic's Session Players (Bass/Keyboard/Drummer reacting to a Chord Track in real time) point toward DAWs shipping interactive AI instrumentalists, a category no competitor has matched yet. · Clip-launch / non-linear capture spreading to linear DAWs: Studio One 7 Integrated Launcher and Pro Tools non-linear Sketch sessions adopt Ableton/Bitwig's session-view paradigm, blurring the linear-vs-loop divide. · Open cross-DAW interchange via DAWproject: Bitwig-originated DAWproject is now in Cubase 14 and Studio One, signaling industry movement toward portable sessions and reduced lock-in. · Multi-format immersive convergence: Pro Tools 2025.10-12 authoring Dolby Atmos + Sony 360 Reality Audio + UWA Audio Vivid with in-session conversion shows immersive deliverables becoming a single unified workflow. · Speech-to-text and AI speech synthesis for post/dialogue: Pro Tools' word-searchable sessions (offline batch transcription) + VoiceWunder (74-language synthesis) mark AI's expansion into ADR/podcast/dialogue editing. · Apple-silicon-gated AI as competitive lever: ChromaGlow and on-device Stem Splitter leverage M-series neural capability, dropping Intel Mac support — hardware-accelerated AI is becoming a platform moat. · Convergence of the baseline feature set: stem separation, ARA/Melodyne comping, a modulation system, generative MIDI, and audio warp are now expected in every flagship, compressing differentiation into a few defensible moats per vendor..

A.2 2026 state of the art in AI for music creation — capability landscape for benchmarking an AI-native DAW#

By mid-2026 AI has moved from a novelty "song generator" to a layered production stack, and an AI-native DAW must compete on every layer at once, not just generation. The decisive 2026 shift is that intelligence is collapsing INTO the DAW timeline: the winning pattern is no longer a browser tool that spits out a finished MP3 you re-import, but an agentic copilot that writes editable MIDI directly to the arrangement, loads instruments, runs stem separation, and edits in place (VIXSOUND-style native chat, Logic AI Session Players, FL's Gopher, plus MCP servers like ableton-copilot-mcp that let an LLM drive Live's arrangement/track/MIDI/recording in real time). For Oshun/Euterpe specifically, the most strategically relevant 2026 development is Google's Magenta RealTime 2 (the same lineage already integrated per project memory): a 2.4B open-weights model (plus a 230M variant) with a C++/MLX inference engine running natively and offline on Apple Silicon, hitting ~200ms control latency / 40ms frames (~15x faster than v1's 3s) — proving real-time, on-device, instrument-like generation is now feasible and is the differentiator against cloud-only round trips (200–2000ms). The competitive bars by layer: (1) GENERATION — Suno v5/v5.5 is the consumer leader (studio-grade vocals, 50+ genres, up to 12 stems, voice cloning, fine-tune-on-your-tracks, Warp Markers/Remove FX/Alternates editing), Udio's surgical inpainting is still uniquely differentiated (but its export/download was crippled by 2025 copyright settlements), Google's Lyria 3 Pro (3-min structured songs, via Vertex AI/YouTube, SynthID-watermarked), and crucially Stable Audio 2.5 is the licensed/commercially-safe enterprise option with <2s for a full 3-min track on H100 plus text-to-audio, audio-to-audio AND audio inpainting — the best fit for a product that must avoid copyright liability; Meta MusicGen/AudioCraft remains the open-source/self-host baseline. (2) STEM SEPARATION — HT-Demucs (free, local, open) is the quality+privacy leader for self-hosting and beats cloud on transients; AudioShake is the enterprise/rights-cleared API; LALAL.ai the cleanest paid cloud API; Moises the best practice-musician UX. (3) MIX/MASTER — iZotope Ozone 12 / Neutron 5 / Nectar 4 assistants set the assisted-chain bar, Sonible smart:EQ 4 added cross-channel intelligence (listens to multiple tracks and carves space), and LANDR/Masterchannel (reinforcement-learning, hands-off) own one-click mastering. (4) PITCH/TIMING — Melodyne 5 (DNA polyphonic) is the editing standard, Auto-Tune Pro 11 the creative/real-time standard, RX 11 for repair. (5) VOICE — RVC is the open real-time voice-conversion standard for covers, ElevenLabs the cloud all-rounder (voice clone + music + SFX, 70+ languages), Synthesizer V (Dreamtonics, v2.2 added AI Choir) and Vocaloid AI the singing-synth standards. (6) PROVENANCE — the dual standard converged on 2026-05-19 when OpenAI joined the C2PA steering committee and committed to embedding DeepMind's SynthID alongside C2PA Content Credentials, with Google bringing verification natively to Search and Chrome: C2PA is cryptographically-signed editable-history metadata, SynthID is the imperceptible watermark that for AUDIO survives re-recording, pitch shifting, and compression — neither sufficient alone, so an AI-native DAW should write C2PA manifests on export AND respect/propagate SynthID. Net benchmark guidance: to be credibly "AI-native" in 2026 a DAW needs an in-timeline agentic copilot, on-device real-time generation (Magenta RT2-class), licensed/commercially-safe generation (Stable Audio 2.5-class), local stem separation (HT-Demucs-class), assistive mix/master + pitch tools at parity with iZotope/Sonible/Melodyne, and built-in C2PA+SynthID provenance.

Emerging trends: Intelligence collapses INTO the DAW timeline: the winning pattern is an agentic in-DAW copilot that EXECUTES (writes editable MIDI, loads instruments, separates stems, edits in place) rather than a browser generator you re-import — VIXSOUND-native and MCP-driven (ableton-copilot-mcp, Claude Connector) are the 2026 reference points. · On-device, real-time, instrument-like generation becomes viable: Magenta RealTime 2 hits ~200ms control latency / 40ms frames as 2.4B open weights running offline on Apple Silicon via C++/MLX — collapsing the cloud round-trip (200–2000ms) and making generation playable like an instrument; directly validates Oshun/Euterpe's on-device strategy. · Commercial-safety / licensing becomes a product axis, not a footnote: Stable Audio 2.5 (fully-licensed training, on-prem enterprise license) and Google Lyria (SynthID-watermarked) position against the legal overhang — and Udio disabling downloads after 2025 copyright settlements shows litigation can kill a tool's core utility overnight. · Provenance converges and goes mainstream: the 2026-05-19 OpenAI+Google alignment on C2PA + SynthID (now verified natively in Search/Chrome) makes paired metadata + durable watermark the de-facto standard; an AI-native DAW must emit C2PA on export and respect/propagate SynthID through edits. · Personalization and identity move into generation: Suno v5.5 (clone-your-voice 'Voices', fine-tune-on-your-tracks 'Custom Models', 'My Taste'), ElevenLabs voice cloning, and Synthesizer V AI Choir push artist-specific models — raising consent/likeness/provenance stakes that the DAW must gate. · Editability beats one-shot generation: surgical, region-level tools win — Udio inpainting, Stable Audio 2.5 audio inpainting/audio-to-audio, Suno Warp Markers/Remove FX/Alternates, Melodyne DNA, RipX note-level stem editing — signaling users want to GENERATE THEN EDIT, not just regenerate. · Local + open-source stays competitive at the quality frontier: HT-Demucs (via UVR ensemble) still leads stem-separation quality while being free/local/private, and MusicGen/AudioCraft + the open voice stack (RVC, Coqui XTTS, OpenVoice, Bark) keep self-hosting viable — a hedge against cloud cost, privacy, and vendor/legal risk. · Cross-channel / context-aware assistive mixing emerges: Sonible smart:EQ 4 now listens to multiple tracks to carve space automatically, and iZotope/Masterchannel assistants propose whole chains — the bar for 'AI mixing' shifts from per-track suggestion to mix-aware, iterative, engineer-mimicking behavior..

A.3 2026 SOTA DAW UI/UX & workflow: non-linear clip-launch, unified everything-modulation, AI-semantic browsers, MPE/expressive controllers, deeply customizable + touch-native + collaborative workspaces#

The 2026 state of the art in DAW UX converges on several through-lines that a SOTA web DAW (Euterpe) should treat as table stakes.

1. NON-LINEAR CLIP/SESSION LAUNCH IS A FIRST-CLASS MODE, NOT A SIDE PANEL. Ableton's Session View (clips x scenes grid, per-clip triangular launch buttons, scene-launch column, Follow Actions for automated/probabilistic clip chaining) remains the reference. The defining workflow is "sketch non-linearly in Session, capture into a linear Arrangement." Bitwig 6 (2025) pushed this further with Clip Aliases (edit one clip, all linked copies update everywhere, in both launcher and arranger) and Automation Clips that detach automation from a single track lane so it can be moved/reused. Push 3's 2025 update brought Follow Actions to hardware. Takeaway: clip-launch + scenes + follow-actions + a capture/retrospective-record button are the modern non-linear composition core.

2. MODULATION SHOULD BE UNIFIED AND ASSIGNABLE EVERYWHERE, NOT HARDWIRED. Bitwig's Unified Modulation System is the gold standard: any device (native or VST) has modulator slots; 43+ modulator types (LFOs, envelopes, Macro/Macro-4 single-and-4-knob macros, Audio Follower, Macro XY, step sequencers) drag onto ANY parameter; modulators chain infinitely; the parameter knob stays usable so you can shift modulation range live; current modulated value stays visible; "modulation above one" supported. This beats a fixed mod-matrix grid. The Grid (235 modules, all signals stereo + interchangeable so any out-port connects to any in-port, pre-cords for wireless connections, drop-on-port auto-wiring, Inspector showing all in/out signals, sample-accurate timeline sync) shows how to expose modular patching while staying integrated.

3. BROWSERS ARE BECOMING AI-SEMANTIC + CROSS-TYPE. Ableton Live 12's Sound Similarity Search uses a neural net to find spectrally/timbrally similar samples AND presets from one seed (similarity score on timbre/pitch/spectral-temporal features), enables Drum Rack full-kit hot-swap, and unifies search across samples + instrument presets with a flexible tag system you can extend. Third-party movement (Waves COSMOS 2D cluster map, SampleSorter AI, Tuva, Curlo natural-language + slash-command metadata search) confirms the direction: embeddings-based semantic search, 2D similarity maps, natural-language queries, automatic tagging, and frictionless drag-drop into the timeline. A SOTA browser unifies samples/presets/MIDI/projects with semantic + tag search and drag-drop.

4. WORKSPACES MUST BE RESIZABLE, DOCKABLE, MULTI-WINDOW/MULTI-MONITOR, THEMEABLE. Reaper is the reference for radical customization: every window docks (top/bottom/left/right), floats, or shares tabbed docks; Screensets save entire layouts (open windows, positions, sizes, arrange zoom) recalled with one keypress; full theme engine reskins every pixel. Pro Tools/Cubase support dragging a parent window across monitors. Bitwig's Detail Editor adapts to selection (multi-clip layered editing, note + audio lanes side-by-side). Takeaway: dockable/floatable panels, savable screensets/workspaces, multi-monitor, theming.

5. COMMAND PALETTE / SEARCHABLE ACTIONS IS AN EMERGING, REQUESTED GAP. Studio One has a searchable command box; Cubase users are actively requesting a macOS-Help-style global "command palette" (still not native as of Cubase 15). This is a clear differentiation opportunity for a new DAW: fuzzy-searchable global action/command/preference palette.

6. MPE + EXPRESSIVE CONTROL IS THE EXPRESSIVITY FRONTIER. MPE (per-note pitch/pressure/timbre) pioneered by ROLI Seaboard (5D: Strike/Press/Glide/Slide/Lift) and LinnStrument (5 movements per pad), now mainstream via Push 3 (64 multi-sensor pads with X/Y), Expressive E Osmose 61, and native MPE synths (Ableton Meld with per-note bend/vibrato, Granulator III note-bend/vibrato/glissando). A SOTA engine needs per-note expression data model + MPE in/out + expression editing on notes (Bitwig 6 edits gain/pressure/expressions directly on notes/audio).

7. TOUCH/TABLET/STANDALONE IS NATIVE NOW. Logic Pro for iPad is touch-redesigned with full pro features + Learn MIDI mapping. Ableton Move (standalone, ARM, 4-hr battery, 32 poly-aftertouch pads, jog wheel, Capture/retrospective-record; 2.0 added audio tracks, slicing, Link Audio) plus Note (iOS sketchpad syncing to Live) show the "capture-anywhere -> finish-in-DAW" ecosystem and touch-first UX (large hit targets, encoders, gesture pads).

8. BROWSER-BASED + REAL-TIME-COLLABORATIVE DAWs ARE A REAL CATEGORY. BandLab (60M+ users, real-time collab, AI Mastering), Soundtrap (Spotify, real-time co-editing), Soundation (same-project simultaneous editing), Audiotool, Sesh, audio.com. Defining traits: zero-install, cloud projects, simultaneous multiplayer editing, built-in AI mastering/stem-split. Key limitation to beat: no VST/AU support. For a WASM-based engine this multiplayer-cloud-collab dimension plus native-quality DSP is the wedge.

9. ACCESSIBILITY: KEYBOARD-ONLY + SCREEN-READER IS ACHIEVABLE AND MATTERS. Reaper+OSARA is the proof-of-concept: full screen-reader access (NVDA/VoiceOver via MSAA/UIA), keyboard-driven navigation with speech feedback on UI elements/parameters, scriptable shortcuts, ReaperAccessible KeyMap + 200+ scripts. Lesson: expose a complete keyboard command surface and ARIA/accessibility tree from day one (web DAW has an ARIA advantage).

10. UNDO IS TRENDING TOWARD NON-LINEAR / HISTORY-AWARE. Most DAWs (Pro Tools, Logic, Ableton, Reaper) are non-destructive with linear undo-history lists. True branching "history-tree" undo (Emacs-style) is largely ABSENT from mainstream DAWs (Cubase even removed per-editor independent undo in 10.5) and is a recognized UX gap — an opportunity. Non-destructive editing is universal baseline; CRDT-style histories underpin the multiplayer DAWs.

11. ONBOARDING IS INTERACTIVE + ECOSYSTEM-LED. Ableton's Learning Music (browser, experiment with beat/melody/harmony/bass/structure) and Note-as-on-ramp are the model; in-app contextual help (Bitwig modules carry inline help docs you read without leaving the editor) reduces friction.

Emerging trends: Embeddings/neural semantic search over a UNIFIED asset graph (samples + presets + MIDI + projects), with 2D similarity/cluster maps and natural-language queries replacing rigid folder/category browsing (Ableton Sound Similarity, Waves COSMOS, Curlo, Tuva). · Modulation as a universal, freely-assignable layer over every parameter (incl. third-party plugins) rather than per-synth fixed mod-matrices — Bitwig's Unified Modulation System as the design target; macros (single-knob and 4-knob/XY) as the performance front-end. · Reusable, relocatable clip + automation primitives: aliases that propagate edits and automation that detaches from track lanes (Bitwig 6) — composition becomes object-oriented and non-linear. · Command palette / fuzzy global action search migrating from code editors into DAWs — explicitly requested (Cubase) and only partially shipped (Studio One); an open differentiation lane. · MPE / per-note expression going mainstream beyond niche controllers (Push 3, Osmose, native MPE synths) — per-note expression must be a core data-model concern, with on-note expression editing in the timeline. · Capture-anywhere ecosystems: standalone/battery hardware + mobile sketchpads (Move, Note, Logic for iPad) that round-trip into the desktop project, with 'Capture/retrospective-record' inferring intent instead of requiring armed recording. · Browser/cloud DAWs with real-time multiplayer co-editing and built-in AI mastering + stem separation as standard features (BandLab, Soundtrap, Soundation, Sesh); the remaining moat for newcomers is native-quality DSP + plugin support inside the browser (WASM opportunity). · Generative + analysis AI woven into the workflow: MIDI generators/transformers (Live 12), text-to-music, and AI stem separation (6-stem) increasingly expected natively and moving toward in-DAW integration through 2026. · Accessibility-first as a design constraint, not an afterthought: keyboard-complete command surfaces + screen-reader trees (Reaper/OSARA proves feasibility) — a web DAW can leverage ARIA to lead here. · Underexplored UX gap: non-linear / branching 'history-tree' undo. Universal non-destructive editing exists, but true Emacs-style branching undo is absent from mainstream DAWs and is a credible innovation surface, especially atop the conflict-free history models multiplayer collaboration already needs..

A.4 2026 DAW Interop, Formats & Standards: the open-exchange era arrives (Dawproject + CLAP + MIDI 2.0/UMP) while incumbents (VST3, AAX, AAF/BWF) remain the production floor#

The big 2025-26 story is that DAW interoperability finally has a credible whole-session exchange format. Dawproject (Bitwig/PreSonus, originated 2023) reached a stable v1.0 — a ZIP-of-XML container carrying audio clips, fades/crossfades, time-warping, transpose, notes + note-expressions, tempo/time-sig, MIDI messages, mixer state (volume/pan/mute/sends), full plug-in state, and parameter automation, plus clip-launcher scenes and four built-in devices (EQ/comp/gate/limiter). Adoption is real but still a "challenger club": Bitwig Studio 5.x, PreSonus Studio One 6.5+, Steinberg Cubase 14 / Nuendo 14 / Cubasis 3.7 / VST Live 2.2, and n-Track 10.2; Reaper only via a third-party tool. The conspicuous absentees — Logic, Ableton Live, Pro Tools, FL Studio — keep it from being universal, and crossfade/automation interchange is still maturing. (github.com/bitwig/dawproject; bitwig.com; soundonsound.com)

In plugin formats, CLAP crossed from novelty to momentum. By late 2024 ~15 hosts shipped CLAP (Bitwig, Reaper, FL Studio 21.3+, MultitrackStudio, MuLab, energyXT, Waveform), with major vendors (u-he, FabFilter, TAL, Surge) on board. Two catalysts define 2025: Steinberg open-sourced VST3 under MIT (read by many as conceding CLAP is the open-standard winner), and JUCE 9 is bringing first-party CLAP authoring (still in roadmap/late-dev as of the Q3-2025 update, not yet GA-confirmed), which removes the single biggest adoption barrier. CLAP's pitch is technical: full MIDI 2.0 / per-note modulation, a cleaner threading model for multicore, and simpler dev than VST3. Still missing from CLAP: Ableton Live, Logic, Cubase (host side), Pro Tools, Studio One. VST3 remains dominant by installed base; AU stays Apple-only; AAX stays Pro-Tools-exclusive (Native/DSP-HDX/AudioSuite tiers, no native VST/AU). (martinic.com; librearts.org; kvraudio.com; juce.com; clapdb.tech)

ARA2 (Celemony/PreSonus) is the mature deep-edit extension — non-real-time, random-access audio sharing for Melodyne and iZotope RX — supported across Pro Tools, Logic, Cubase/Nuendo, Studio One, Cakewalk, Reaper, Waveform, Samplitude/Sequoia, Mixcraft (Bitwig still a long-standing wishlist gap). Note RX Music Rebalance via ARA2 has been Logic-first.

Post/broadcast interchange is unchanged but solid: AAF is the modern standard (carries volume automation + track names, where legacy OMF drops them); FCP exports XML that tools like X2Pro/Vordio/Resolve convert to AAF for Pro Tools; MXF/AAF underpin picture↔sound round-trips. BWF (WAV + bext chunk) plus iXML 2.0 (now with structured sub-tags, <NO_GOOD> deprecated) remain the field-recording metadata backbone (Sound Devices, Zaxcom, Nagra, Aaton). Immersive delivery has consolidated on ADM BWF at 48k/24-bit as the Dolby Atmos master, with Netflix BWAV ADM guidelines (Feb 2025) requiring D/M/E/N group labels.

MIDI 2.0 took a concrete OS step: Windows 11 MIDI Services now ships a native in-box UMP/MIDI-2.0 stack with multi-app routing — UMP carries 256 channels (16 groups × 16), variable 32/64/96/128-bit packets, high-res CVMs, per-note expression and MPE-style data, plus Capability Inquiry (profiles/property exchange). Practical benefit is still gated on device firmware and DAW/plugin updates. Sync: Ableton Link remains the de-facto peer tempo/phase sync; MTC (no tempo) and LTC/SMPTE cover frame-accurate lock, often bridged by converters.

Codecs settled into clear lanes: FLAC = lossless standard; Opus = best sub-128k + low-latency/WebRTC (patent-free); AAC = streaming/broadcast default (HLS/DASH); Ogg Vorbis = Spotify Premium 320k; MP3 = universal fallback. Samples: SFZ is the open quasi-standard interchange pivot between Kontakt/EXS, with Decent Sampler rising as a third common delivery format. Notation: MusicXML 4.0 (W3C, 2021) is universally read by Finale/Dorico/MuseScore; a 4.1 draft landed April 2025; MNX is the long-horizon successor, still in development.

Emerging trends: Open whole-session exchange goes mainstream-adjacent: Dawproject v1.0 is the first credible cross-DAW session format, but remains a 'challenger club' (Bitwig/PreSonus/Steinberg/n-Track) until Logic, Ableton, Pro Tools, and FL Studio join — and automation/crossfade fidelity is still being completed. · VST3's MIT open-sourcing + JUCE 9 native CLAP authoring signal a structural shift toward open plugin standards; CLAP and VST3 will coexist for years, with CLAP winning the 'open + MIDI 2.0 + multicore' narrative while VST3 holds the installed base. · MIDI 2.0 moves from spec to OS plumbing: Windows 11 MIDI Services delivers a native in-box UMP stack with multi-app routing, but per-note-expression/Profile payoff is still bottlenecked on device firmware and DAW/plugin updates. · Immersive audio standardizes on ADM BWF (48k/24-bit) as the universal Dolby Atmos master, with platform delivery specs (Netflix BWAV ADM, Feb 2025) hardening D/M/E/N stem-labeling conventions. · iXML 2.0 + BWF mature into spatial/Atmos workflows, and the field-recorder-to-post metadata chain (Scene/Take/Notes) is now expected end-to-end. · Sample-library delivery is trending multi-format (Kontakt + SFZ + Decent Sampler), with open SFZ as the interchange pivot — reducing single-vendor lock-in. · ARA2 is now table-stakes for deep audio editing (Melodyne/RX) across nearly every major DAW, leaving Bitwig's missing ARA support as a conspicuous outlier. · Notation interchange is incrementally evolving (MusicXML 4.1 draft, April 2025) while MNX remains the still-unshipped clean-slate successor — practical interop stays on MusicXML for the foreseeable future..

A.5 2026 SOTA Platform, Audio-I/O, Collaboration & Hardware for DAWs#

State of the art across the DAW platform stack splits sharply along native-vs-web lines. NATIVE AUDIO I/O remains the latency ceiling: macOS CoreAudio is the consistent low-latency leader (a few ms, no separate driver layer), Windows needs ASIO (well-tuned interface drivers reach ~4.6ms round-trip; WASAPI Exclusive can match it but Shared mode adds 8-28ms), and Linux ALSA + an RT-patched (PREEMPT_RT) kernel posts the lowest measured figures of all. True "sub-3ms" round-trip is achievable only at tiny buffers (32-64 samples) on premium interfaces and stresses the whole DSP graph — it is a buffer/driver/interface system property, not a single switch. WEB AUDIO is closing the gap but structurally constrained: AudioWorklet runs DSP on a dedicated high-priority thread at a FIXED 128-sample render quantum (~2.9ms @44.1k), but real-world output latency is platform-bound (~10ms Windows, a few ms macOS/iOS, 30-40ms Linux/PulseAudio, 12-150ms Android), GC pauses and AudioParam-event floods cause dropouts, and the 128-sample mandate triggers crackle on many mobile browsers. SharedArrayBuffer (lock-free ring buffers, requires COOP/COEP cross-origin isolation) + WASM/SIMD (Rust compiled to the audio thread) is the SOTA pattern; openDAW, Soundation (WASM threads), web-synth (Rust→WASM) and BandLab prove near-native browser DAWs are real in 2025-2026, with Tauri wrapping for native file access + lower latency. MULTICORE/STREAMING: Reaper leads (>95% utilization via anticipatory/out-of-order FX processing), Cubase ASIO-Guard pre-renders non-live tracks, Logic on Apple Silicon parallelizes well at mix but lagged on e-cores; the unavoidable constraint is the single live-record track pinned to one thread. Avoid SMT/hyperthreads for DSP; >32 logical cores yields little. CONTROL SURFACES: MCU (1024-step fader resolution) and HUI (MIDI-based) remain the lingua franca; EUCON (Avid, Ethernet, 250x MIDI speed, 8x resolution) is the high end, with the free Avid Control app bringing wireless EUCON to phones/tablets; OSC + TouchOSC for networked/custom; Ableton Push 3 (now standalone) and Launchpad lead the grid/clip world; MIDI Learn is table-stakes. COLLABORATION: split between async cloud version-control (Avid Cloud Collaboration in-session multitrack merge; Splice Studio free backup/versioning/comments though no Cubase) and real-time streaming (Audiomovers Listento lossless low-latency monitoring) and loop-jam (Endlesss/Aux). True simultaneous multiplayer DAW editing is still largely unsolved at scale; the enabling tech (CRDTs — RGA, modern EG-Walker — for serverless offline-capable convergence vs OT for server-mediated) is mature in text but not yet standard in audio. VERSION CONTROL: Git works on text/XML project files (Reaper) for branch-per-cue workflows but chokes on un-diffable binary audio and huge stem repos; DAW-native snapshots (Cubase Arranger, Sonar MixRecall) fill gaps. PWA/OFFLINE-FIRST: Service Workers + OPFS (Origin Private File System for sample/project persistence) + cache-first strategies make offline web DAWs viable (openDAW ships OPFS sample import, planning full offline PWA). ACCESSIBILITY: Reaper + OSARA + NVDA is the gold standard for blind producers; Pro Tools is partially accessible via PTAccess scripts + VoiceOver (Berklee's free 20-hour course); Logic Pro is reasonably VoiceOver-accessible but Mac-only; the persistent blocker is third-party plugin GUIs lacking screen-reader exposure.

Emerging trends: Rust-to-WASM audio engines inside AudioWorklet are now production-real (openDAW, Soundation WASM-threads, web-synth), making near-native browser DAWs a 2026 reality rather than a demo · Tauri (and similar) wrapping of web DAWs to regain native file-system access and lower latency — collapsing the desktop/web divide rather than choosing a side · OPFS + Service Workers turning browser DAWs into genuine offline-first PWAs with local sample/project persistence (openDAW leading) · CRDTs (RGA → EG-Walker) poised to bring true serverless, offline-tolerant, simultaneous multiplayer editing to audio — mature in text, the open frontier for DAWs · Convergence of three collaboration modes that are currently separate products: async project-merge (Avid/Splice), live lossless monitoring (Audiomovers), and real-time loop-jam (Endlesss) — an integrated stack is an unfilled niche · Wireless/tablet control surfaces over Ethernet/Wi-Fi (free Avid Control EUCON app, OSC/TouchOSC) eroding the need for dedicated motorized-fader hardware · Apple-Silicon-aware scheduling (P-core/E-core, unified memory) as the new multicore-DSP frontier; Reaper-style anticipatory/out-of-order FX processing as the utilization benchmark to beat · Sub-3ms round-trip moving from exotic to attainable on premium interfaces, shifting the real bottleneck to plugin/graph headroom and live-track single-thread pinning rather than the driver · Accessibility shifting from DAW-core (largely solved by Reaper/OSARA, Pro Tools/PTAccess, Logic/VoiceOver) to the unsolved third-party-plugin-GUI screen-reader exposure problem · Mobile-browser audio reliability (crackle at the mandated 128-sample quantum on Android/iOS) as the gating issue for web DAWs reaching phone/tablet parity.

A.6 2026 SOTA mastering, distribution, immersive audio, and AI music-rights for DAWs#

As of mid-2026, four forces define the post-mix chain in a modern DAW: loudness-normalized streaming (convergence on a single master), AI-assisted/reference-matched mastering, object-based immersive audio (Dolby Atmos dominant, Sony 360RA fading), and a fast-hardening AI-provenance/rights layer that now reaches into distribution metadata.

LOUDNESS & STREAMING TARGETS. Platform normalization is universal and you generally ship ONE master rather than per-platform versions. Targets (integrated LUFS, ITU-R BS.1770-4): Spotify -14 (user-selectable -19/-14/-11; ~87% keep default), Apple Music -16 (no limiting), YouTube -14 (track-only, no limiting), Amazon Music -14 (no limiting), Tidal -14 (album normalization even in playlists), Deezer -15, Pandora ~-14 proprietary, SoundCloud none. AES (AESTD1008) recommends -16 LUFS music / -18 speech and album normalization. A safe universal master sits around -14 to -12 LUFS integrated. TRUE PEAK: -1 dBTP is accepted everywhere; -2 dBTP is the recommended universal ceiling because it satisfies Amazon's strict requirement and leaves AAC/Ogg Vorbis codec headroom (lossy encoding can push inter-sample peaks above 0 dBFS). Loudness-normalize-then-master logic: pushing far past target buys no loudness (it gets turned down) and only costs dynamics. Apple Music Atmos has a distinct, stricter spec (see immersive).

AI MASTERING. iZotope Ozone is the reference: Ozone 11 introduced AI Master Assistant with tonal-balance/width/impact targets learned from hundreds of hits, AI Vocal Balance, Stem Focus (apply any module to an isolated separated stem), and the Clarity module (adaptive spectral optimization to add loudness/sparkle without harshness). Ozone 12 (current) adds three modules — Stem EQ (splits into Vocal/Drums/Bass/Other, up to 8 bands each), Bass Control (AI low-end shaping for translation), and Unlimiter — plus IRC 5 limiting, a Custom Master Assistant flow (dozens of genre targets, toggleable modules, set loudness, choose analysis duration in seconds or bars), improved neural Stem Focus, and 25 new Stabilizer genre targets. Cloud/service AI mastering: LANDR (three styles + reference-track matching + a real-time DAW plugin with 5 controls: Loudness/Bass/Treble/Stereo width/Intensity), Masterchannel (Norwegian, reinforcement-learning, zero-control upload/download), eMastered, BandLab, CloudBounce, RoEx. Sonible smart:bundle (smart:EQ 4, smart:comp 2 — spectral engine ~2,000 bands, smart:limit, smart:reverb) provides genre-aware track-level AI. REFERENCE-TRACK MATCHING is a baseline expectation: load a commercial reference and match tonal balance, stereo width, and dynamics (Ozone, LANDR).

DYNAMIC EQ / MULTIBAND. The 2026 surgical-vs-broad split: dynamic EQ (frequency-specific gain triggered by threshold) for precise problem frequencies (harshness, plosives, boominess, resonances) because it's more transparent; multiband compression for broad tonal control / low-end glue. Leading tools: FabFilter Pro-Q 4 (per-band dynamic EQ), oeksound soothe2 (thousands of narrow dynamic cuts on ringing frequencies; 2026 DSP update reduces phasey artifacts), Ozone EQ, Waves Abbey Road TG Mastering Chain. Spectral processors (soothe2, Smooth Operator, Gullfoss) are now standard pre-limiter mastering tools.

IMMERSIVE / SPATIAL. Dolby Atmos music is the dominant format and the deliverable is the ADM BWF (Broadcast Wave + Audio Definition Model): 24-bit LPCM, 48 kHz, single frame rate, carrying bed channels + objects with positional metadata. DAW workflows: Logic Pro (native Atmos tools, create/import/export ADM BWF), Nuendo and Cubase (built-in Dolby Atmos Renderer, ADM authoring/export; Nuendo strongest for post — binaural + 7.1.4 monitoring), Pro Tools (with Atmos tools). For other DAWs, use the free Dolby Atmos Renderer + Binaural Settings plug-in. BINAURAL RENDER MODE metadata (critical because most Atmos music is heard on headphones) sets per-object/bed distance: Off (bypass), Near (~20 cm, vocals), Mid (~2 m, instruments), Far (~6 m, ambience/FX). APPLE MUSIC ATMOS DELIVERY is stricter than stereo streaming: integrated loudness must NOT exceed -18 LKFS, true peak <= -1 dBTP (BS.1770-4), ADM BWF only; upmixing from stereo, extracting stems from a stereo release, or a stereo mix merely placed in the field with reverb are all PROHIBITED — must come from real multitracks/stems; mastered to the Apple Digital Masters / Dolby Atmos Master ADM profile. SONY 360 REALITY AUDIO (MPEG-H 3D, up to 64 channels, object-based) still exists with the 360RA Creative Suite, but momentum is collapsing: Tidal dropped it and Deezer stopped offering it (Oct 2022), so content availability is the central risk — Atmos has effectively won immersive music.

METADATA & DISTRIBUTION. ISRC identifies the recording (one per master/video); ISWC identifies the composition (one ISWC -> many ISRCs); UPC identifies the release. Distributors (DistroKid, TuneCore, CD Baby, AWAL) auto-assign ISRCs at upload and embed/track ISWC; for CD Baby you don't pre-embed. DDEX is the supply-chain standard: ERN 4.x (4.3 current, plus Catalogue Transfer Standard 1.0) moves release/rights/pricing metadata between systems. NEW in 2026: DDEX AI disclosure — ERN v4.3.1 + the expanded MEAD (Media Enrichment and Description) spec add optional flags for recordings/contributions made fully or partly with generative AI; caveats: optional, no required model/vendor disclosure, "partially" undefined. Spotify AI Credits launched April 16, 2026, surfacing this DDEX disclosure in mobile Song Credits (voluntary now, infrastructure built for eventual mandatory labeling). Proactive DDEX AI disclosure is becoming the safest distribution posture.

AI RIGHTS / PROVENANCE / MONETIZATION. The industry converged on a TWO-LAYER provenance model: (1) C2PA Content Credentials — a signed JSON-LD manifest cryptographically bound to an audio/image/video file recording the producing model/device and edit chain; C2PA 2.1 was ratified and is now ISO/IEC 22144. (2) Imperceptible watermarking — Google DeepMind SynthID is the most-deployed (audio watermark survives re-recording, pitch shift, and compression; >100B assets watermarked by May 2026). On May 19, 2026 OpenAI and Google announced a dual-layer (C2PA + SynthID) model; OpenAI joined the C2PA steering committee. Regulation: California SB 942 effective Jan 1 2026; EU AI Act Article 50 enforcement begins Aug 2026. GENERATORS: Suno and Udio both settled with major labels (WMG with Suno; UMG with Udio, Udio later also WMG) — 2026 terms require licensed training data and PAID downloads; Suno/Udio/ElevenLabs Music embed C2PA-compliant watermarks encoding platform, model version, prompt hash, and timestamp; Suno offers up to 12-stem separation on paid plans, grants Pro/Premier users a perpetual commercial license (note: under WMG terms Suno is the legal "author," user gets a license, not ownership). Deezer reports detecting ~60,000 AI tracks/day (Jan 2026) and excludes fully-AI tracks from recommendations/royalties. RIGHTS/ROYALTY MODELS: data-licensing (catalog licensed for training, proportional pay), attribution-based royalties (pay scaled to dataset contribution), and collaborative-generation splits; emerging usage-logged micro-royalty distribution via smart contracts / blockchain-linked metadata. SPLIT SHEETS / CLEARANCE compliance is trending toward three layers: dataset transparency, attribution tracking (metadata linking output to datasets/models), and licensing automation. Typical stream payout ~$3-5 per 1,000 streams.

DAW IMPLICATIONS. A SOTA DAW mastering/export chain should: target ~-14 LUFS / -1 to -2 dBTP with built-in LUFS+true-peak metering and per-platform preview; offer reference-track matching and AI assist; support multiband + dynamic/spectral EQ on the master; author and export Dolby Atmos ADM BWF (24/48, objects+beds, binaural Near/Mid/Far metadata) with an Apple-spec validator (-18 LKFS, no stereo upmix); tag ISRC/ISWC/UPC and emit DDEX ERN/MEAD including the AI-disclosure flags; and embed C2PA Content Credentials (+ optionally SynthID) on AI-touched exports.

Emerging trends: Per-stem AI mastering: Ozone 12 Stem EQ / Stem Focus and Sonible spectral engines let mastering operate on separated Vocal/Drums/Bass/Other stems from a stereo file — blurring the mix/master boundary and enabling per-stem tonal repair at the master stage. · Convergence on a single loudness-normalized master (~-14 LUFS / -1 to -2 dBTP) for stereo streaming, with Dolby Atmos requiring a separate stricter deliverable (Apple: -18 LKFS, ADM BWF, no stereo upmix). · Dolby Atmos has effectively won immersive music while Sony 360 Reality Audio fades (Tidal dropped, Deezer stopped) — DAWs should treat Atmos ADM BWF as the primary immersive target and 360RA as legacy/optional. · Binaural Render Mode metadata (Near/Mid/Far per object) is now a first-class mastering decision because the dominant Atmos listening surface is headphones. · Dual-layer AI provenance standard solidified in 2026: C2PA Content Credentials (now ISO/IEC 22144) plus SynthID-style imperceptible audio watermarking, jointly endorsed by OpenAI and Google (May 19 2026) and embedded by Suno/Udio/ElevenLabs. · AI disclosure entering the distribution metadata pipeline: DDEX ERN 4.3.1 + MEAD AI flags and Spotify AI Credits (launched Apr 16 2026) — voluntary now, but infrastructure for mandatory labeling, pushed by CA SB 942 and EU AI Act Art. 50. · Generative-AI/major-label settlements (Suno-WMG, Udio-UMG/WMG) reset terms toward licensed training data, paid downloads, and license-not-ownership user rights — and platforms (Deezer) now exclude fully-AI tracks from recommendations and royalties. · Royalty/rights automation: smart-contract / blockchain-linked micro-royalties, attribution-based payouts scaled to dataset contribution, and three-layer clearance (dataset transparency, attribution tracking, licensing automation) are emerging as the AI-era split-sheet model. · Reference-track matching and zero-control upload-download mastering (Masterchannel, LANDR, Ozone reference match) are now baseline expectations rather than premium features..

Appendix B — full residual-gap catalog (all 186)#

Generated 2026-06-07 by a 47-agent research workflow (6 SOTA-benchmark web researchers + 1 re-baseline → 13 dimensions through Ground→Gaps→adversarial-Verify → completeness critic). 3.56M subagent tokens, 1084 tool calls. Supersedes EUTERPE_SOTA_DAW_REMAINING_WORK_2026-06-06.md as the current baseline.