The AI that lives inside your DAW — controls transports, tracks, and every knob of every plugin — without knowing them in advance.
A WhyEd™ Project · © 2026 @whyed
🌐 Website · ⭐ Star this repo · 🐛 Report a bug · 💬 Discord · 📸 Instagram · 𝕏 Follow
You don't need to know C++. You don't need to code. You don't need to map any preset.
You just need a DAW, a microphone for your ideas, and a question to type.
|
① Load the plugin |
② Just talk to it |
③ It talks back |
Works offline with Ollama — no API key, no subscription, no latency.
WhyCremisi installs on your master channel. From there, it takes full control of your DAW: it can play/stop/record, mute tracks, adjust volumes, and scan every parameter of every plugin in the session — Serum, FabFilter, Valhalla, anything. It exposes everything to an AI that can read, write and automate it all in real time. No preset mapping. No plugin SDK. No prior knowledge of the plugin. Just index-based VST3 parameter scanning, and an AI that learns what each knob does on the fly.
Table of Contents
- Mission & Vision
- The philosophy
- There are no limits to what you can ask
- It's a conversation, not a command line
- Smart suggestion widgets
- Why this is different
- The most advanced plugins in the world
- A full AI agent inside your DAW
- How it works
- Three phases of intelligence
- The wire protocol
- Session memory
- AI providers
- BotFace
- Features
- Plugin Dictionary
- Compatibility
- Quick start
- Project structure
- Roadmap
- Contributing
Mission: To bring the most powerful creative intelligence directly into the DAW — so the gap between what you hear in your head and what comes out of the speakers disappears.
Vision: To make the best AI tool for music producers on earth, and to leave the creative process better than we found it.
WhyCremisi was built around one belief: creativity has no limits, and neither should the tool.
Most audio software asks you to learn its language — menu structures, preset names, parameter ranges. WhyCremisi flips this. You speak in the language of music and emotion. The software figures out the rest.
You shouldn't need to know that "filter cutoff" is parameter index 0047 in Serum. You should be able to say "make it darker" and have it happen. You shouldn't need to reconstruct a mastering chain from memory — you should be able to say "master this like Pretolesi" and watch it apply, knob by knob, in your actual session.
- Ask anything. No supported commands. Say "mix this like Chris Lord-Alge" or "check the controfasi" or "rebuild the low end." The language of music, not menus.
- Every plugin. Including yesterday's. Serum 2, Pro-Q 4, Ozone 11, native DAW plugins — anything. VST3 parameter indices are read at runtime. Load a plugin and it's mapped. No update needed.
- A living encyclopedia. A curated dictionary of the most-used modern plugins — human-readable names, ranges, interdependencies, how pros use them. You can add entries. The community contributes via PRs.
- Creates, not just edits. Piano roll access. Full songs from scratch — verse, chorus, bridge, every instrument, every note — written directly into the timeline. Or just rewrite bars 5–8 and leave the rest.
- Remembers everything. Every parameter touch, every decision, every session. Cross-session memory. It knows your history and learns your taste.
- Has a personality. Thinks, replies, explains, pushes back. Has a face that shows how it feels. Not a search bar — a collaborator.
- Lives inside the DAW. Not an external app. Not a chatbot tab. On the master channel, always in the room.
The more sessions you run with WhyCremisi, the more it knows you. That history — your taste, your decisions, your sound — is yours. It compounds. You can't take it with you if you switch. → Full brand & community philosophy
No supported commands — just describe what you want. WhyCremisi figures out which knobs to move.
| What you say | What happens |
|---|---|
| "Mix this track the way Chris Lord-Alge would" | Parallel compression on drums, mid-forward guitars, punchy low end — applied to your session's plugins |
| "Master this like Stefano Pretolesi" | Clean limiting, controlled low end, Italian hi-fi warmth — on your actual master chain |
| "Check phases across all tracks — fix cancellations" | Analyzes polarity across plugins, flags and corrects phase issues before they kill your low end |
| "Mute the kick, drop the vocal 3dB, start recording" | Native transport + fader control — no clicking, no menus |
| "What did we change in the last 3 sessions on this track?" | Full recall from memory.json + events.jsonl — every parameter touch, every decision |
| "Remember: I always want the kick at -6dBFS. Apply this every session." | Written to long-term memory. Enforced automatically from now on |
| "Use Logic's built-in compressor, push the attack a bit" | Stock and bundled plugins mapped exactly like third-party ones |
| "Write me a full song — dark pop, 128 BPM, A minor, verse/chorus/bridge" | Opens the piano roll, composes the entire arrangement — every instrument, every note, every velocity — directly into the DAW timeline |
| "The verse is too predictable, rewrite bars 5–8 with unexpected intervals" | Selects the region, rewrites only those bars, keeps everything else intact |
If a human composer, engineer, or producer could describe a move in words — WhyCremisi will attempt it in knobs, regions, melodies, and the full arrangement.
WhyCremisi is not a search bar where you type exact commands. You talk to it the way you'd talk to a collaborator in the studio.
You: "Something feels off in the high end, not sure what"
AI: "The FabFilter Q3 has a +4.2dB shelf at 10kHz that might be too aggressive
for this mix. I also see Serum's oscillator brightness is at 78% — that's
quite high. Want me to pull both down a bit and see how it feels?"
You: "Yeah try it"
AI: [moves both parameters] "Done. The shelf is now +1.8dB and Serum brightness
is at 55%. How does that sit?"
The AI sees your full session — current values, what you changed recently, what's loaded, what's playing. It reasons from that context, not from a manual.
As the conversation evolves, WhyCremisi creates interactive parameter widgets directly in the plugin UI — no need to hunt for knobs across multiple plugin windows.
┌─────────────────────────────────────┐
│ Suggested tweaks │
│ │
│ FabFilter Q3 · High Shelf │
│ ████████░░░░ +1.8 dB [Apply] │
│ │
│ Serum · Osc A Brightness │
│ █████████░░░ 55% [Apply] │
│ │
│ Valhalla · Decay Time │
│ ████░░░░░░░░ 1.2s [Apply] │
└─────────────────────────────────────┘
The AI decides which parameters are worth surfacing based on your conversation. Widgets appear live, update as values change, and disappear when they're no longer relevant. You can apply each suggestion individually or tell the AI to go ahead with all of them.
Every widget interaction is logged to the session, so the AI knows what you accepted and what you ignored — and learns your preferences over time.
Every other "AI for music production" tool is either a standalone app disconnected from your session, or a chatbot that generates MIDI. WhyCremisi is a plugin — it loads in the same DAW process as your other plugins, sits on the master channel, and has native access to the VST3 parameter graph of the entire session.
| WhyCremisi | Standalone AI tools | Manual workflow | |
|---|---|---|---|
| Lives inside the DAW | ✅ VST3/AU plugin | ❌ External app | — |
| Controls transport (play/stop/record) | ✅ Native DAW commands | ❌ | ❌ Manual |
| Controls track volume, mute, solo | ✅ Real-time fader control | ❌ | ❌ Manual |
| Accesses any plugin's parameters | ✅ Universal bridge | ❌ Hardcoded presets | ❌ One by one |
| No preset mapping needed | ✅ Auto-discovery | ❌ Plugin-specific | — |
| Writes MIDI / creates regions | ✅ Piano roll access | ❌ | ❌ Manual |
| React UI inside the plugin | ✅ WebView | ❌ | — |
| Knows the session history | ✅ Flight Recorder | ❌ | ❌ |
| Streaming AI responses | ✅ Chunk-by-chunk | ❌ | — |
| Run offline | ✅ Ollama support | ❌ | — |
| Works with any DAW | ✅ JUCE/VST3/AU | ✅ |
FabFilter Pro-Q 4 just dropped. Serum 2 is out. iZotope Ozone 11, Neutron 5, RX 11. Native Instruments Kontakt 8. Waves' entire catalog. Plugin Alliance, Slate Digital, UAD — anything.
WhyCremisi doesn't need a software update to support them. It doesn't need a new preset file or a mapping patch. The moment you load any plugin in your DAW, WhyCremisi reads every parameter it exposes through the VST3 interface — index by index, in real time. A plugin released today works the same as one released ten years ago.
And on top of that: a living encyclopedia.
The Plugin Dictionary is a curated, human-readable knowledge base of the most-used modern plugins — their parameter names, ranges, behaviors, interdependencies, the way professionals use them. It ships with entries for the industry standards and it grows over time:
- You can add your own entries for plugins you use
- The community contributes mappings via pull requests
- The AI uses the dictionary to speak intelligently about plugins it already knows, and falls back to raw index scanning for everything else
The dictionary is not a limitation — it's an accelerant. WhyCremisi works with every plugin. It just works smarter with the ones in the dictionary.
This is the part that shouldn't be possible.
WhyCremisi doesn't just call an LLM and paste the response. It runs a complete AI agent with access to every tool a modern code agent has — from inside a plugin slot on your master channel.
| Tool | What it can do inside WhyCremisi |
|---|---|
| Web search | Look up mixing techniques, find reference tracks, research what a specific plugin parameter does |
| Bash execution | Run shell scripts, process audio files, call external tools, automate anything on your system |
| Code generation | Write and run code — generate Max for Live devices, MIDI scripts, automation data |
| File system | Read and write project files, export session reports, load stems, organize your library |
| DAW control | Play, stop, record, mute, automate, create regions, write MIDI — full native control |
| Plugin parameters | Read and write any knob on any plugin, any DAW, in real time |
| Session memory | JSONL log + cross-session memory.json — full recall of everything |
Imagine asking your DAW: "Search for how Chris Lord-Alge sets up his SSL bus compressor, then apply those settings to my master chain." WhyCremisi searches the web, reads the result, finds the closest parameters in your loaded plugins, and applies them. Without leaving the DAW. Without switching tabs. Without touching a single knob.
This is not a plugin that wraps an AI. This is an AI agent that happens to live inside a plugin.
WhyCremisi doesn't need to know what a plugin is. VST3 exposes every parameter as a numbered index. WhyCremisi reads them all. The entire communication stack runs inside the DAW process — no external app, no network roundtrip.
┌─────────────────────────────────────────────────────────┐
│ Your DAW session │
│ │
│ [Serum] [FabFilter Q4] [Valhalla] [OTT] ... │
│ │ │ │ │ │
│ └───────────┴───────────────┴────────┘ │
│ │ VST3 parameter graph │
│ ┌──────────▼──────────┐ │
│ │ WhyCremisi │ ← master channel │
│ │ │ │
│ │ AiEngine │ Ollama / Groq / │
│ │ SessionManager │ Gemini / Claude │
│ │ OscBridge │ OpenAI / OpenRouter│
│ └──────┬──────────────┘ │
└─────────────────────┼───────────────────────────────────┘
│
┌─────────────┴──────────────┐
│ │
OSC UDP :9000 WebSocket :8080
(DAW → plugin) (plugin ↔ React UI)
│ │
OSC UDP :9001 WhyCremisiBridge.js
(plugin → DAW) (singleton, auto-reconnect)
│
React UI (WebView)
transport · tracks · widgets
useWhyCremisi() hook
The 33ms broadcast loop — a JUCE Timer fires every 33ms (~30fps), pushing DAW state (transport, meter L/R/peak) to every connected WebSocket client. React stays in sync with the DAW in real time without polling.
The Flight Recorder — every event in the session is appended to a JSONL file with millisecond timestamps. Parameter changes, transport events, AI prompts and responses, OSC messages, errors — all of it. The AI sees not just the current state but everything that happened since you pressed play.
| Phase | What it does | Status |
|---|---|---|
| ① Universal Bridge | Scans and maps all VST3 parameters by index across every loaded plugin. Read + write in real time. | ✅ Live |
| ② Plugin Dictionary | Semantic layer that maps index numbers to human-readable names for the 10 most-used plugins in the world. "Filter cutoff" instead of "param_0047". | 🔧 Building |
| ③ Auto-Discovery | AI infers what unknown parameters do by observing their effect on audio. Learns any plugin without a dictionary entry. | 🔮 Roadmap |
Phase ① alone is already useful. You can ask the AI to move a parameter and it will find it. Phases ② and ③ make it fluent.
The wire protocol — full message reference
Every message on the WebSocket is a JSON object:
{ "type": "ai.prompt", "id": "uuid-v4", "timestamp": 1718123456789, "payload": { ... } }DAW → UI events the plugin broadcasts:
| Message type | What it carries |
|---|---|
daw.transport |
isPlaying, isRecording, BPM, positionSeconds |
daw.track |
trackId, name, volumeDb, pan, muted, soloed |
daw.meter |
trackId, leftDb, rightDb, peakLeftDb, peakRightDb |
ai.response |
requestId, content, provider, isComplete |
ai.stream |
requestId, chunk, isDone — for streaming responses |
ui.widget.create |
widgetId, widgetType, title, config |
ui.widget.update |
widgetId + updated values |
plugin.error |
code, message, severity |
UI → DAW commands the React side can send:
| Message type | Effect |
|---|---|
daw.command |
play, stop, record, setVolume, etc. |
daw.request |
request track list, session state |
ai.prompt |
dispatch a prompt to the AI provider |
ui.widget.create/remove |
manage dynamic UI widgets |
osc.send |
forward a raw OSC message to the DAW |
config.get / config.set |
read/write plugin config at runtime |
Session memory — full storage layout
~/Library/Application Support/WhyCremisi/
sessions/
20240615_142301/
header.json ← session metadata, written once at start
events.jsonl ← one JSON object per line, append-only
summary.json ← event counts per type, written at end
current.json ← always-fresh live snapshot of active session
memory.json ← long-term knowledge base, updated across sessions
events.jsonl is the core: append-only, zero-overhead, reconstructable. Every logOscEvent, logTransport, logParameter, logAiPrompt, logAiResponse, logError call adds one line. The rate-limiter keeps meter ticks to 1 entry per 500ms and position ticks to 1 per second — so the log stays usable at high sample rates.
memory.json accumulates knowledge across sessions. The AI doesn't start from zero each time.
| Provider | Default | Notes |
|---|---|---|
| Ollama | ✅ yes (llama3.2) | Runs at localhost:11434, fully offline |
| Groq | — | Fast inference, free tier available |
| Gemini | — | Google, flash and pro models |
| Anthropic | — | Claude 3 family |
| OpenAI | — | GPT-4o and variants |
| OpenRouter | — | Single key, any model |
Config: temperature 0.7, maxTokens 2048, timeout 30s. All providers share the same sendPromptAsync() interface — swap with one config change.
WhyCremisi isn't a toolbar with an LLM behind it. It has a face, emotional states, and a voice. BotFace is the animated SVG mascot living inside the plugin UI — and it reacts to everything happening in the session in real time.
| What's happening | BotFace state |
|---|---|
| You sent a prompt | thinking — processing your request |
| AI is streaming a response | typing — word by word |
| Response complete | success → back to idle after 2s |
| Something went wrong | error → recovers to idle after 3s |
| Waiting for you | idle |
9 emotional states total, animated with framer-motion. It's not decorative — it's a live status indicator that makes the AI feel present, not just functional. When WhyCremisi is thinking about your mix, you see it think. When it's done, it settles. It feels alive because it is, in the only way software can be.
- Universal parameter bridge — reads and writes any VST3 parameter by index, across all plugins simultaneously
- Piano roll access — writes MIDI regions, melodies, chord progressions, full song arrangements directly into the DAW timeline
- Flight Recorder — append-only JSONL session log + cross-session
memory.json, injected as context into every AI prompt - Streaming AI responses — chunk-by-chunk
ai.streammessages, BotFace animates during generation - BotFace mascot — animated SVG mascot with 9 emotional states, state machine driven by WebSocket message types
- React WebView UI — full React app rendered inside a JUCE WebView,
useWhyCremisi()hook for clean integration - WhyCremisiBridge.js — WebSocket singleton with auto-reconnect (10 attempts, 2s interval), pending request map, typed event emitter
- 33ms broadcast loop — JUCE Timer pushes transport + meter to React at ~30fps
- Dynamic widget system — C++ broadcasts
ui.widget.create/update/remove, React renders them live - Multi-provider AI — Ollama (offline default) + Groq + Gemini + Claude + OpenAI + OpenRouter
- 14 automated tests — CI-ready, build is stable
- VST3 + AU + Standalone — one codebase, three build targets
The plugins that cover ~90% of real-world sessions. Every plugin works via index scanning on day zero — the dictionary adds semantic understanding on top:
| Plugin | Category | Status |
|---|---|---|
| Serum / Serum 2 | Synthesizer | 🔧 Mapping |
| Vital | Synthesizer | 🔧 Mapping |
| Massive X | Synthesizer | 📋 Queued |
| FabFilter Pro-Q 4 | EQ | 🔧 Mapping |
| FabFilter Pro-C 2 | Compressor | 📋 Queued |
| OTT | Multiband | ✅ Complete |
| iZotope Ozone 11 | Mastering | 📋 Queued |
| Valhalla VintageVerb | Reverb | 📋 Queued |
| Valhalla Delay | Delay | 📋 Queued |
| Waves SSL E-Channel | Channel strip | 📋 Queued |
| Environment | Support |
|---|---|
| macOS (Monterey+) | ✅ Primary development platform |
| Windows (10/11) | ✅ JUCE cross-platform build, tested |
| Linux | ✅ JUCE cross-platform build, tested |
| Modern DAW (Logic 11, Ableton 12, Cubase 13+) | ✅ Full — SDK extensions, extended context |
| Older DAW (Logic 10.7, Ableton 11, Cubase 12) | ✅ Full — core parameter bridge, all features |
| Legacy sessions / older plugin versions | ✅ Read + write via index scanning |
| AU (macOS only) | ✅ Same bridge, AU format |
| Standalone mode | ✅ No DAW needed, bridge runs independently |
The VST3 SDK extension architecture (note expression, MIDI 2.0, MPE) is supported where available and degrades gracefully where it isn't. The core mechanism — VST3 index-based parameter scanning — has been stable since VST3's initial release.
Prerequisites: CMake ≥ 3.22 · Xcode Command Line Tools · JUCE 7
git clone https://github.com/OfficialWhyEd/WhyCremisi
cd WhyCremisi
# Build
cmake -B build -DJUCE_ROOT=/path/to/JUCE
cmake --build build --config Release
# Install VST3
cp -r build/WhyCremisi_artefacts/VST3/WhyCremisi.vst3 \
~/Library/Audio/Plug-Ins/VST3/
# Configure AI provider
cp config.example.json config.json
# → set your preferred provider + key in config.jsonLoad WhyCremisi on the master channel in your DAW. Open the plugin UI. The bridge starts automatically — OSC on :9000, WebSocket on :8080, React connects and sends plugin.init.
For offline use: install Ollama, run ollama pull llama3.2. No API key needed.
Project structure
WhyCremisi/
├── src/
│ ├── core/
│ │ ├── PluginProcessor.cpp # VST3 host + universal parameter scanner
│ │ ├── PluginEditor.cpp # JUCE WebView host
│ │ ├── SessionManager.cpp # JSONL event log + cross-session memory.json
│ │ └── tests/ # 14 automated tests
│ ├── ai/
│ │ └── AiEngine.cpp # 6 providers, sync + async, streaming
│ └── bridge/
│ ├── OscBridge.cpp # 33ms timer, widget broadcasts, message dispatch
│ ├── OscHandler.cpp # UDP OSC receiver (:9000 in, :9001 out)
│ └── WebSocketServer.cpp # TCP WebSocket server (:8080)
├── webview-ui/ # React app (UI, BotFace, panels)
│ └── src/
│ ├── whycremisi-bridge.js # WebSocket singleton + useWhyCremisi() hook
│ ├── BotFace.jsx # Animated mascot — 9 states, framer-motion
│ ├── SessionPanel.jsx # Flight recorder view
│ └── WidgetSystem.jsx # Dynamic plugin parameter widgets
├── docs/ # GitHub Pages landing page
│ └── index.html # → officialwhyed.github.io/WhyCremisi
└── Research/ # Logo, design system, visual docs
Status: Beta. Core bridge, AI engine, and session memory are live. Plugin dictionary and auto-discovery are next.
- Plugin dictionary for top 10 plugins (semantic layer on top of index scanning)
- Auto-discovery — AI infers what unknown parameters do by observing their audio effect
- Parameter automation curves generated by AI
- Session summary export (what the AI did, and why)
- Plugin state presets saved by AI ("my warm master", "my hard-clipped drums")
This is a one-person project so far. PRs, issues and discussions are very welcome — especially for:
- Plugin dictionary entries — if you've mapped parameters for any DAW plugin, open a PR
- Provider implementations — new AI providers follow the same interface as the existing 6
- DAW compatibility testing — tested on Ableton and Logic (macOS), reports for Windows/Linux DAWs appreciated
If you're working on something larger, open an issue first so we can align.
If WhyCremisi made you go "wait, this is actually insane" — that's the right reaction.
- ⭐ Star the repo — it helps with discoverability
- Join the Discord — live sessions, dev updates, direct feedback
- Follow on Instagram — behind the scenes and demos
- Share on Twitter/X with what you think is the craziest part
- Post in your DAW's community — r/ableton, r/edmproduction, r/audioengineering, KVR Audio
- Show it to your music producer friends — they will not believe it's a plugin
WhyCremisi™ · A WhyEd™ Project
© 2026 @whyed
· macOS · Windows · Linux · JUCE 7 · MIT License
· Website
· Discord
· Instagram
If you think this is insane, you're right. Star it anyway.