Article November 20, 2026 Engineering 8 MIN READ

RE:DRUM: turning any song into a GGD (GetGood Drums) backing track

RE:DRUM app showing the hit timeline and per-drum sensitivity sliders

Reconstruct. Replace. Replay.

If you record guitar covers, you know how it goes. You want to play along to the song, but with your drum sound: a modern, punchy kit like GetGood Drums in Kontakt instead of whatever the original record has. That means programming the drums by hand, hit by hit, in Logic, before you’ve played a single note of guitar. For a 6-minute metal song that takes hours.

So I built RE:DRUM. You give it a song you own and it gives you back:

  • a drumless backing track (the song with the drums removed),
  • the isolated original drums, for reference,
  • a MIDI file of the drum performance, already mapped to GetGood Drums, that you drop onto a Kontakt track in Logic and play along to.

All of it runs locally on a 2020 13″ Intel MacBook Pro. That’s the machine I already use for Logic, Kontakt and GGD. No cloud, no GPU, no uploads.

The first real test

The moment it clicked was the first run on one of my own songs: a 6 min 36 s MP3. On this six-year-old quad-core i5:

StageTime
Separation (remove the drums)272 s
Transcription (drums to MIDI)20 s
Total~5 minutes

Peak memory was 2.8 GB. It found about 2,000 drum hits and estimated the tempo at 152 BPM. I dragged the backing WAV and the MIDI into Logic, loaded GGD Modern & Massive, hit play, and it lined up.

It isn’t perfect, and I’ll get to what’s still rough. But five minutes of waiting instead of an evening of programming changes how often I’ll actually sit down and record a cover.

The constraint that shaped everything: an Intel Mac

Most of today’s audio ML tooling assumes Apple Silicon or an NVIDIA GPU. I wanted this to run on the laptop I actually make music on, which is a 2020 Intel MacBook Pro with 16 GB of RAM. That turned out to be the most interesting engineering constraint in the project:

  • PyTorch stopped shipping macOS x86_64 builds after 2.2. The whole stack is pinned to Python 3.11 + torch/torchaudio 2.2.2 + numpy 1.26, from a lockfile, in an isolated venv. Nothing touches the system Python, Homebrew or my DAW setup.
  • CPU only. Separation runs at about 0.77× real time on a 48-second clip, which is quite usable for a CPU.
  • Don’t eat the RAM Logic needs. Only one heavy job runs at a time (enforced with a file lock), and a preflight check estimates memory and disk before starting. It warns you before your machine starts swapping, not after.
  • Even FFmpeg comes from inside the venv, as a static binary shipped in a Python wheel, so there’s no system install.

How it’s built

RE:DRUM has three verbs, and each one works on its own:

  • SPLIT: mixed song → drums + drumless backing. Uses Demucs (htdemucs), Meta’s open-source source-separation model.
  • TRANSCRIBE: drum audio → semantic drum events → MIDI. Uses an ADTOF-based automatic drum transcription model (kick, snare, toms, hi-hat, cymbals).
  • PREPARE: runs both and exports a finished package for your DAW.
redrum prepare song.mp3 --output ./song
song/
├── audio/backing-no-drums.wav
├── audio/drums-original.wav
├── midi/drums-ggd-mm-gm.mid
├── analysis/events.json        # every hit, in seconds, with confidence
├── analysis/review.json        # hits worth double-checking by ear
└── redrum.project.json         # input hash, model hashes, timings, alignment checks

Under the hood it’s about 3,000 lines of Python and 110 tests. A few design decisions mattered more than the rest.

1. Time is measured in seconds, not beats. Every drum hit is stored as an absolute timestamp in seconds from the start of the song, alongside the sample rate. Tempo is only metadata for the MIDI grid. When the MIDI file is written, ticks are calculated from those seconds using the exact tempo value encoded in the file, so a DAW reading it back puts every note within half a tick (about 0.26 ms at 120 BPM) of where the model heard it. The default export tempo is 120 BPM because that’s what a fresh Logic or REAPER project uses, so even if the DAW ignores the file’s tempo, the notes still land in the right place.

2. No surprise quantization. Drummers don’t play on a grid, and the tool shouldn’t pretend they do. Ghost notes, flams and the way a real drummer pushes a fill all come through as played. If you want it quantized, Logic will do it in one click. It’s much harder to un-quantize.

3. Drums are stored by name, not by note number. Internally a hit is kick or snare, not 36. Mapping to a specific kit happens at export through small versioned JSON profiles, so switching from one GGD kit to another is a re-export that takes a second. Nothing has to be re-analyzed.

4. A map isn’t “verified” until it has played the real instrument. I generated test MIDI files, played them through my own Kontakt install, and recorded the results. Modern & Massive’s GM map passed 7 of 7 instruments, so it’s marked verified. One Kit Wonder: Brutal’s GM map is partial, because the hi-hat note doesn’t trigger anything. Brutal’s default map failed, so the CLI refuses to use it. The tool never labels a guessed map as correct.

