Under the hood

Updated July 25, 2026

Native macOS app

Baking Powder uses SwiftUI and AVAudioEngine. It runs on Apple Silicon with a mouse and keyboard. The audio engine has no third party dependencies. The effects are custom Audio Units built for the app.

Core synth

Core is the only built in synth. Each voice has two oscillators, a noise lane, one filter, and its own amp, filter, and pitch envelopes. The oscillators mix saw, square, triangle, and sine shapes, with unison up to 16 copies per oscillator. Oscillator 2 can FM or hard sync oscillator 1. The noise lane has four classic colors and eleven procedural textures like rain, vinyl, and wind.

There are four filter models. The SVF has low pass, band pass, and high pass shapes, and the SVF and ladder filters support 12 or 24 dB slopes. The OTA and diode filters use fixed slopes. Core plays up to 16 voices. At one voice it runs monophonically with glide, legato, and note priority. Velocity can drive the amp and the filter with adjustable sensitivity.

Effects

Twelve effects are built in: Reverb, Delay, Distortion, Chorus, Phaser, Flanger, Compressor, EQ, Volume LFO, Tape, Transient, and Utility. Utility carries saturation, stereo width, balance, gain, and a brickwall limiter in one unit. Transient shapes attack and sustain. The Compressor accepts an external sidechain from any track, tapped before that track's effects, with no added latency. Every effect has a mix control and presets. Baking Powder does not host third party plugins of any kind, including Audio Units and VSTs.

Audio and MIDI

A project can contain MIDI tracks and audio tracks. Each audio clip has its own source file and trim settings, so one track can hold many different sounds. Clips that point at the same file share one decode. A built in sample browser auditions files. Files drag from the browser onto audio tracks. Audio and MIDI tracks use the same effects, sends, meters, and master chain. Live input can be recorded as MIDI, and tracks can be grouped.

Arpeggiator and step sequencer

Each MIDI track has an arpeggiator or a step sequencer. The arpeggiator plays held chords in patterns, with transposed repeats. The step sequencer runs 16, 32, or 64 steps with per step pitch, rest, tie, and velocity. Ties play as slides on a mono patch. Both can be flattened into ordinary notes.

Automation

Track volume, pan, width, tone trim, and all sixteen sends have automation lanes, along with most Core and effect parameters. Each automatable parameter can also carry an LFO with six waveforms and a smoothing control. Continuous Core parameters apply their modulation per sample at 48 kHz. A Core LFO can retrigger its phase on each note.

Rendering

Tracks render across multiple CPU cores. A heavy Core patch can also split its voices across cores, and parallel renders are bit identical to serial renders. The audio thread does not allocate, access files, or take locks while rendering. One clock drives the transport, recording, and every playhead. There are no low quality fallback modes. When audio quality and CPU cost conflict, the heavier version ships.

Import and export

Audio import reads WAV, AIFF, MP3, FLAC, and M4A. Export writes a 24 bit, 48 kHz stereo WAV file. A MIDI clip can be exported as a standard MIDI file, and a MIDI file can be dropped onto a MIDI track to import it.

AI friendly project files

Projects and presets use readable JSON with field descriptions and edit rules. The format is a designed LLM authoring surface. Missing fields load as their defaults, so a partial file is valid, and a load error names the exact field that failed. The File menu can copy a clean project for an LLM. The model runs outside the app: a person or an LLM edits the song, synth, effect, and arrangement data, and Baking Powder loads the result. The app never calls a model itself, so it needs no account and no API key.

AI Control

AI Control lets an AI assistant running on the same Mac edit the open project directly, instead of editing files and reloading them. Baking Powder runs a small MCP server inside the app. MCP, the Model Context Protocol, is the open standard AI apps use to talk to tools, so any MCP client that can reach a local HTTP endpoint can drive the DAW. Claude Code, LM Studio, Cursor, and Cherry Studio all read the same config format.

The AI edits the real project while it is open. This is not a file exporter and not a code generator. Knobs move on screen while the model works, and any control can be grabbed back mid session. Every edit lands in the normal undo history, and Undo AI Changes reverts the AI's current run of edits in one click. That run ends after thirty seconds with no tool call, so a long session reverts in pieces rather than all at once. The revert is itself undoable.

