DeadCat

DeadCat is a digital audio workstation for iPhone, iPad, and Mac, designed around Apple's on-device intelligence: your audio, your session, and your conversation with the assistant stay on your device. It's for music and for spoken-word work like podcasts and radio stories. The DAW is early; we're building it in this repo one milestone at a time. Everything is Swift with no third-party dependencies.

DeadCat also ships tools you can use today: local MCP servers and a terminal command that let an AI assistant operate an existing DAW in plain language. Start playback, record a take, balance the mix, build a session. The first server drives REAPER over OSC on macOS, since REAPER has the most open control surface of the major DAWs.

[!NOTE] A "dead cat" is the furry windscreen that slips over a shotgun microphone to keep wind noise out of a recording; field recordists and radio reporters rarely leave home without one. The cat in the icon is Gus, the studio's actual cat, and we love him very much.

[!IMPORTANT] DeadCat is early and its surface is still changing. There are 25 REAPER tools today: 22 that change the session and 3 that read it.

Bug reports, ideas, and pull requests are welcome; CONTRIBUTING.md covers how to help and how review works.

The ecosystem

Piece	What it is	State
The DAW	A digital audio workstation for iPhone, iPad, and Mac with on-device intelligence built in, for musicians and audio journalists.	In progress; see the DAW
deadcat-reaper	The MCP server: 25 annotated tools that drive REAPER over OSC.	Built
deadcat	The terminal command: the same tool surface as one-shot commands, no MCP client required.	Built
Desktop extension	A one-file .mcpb bundle that installs the server inside Claude Desktop.	Built
More DAW servers	Ableton Live, Pro Tools, and Logic Pro mappings over the same core.	Planned

The DAW

The DAW is for musicians and for audio journalists, with the assistant built in. Development moves one milestone at a time, and each milestone ships something usable:

Milestone	What you get	Status
Scaffold	The app exists on iPhone, iPad, and Mac with the design system's foundations.	Built
Sketchpad	Record one take, play it back, name it, and keep it.	Built; hardening in progress
Tracks	A few parallel tracks with volume, pan, mute, and solo.	Next
Arrange	Move, trim, and loop regions on a timeline.	Planned
Transcribe	On-device transcripts for spoken takes.	Planned
Assist	The on-device assistant: name takes, summarize a session, operate the transport and mixer in plain language.	Planned
Deliver	Export with loudness measured against podcast and broadcast targets.	Planned

The interface is built with SwiftUI in an MVVM architecture on Observation. One codebase runs native on iPhone, iPad, and Mac, and stock components pick up Dynamic Type, VoiceOver, both appearances, and new design languages as Apple ships them. Every screen takes its colors, type, and spacing from a small token system instead of hardcoded values.

More detail: the DAW covers the principles and the milestone path, the design system covers the interface decisions, MVVM in the app covers the layers, and on-device intelligence covers the AI ground rules.

How the servers work

A DeadCat server exposes DAW actions as tools. When an assistant calls a tool, the server encodes the request as an OSC message and sends it to the running DAW over UDP. OSC is one-way and fire-and-forget: there is no reply on the wire.

Reads come from REAPER's OSC feedback. REAPER sends its state to a port the server listens on, the server keeps the latest value at every address in a session cache, and the read tools answer from that cache. Before answering, a read tool asks REAPER to refresh all control surfaces, which makes it re-send its full state, so the answer reflects the session as it stands.

The architecture page maps the modules and the boundaries between them.

What's in the repo

Path	What lives there
Sources/DeadCatKit	The dependency-free core: the OSC 1.0 encoder and decoder every server is built on.
Sources/DeadCatReaperCore	The REAPER layer: tools, routing, write verification, the session cache, the media bridge, the command-line parser.
Sources/deadcat-reaper	The MCP server executable.
Sources/deadcat	The terminal command executable.
Tests/	The test suites for everything above.
apps/	The DAW for iPhone, iPad, and Mac, early in its milestone path.
docs/	The documentation set, indexed below.
web/	The Pages site source: one static page, no build step.
distribution/	The desktop extension bundle: manifest, icon, and the build script.
scripts/reaper/	The ReaScript bridge that gives the server media-item access.

Documentation