5. Every expensive step is cached. Separation is the slow part, so nothing reruns it unless it has to. The raw model output from transcription is saved too, so changing the sensitivity for a single drum re-picks the hits from those saved activations in a few seconds. No model rerun needed.

6. The outputs line up to the sample. The backing and drum stems have the same sample rate, channel count and exact length as the input, and the tests check that with cross-correlation (lag 0) at both the start and the end of the file. The WAV and MIDI outputs are byte-for-byte reproducible: a fresh clone run from the README produces identical files.

Then it got a UI

RE:DRUM app showing the default window for uploading an audio file

Once the CLI pipeline was producing results I’d actually use, I added a small local interface: a FastAPI server plus a React/Vite front end, with no component libraries. You drop in a song, pick a kit map and a tempo, and watch it progress through each stage. When it’s done you can:

  • preview the backing, the original drums, and a click track of the detected hits on a scrolling timeline,
  • jump to the “hits to check” the model wasn’t confident about,
  • adjust per-drum sensitivity and re-pick in seconds,
  • re-export the MIDI at a different tempo, or open the files in Finder.

It then got wrapped in a native Mac window (pywebview over WebKit) and a RE-DRUM.app bundle with its own icon, so it opens from the Dock like any other app. It only listens on 127.0.0.1, and your audio never leaves the machine.

Building it with an AI agent (and keeping it honest)

I built RE:DRUM with Claude Code as the lead implementation agent, and I spent most of my effort on the setup around it, not on prompting. I wrote a spec, a milestone tracker with acceptance gates, and a short rulebook for the agent. Some of the rules:

  • Milestone zero was a go/no-go feasibility gate. No UI and no packaging until the full pipeline ran end-to-end on this exact Mac with measured numbers. The result was a Conditional Go, with the conditions written down.
  • No invented benchmarks. Every number in the docs comes from a command that actually ran, and the command is logged. Tests that didn’t run are labeled as not run.
  • “Verified in Logic” means a person did it in Logic. The agent couldn’t claim DAW verification, so things like the Kontakt map check are recorded as my results, with the evidence filed.
  • Code licenses and model-weight licenses are tracked separately. A model’s code license often says nothing about whether you can use its weights.
  • Ask before big downloads or system changes, with the source, license and size shown first.

That process caught real problems. The upstream transcription port loaded its weights in a way that could silently fall back to a randomly initialized model; RE:DRUM loads them strictly and fails loudly. A test that failed intermittently turned out to be libsndfile writing a timestamp into float WAV headers. The model host served an expired TLS certificate on the day I needed the weights, so the download was handled deliberately (pinned key, hash check, static scan of the checkpoint) and logged, not quietly worked around.

The whole thing went from spec to a working Mac app in about two days. Most of that speed came from the guardrails: a fast agent with no constraints would have produced a demo, and I wanted a tool I’d actually use.

What’s still rough

The same rules apply here, so this is the honest list:

  • Accuracy on real recordings hasn’t been measured properly yet. My first real song sounded great, but the precision and recall numbers (F1 ≈ 0.95 within ±50 ms) come from synthetic test fixtures. Cymbals are the weakest class, and very fast double-kick (hits under ~50 ms apart) is beyond what the model can resolve.
  • Logic sync is confirmed by ear, not yet by measurement. I built a measurement kit for this (a click track plus MIDI at two tempos, bounced and analyzed for offset and drift). I just haven’t run it in Logic yet.
  • The tempo is constant. Songs with tempo changes will drift against a single-BPM grid. The tool warns you about it but doesn’t fix it yet.
  • Brutal’s hi-hats are silent on the GM map for now.

What’s next

  • Measured accuracy on real kits. The plan is to render the ground-truth MIDI through GGD itself, so I get real drum sounds with exact known answers, then score cymbals, toms and timing bias against that.
  • A transcriber I can actually ship. The ADTOF weights are licensed for non-commercial use only, which is fine on my laptop and blocks any public release. I’ll benchmark permissively licensed alternatives with RE:DRUM’s own eval harness and pick based on results, not hype.
  • A dedicated fast-kick detector, if real recordings hit the same double-kick limit the synthetic tests do.
  • Tempo maps for songs that speed up and slow down.
  • More kits and DAWs: other GGD libraries, a proper REAPER pass, and maybe other drum samplers.
  • A real name and a real release. “RE:DRUM” clashes with Reason’s Redrum, so the name will probably change. Before anyone else can download it, it needs a clean licensing story for every model, a license for its own code, and a signed app.

For now it’s a private tool that does one thing I wanted badly: it gets me from “I want to cover this song” to playing guitar over a great-sounding drum kit in about five minutes.