Baking Powder ships no model and no AI subscription. You bring the AI app.

Connecting an AI app

Open File ▸ AI Control… or click the AI pill in the top bar, then turn on "Allow AI apps on this Mac to edit this project". It is off by default. Now click Copy MCP Config. That puts a ready to paste JSON block on the clipboard with the access key already inside it, so the key never has to be handled by hand. The block below is an example only. The port and access key in yours come from your own install.

{
  "mcpServers": {
    "baking-powder": {
      "type": "http",
      "url": "http://127.0.0.1:48000/mcp",
      "headers": { "Authorization": "Bearer bp_…" }
    }
  }
}

Paste it into your AI app's MCP configuration. Each host keeps that file in its own place, and they all read the same block.

The default port is 48000, the sample rate as a port number, and any port from 1024 to 65535 works. The access key is generated per install as bp_ followed by 48 hex characters, and can be regenerated at any time. Both live in a Connection Details section in the same sheet. While the server runs, the pill in the top bar lights green and pulses once for every request it handles, so the AI is visible at work. The server speaks MCP protocol versions 2025-06-18 and 2025-11-25.

What the AI can do

The server exposes eighteen tools. That is the whole set.

Reading
  get_state          the project, one track, or a summary
  list_params        every parameter addressable on a track
  list_presets       Core patches and effect presets to load

Sound design
  set_param          set one parameter
  apply_params       set many at once, as one undo step
  load_preset        load a Core patch or an effect preset
  add_effect         add an effect to a track rack
  remove_effect      take one out
  write_automation   draw an automation lane
  set_lfo            configure the LFO on a parameter

Writing music
  write_chords       write chords into the arrangement
  write_notes        write MIDI notes into a clip
  clear_bars         clear bars
  set_bpm            set the tempo
  set_key            set the key and scale

Transport and output
  play, stop         start and stop playback
  export_wav         bounce to a 24 bit, 48 kHz stereo WAV

export_wav writes into ~/Music/Baking Powder/Exports and numbers the files so it never overwrites one, then returns the absolute path. That folder is the only place it writes, so an AI app that needs the file elsewhere moves it there. The app also publishes its project format documentation to the connected client as an MCP resource, so a model can learn the JSON dialect from the app itself. Reads of project state return a revision counter that the next write can pass back, so a model working from stale state is refused instead of overwriting newer changes. Requests are handled one at a time, in the order they arrive.

What the AI cannot do

The tools reach the open project, the preset library, and the export folder. Nothing else is exposed, so the AI cannot:

• Browse your files, open arbitrary files, run a shell, or make network calls on your behalf. No tool does any of that.
• Undo its own work. Undo AI Changes is a control in the sheet, not a tool the AI can call.
• Record audio, or import audio files into the project.
• Change the project during an export, or revert during a recording.
• Reach another machine. There is no cloud, no account, and no sync.

Access and privacy

• The server is off until it is turned on, on every install.
• It binds 127.0.0.1 and nothing else, so it is not reachable from the local network or the internet, and turning it on raises no macOS firewall prompt.
• Every request has to carry the install's access key, compared in constant time. Requests that arrive with a browser Origin header are rejected, so a web page cannot reach it.
• The app ships with the outgoing network entitlement turned off. It listens, and never dials out. Its App Store privacy label is Data Not Collected.
• The AI app is the part that talks to the internet. A cloud model can send project data to its provider. With a fully local, offline AI client, project data need not leave the Mac. That is the client's doing, not the app's.

Local files

Projects, presets, and audio stay on the Mac unless the user moves or shares them. The app has no account, analytics, tracking, or telemetry. Each save creates a local checkpoint of the file being replaced, and the last twenty checkpoints are kept for each project file. A project with a missing audio file still loads; the clip goes silent and keeps its reference. See the privacy policy for details.

Signal flow

The track and master chain:

MIDI (Core) or audio clips
   → track FX rack
   → stereo width
   → fader · pan
   → tone trim
   → meter
   ├→ dry to master
   └→ sends A to P → send FX → send fader → master

master mix
   → master FX rack
   → safety limiter
   → output

Sixteen sends per project, a master FX rack, and an always on safety limiter at the very end of the chain.

Questions?

contact@bakingpowder.app reaches the developer. You can also send feedback.