• Architecture: the modules, the control and feedback paths, and the boundaries between them.
• The DAW: the principles and the milestone path.
• Design system: the principles and tokens every DAW screen inherits.
• MVVM in the app: the model, view model, and view layers the DAW app is built from.
• On-device intelligence: how Foundation Models, Core AI, and tool calling shape the DAW.
• Testing: what the suite proves, how write verification is tested, and how coverage gates a merge.
• Privacy: the full privacy policy. DeadCat collects nothing.
• Troubleshooting: what to check when a tool call does not do what you expected.
• Terms of service: the terms that cover the software, releases, and support.
• The wiki carries the same material as browsable documentation, with the install guide, the full tool reference, the FAQ, and the policies.

Audio guides

These guides cover audio fundamentals; nothing in them is specific to DeadCat:

• Loudness standards: what LUFS means, how platforms normalize playback, and the delivery targets for music streaming, podcasts, and broadcast.
• Recording basics: gain staging, sample rate and bit depth, microphone placement, and noise.
• The guide index collects more learning resources: Transom, NPR Training, This American Life, Radio Diaries, and more.

How it's verified

Every write tool confirms itself against REAPER's own feedback instead of assuming the datagram landed. The OSC core is tested byte-for-byte against the OSC 1.0 specification, and coverage gates every merge in CI. Testing covers what the suite proves. Live coverage by area:

🟢 well covered, 🟡 partially covered, 🔴 needs tests.

Get started

Build and test the package:

swift build
swift test

Run the server over stdio:

swift run deadcat-reaper --host 127.0.0.1 --port 8000

The host and port default to DEADCAT_REAPER_HOST / DEADCAT_REAPER_PORT, then 127.0.0.1:8000. The feedback listener port defaults to DEADCAT_REAPER_FEEDBACK_PORT, then 9001; set --feedback-port to change it, or --no-feedback to run write-only.

For Claude Desktop, the simplest install is the extension bundle: run sh distribution/buildBundle.sh, then in Claude Desktop open Settings, then Extensions, then Advanced settings, choose Install Extension, and pick dist/deadcat-reaper.mcpb. Any other MCP client points at the built binary with the same two arguments shown above.

[!IMPORTANT] OSC is fire-and-forget UDP: if the ports below do not match, nothing errors, nothing happens. When a tool seems to do nothing, check this device configuration first.

REAPER has to listen for the server's messages before the tools can do anything. In REAPER, open Options, then Preferences, then Control/OSC/web, click Add, and choose OSC as the control surface mode. Set the local listen port to 8000 (the port the server sends to). For the read tools, also set the device IP to 127.0.0.1 and the device port to 9001 (where REAPER sends feedback). REAPER applies the change as soon as you close the dialog; no restart is needed. REAPER's own OSC documentation covers the control surface in depth, and the REAPER user guide covers everything else about the DAW itself.

[!CAUTION] These tools operate your live REAPER session: faders move, tracks appear, playback starts. When you are trying DeadCat out, reaper_new_project_tab opens a scratch tab so your real project stays untouched, and reaper_undo reverses the last edit.

These are the tools so far, transport first, then the mix, then navigation:

Tool	Arguments	What REAPER does
reaper_play	none	Starts playback.
reaper_stop	none	Stops playback or recording.
reaper_record	none	Starts recording on the armed tracks.
reaper_pause	none	Pauses at the current position.
reaper_set_track_volume	track, normalized value	Sets a track fader.
reaper_set_track_pan	track, normalized value	Pans a track.
reaper_set_track_mute	track, muted	Mutes or unmutes a track.
reaper_set_track_solo	track, soloed	Solos or unsolos a track.
reaper_set_master_volume	normalized value	Sets the master output fader.
reaper_insert_marker	none	Drops a marker at the edit cursor.
reaper_go_to_marker	marker	Jumps to a marker by number.
reaper_next_marker	none	Jumps to the next marker, or the project end.
reaper_previous_marker	none	Jumps to the previous marker, or the project start.
reaper_go_to_time	seconds	Moves the edit cursor to a time.
reaper_insert_track	none	Adds a track at the end of the track list.
reaper_set_track_name	track, name	Renames a track.
reaper_set_tempo	bpm	Sets the project tempo.
reaper_select_track	track	Selects a track.
reaper_insert_media	path, track, seconds	Inserts an audio file on a track at a position, through the bridge script below. Missing tracks are created.
reaper_new_project_tab	none	Opens a new empty project tab.
reaper_undo	none	Undoes the last edit.
reaper_redo	none	Redoes the last undone edit.
reaper_get_transport	none	Reports playing, paused, recording, position, and tempo.
reaper_get_track_state	track	Reports one track's name, volume, pan, mute, and solo.
reaper_get_session_state	none	Reports the transport, the master volume, and every reported track.

