Audio source separation has gone from a niche research problem to something you can do in a few lines of Python. The tooling has improved dramatically in the past two years, but the documentation is scattered. Here's a curated list of the resources actually worth reading in 2026.
Understanding the technology first
Before you write any code, it's worth understanding what you're working with. Modern stem separation uses neural networks trained on large datasets of music with known stems. The current state-of-the-art open source model is HTDemucs from Meta AI Research — a hybrid transformer architecture that processes both the waveform and spectrogram simultaneously.
- HTDemucs GitHub — the model itself, with installation docs and usage examples
- HTDemucs paper (arXiv) — the research behind the architecture
- MDX Workshop benchmarks — the most rigorous public comparison of separation models
The practical Python guides
For the full implementation comparison:
Demucs, Spleeter & API Compared (Hashnode) — covers all three approaches with working code. Particularly useful for the async polling loop implementation, which is where most first attempts fall over. Compares running models locally vs. calling a REST API, with honest tradeoffs for each.
For a specific end-to-end pipeline:
Full acapella extraction pipeline (Hashnode) — YouTube download with yt-dlp → API submission → async polling → stem download. Good template if you're building something similar.
The core libraries
# The three you'll actually use
pip install demucs # HTDemucs local inference
pip install yt-dlp # Audio download from YouTube/SoundCloud/etc.
pip install requests # REST API calls
Demucs — for local inference on GPU. Best quality, most control, needs CUDA.
yt-dlp — the standard for downloading audio from streaming platforms. Handles YouTube, SoundCloud, Bandcamp, and hundreds more.
StemSplit API — if you want cloud inference without managing GPU infrastructure. Has a free tier for testing and documented REST endpoints. The separation quality is the same as local HTDemucs (it runs the same model).
The non-obvious parts
Polling is mandatory. Separation is asynchronous — you submit a job and poll for results. Build this correctly from the start: exponential backoff, timeout handling, status codes.
Local Demucs needs GPU to be practical. CPU inference on HTDemucs takes 10–15 minutes per track. GPU drops that to under 90 seconds. If you're on CPU-only hardware, an API is more practical.
File format matters. HTDemucs works best on WAV or FLAC. MP3 compression artifacts can affect separation quality on bass-heavy content specifically.
Genre affects results. Models trained on pop/rock generalize well to hip-hop and R&B. Jazz with unusual voicings and non-Western music are harder. Test on your actual content before building a pipeline around it.
Quick starter
import subprocess
import requests
import time
# Download audio with yt-dlp
subprocess.run(["yt-dlp", "-x", "--audio-format", "wav", "-o", "track.wav", "YOUTUBE_URL"])
# Submit to StemSplit API
with open("track.wav", "rb") as f:
r = requests.post(
"https://stemsplit.io/api/v1/separate",
headers={"Authorization": "Bearer YOUR_API_KEY"},
files={"audio": f},
data={"stems": "4"},
)
job_id = r.json()["job_id"]
# Poll for results
while True:
status = requests.get(
f"https://stemsplit.io/api/v1/jobs/{job_id}",
headers={"Authorization": "Bearer YOUR_API_KEY"},
).json()
if status["status"] == "complete":
print(status["stems"]) # URLs for each stem
break
time.sleep(5)
For the complete implementation with error handling, retries, and batch processing — see the full guide on Hashnode.
Drop questions in the comments if anything is unclear. This is a fast-moving space and I'll update this post when significant changes happen.