Normalized values run from 0.0 through 1.0; for pan, 0.0 is hard left and 0.5 is center. The read tools answer from REAPER's own feedback; a null field means REAPER has not reported that value yet, and a track listed without a name is usually an empty slot in REAPER's eight-track surface bank.

The terminal command

Every tool is also a one-shot terminal command, named after the tool with the reaper_ prefix dropped:

swift run deadcat help                     # the command list
swift run deadcat set-track-volume 3 0.7   # required arguments are positional, in schema order
swift run deadcat set-tempo --bpm 104      # or passed by name
swift run deadcat get-session-state        # read commands answer as JSON

The command takes the same --host, --port, --feedback-port, and --no-feedback options as the server, with the same defaults. Write commands report REAPER's feedback confirmation the same way the server's tools do.

[!TIP] Only one process can own the feedback port at a time. The read commands bind it for the length of the call, so they cannot run while a server instance holds it; the command says so when that happens instead of guessing.

The media bridge

OSC has no media-item surface, so reaper_insert_media uses a small ReaScript. Install it once:

1. Copy scripts/reaper/deadcat_bridge.lua into REAPER's Scripts folder (~/Library/Application Support/REAPER/Scripts/ on macOS).

2. Quit REAPER, then append this line to reaper-kb.ini in the same support folder (quit REAPER fully with Cmd+Q first: it rewrites the file on exit, and an edit made while it runs is silently lost):

   SCR 4 0 RSdeadca7b41d6e0000000000000000000000000 "Custom: deadcat_bridge.lua" deadcat_bridge.lua
   

3. Relaunch REAPER.

The server writes one request line to /tmp/deadcat-bridge/request.tsv, triggers the registered action over OSC, and reads the script's answer back from /tmp/deadcat-bridge/response.txt. The answer reports the track's item count after the insert, so the tool result reflects what actually happened in REAPER. Without the script installed, the tool reports that the bridge is not installed.

Roadmap

DeadCat adds DAW servers one at a time, starting with the most open control surface.

DAW	Surface	State
REAPER	OSC, then ReaScript for richer session reads	Shipped: 25 tools
Ableton Live	The Live API via Max for Live, OSC bridges	Planned
Pro Tools	PTSL (gRPC), narrower and partly gated	Planned
Logic Pro	Limited scripting (Scripter, AppleScript)	Planned

The server is listed in the MCP Registry as io.github.systemblueio/deadcat-reaper; a Claude extension directory listing is submitted and in review.

Privacy

DeadCat collects nothing: no telemetry, no analytics, no accounts, and no network calls beyond the OSC messages it exchanges with the DAW on your machine. The server keeps REAPER's reported state in memory while it runs and forgets it on exit; the media bridge's request and response files under /tmp/deadcat-bridge/ carry only the file path, track, and position of an insert. Nothing is retained between runs and nothing is shared with anyone. The privacy page is the full policy.

Support

The troubleshooting page covers the common failures. Questions and bug reports are welcome in issues. DeadCat is free. If it has helped you and you'd like to support its development, you can do so on Liberapay; thank you.

About systemBlue

systemBlue is an indie Swift studio in Charlottesville, Virginia, building resources and tooling for the AI era. We're particularly focused on audio production and bringing on-device intelligence to the modern audio workflow.

If you'd like to partner with us, email us at systemblueio@icloud.com.

Security

Found a vulnerability? Report it privately through the channel in SECURITY.md, never in a public issue.

Contributing

CONTRIBUTING.md covers reporting bugs, sharing ideas, sending pull requests, and how review works here.

License

Apache-2.0. See LICENSE. You may use, modify, and distribute it, including commercially, under the terms there.

Built by systemBlue.