Stop Exporting to Spleeter! STEMwerk-reaper Does It Inside REAPER

What if I told you that every time you export a track to separate stems, you're burning 15 minutes you'll never get back?

Picture this: You're deep in a REAPER session, perfecting a remix. The client wants the vocals isolated—yesterday. Your old workflow? Bounce the track, upload to some sketchy web service, wait for processing, download four files, drag them back in, realize the quality is garbage, repeat. Sound familiar?

Here's the dirty secret the DAW industry doesn't want you to know: stem separation doesn't have to be a workflow killer. While producers have been trapped in this export-upload-download purgatory for years, a quiet revolution has been brewing in the open-source audio community. And it's about to change everything.

Enter STEMwerk-reaper—the local-first stem separation engine that runs inside your REAPER project. No cloud. No subscriptions. No leaving your DAW. Just select, separate, and keep creating. Built on Facebook's legendary Demucs algorithm and wrapped in a polished REAPER-native interface, this is the tool that makes stem separation feel like it should have always worked: invisible, instant, and under your complete control.

Ready to reclaim your workflow? Let's dive into why top producers are quietly abandoning external stem tools—and why you should too.

What is STEMwerk-reaper?

STEMwerk-reaper is a REAPER ReaScript package that brings industrial-grade stem separation directly into your Digital Audio Workstation. Created by flarkAUDIO and released under the MIT License, it leverages the power of Facebook Research's Demucs deep learning architecture through a Python backend built on the audio-separator ecosystem.

At its core, STEMwerk-reaper solves a deceptively simple problem: how do you split a mixed audio file into its constituent parts without leaving your creative environment? The answer, historically, involved complex command-line tools, cloud-based APIs with usage limits, or expensive proprietary plugins. STEMwerk-reaper obliterates these barriers by embedding the entire pipeline—model inference, audio I/O, track management—directly within REAPER's scripting environment.

The project is currently on stable release v2.2.2.1, a significant stabilization and packaging milestone. Compared to earlier 2.2.1.x builds, this release line introduces a complete visual refresh with refined STEMwerk theme styling, dramatically improved dark and light UI consistency, and better multilingual layout support for English, Dutch, and German users. The v2.2.2.x series also hardened the Windows installer, fixed progress reporting glitches like duplicate stage text (no more Processing Processing confusion), expanded offline patch compatibility to older installs, and—critically—pinned PyTorch dependencies to 2.5.1 to avoid a breaking change in PyTorch 2.6+ that broke Demucs model loading.

Why is it trending now? Three forces converged: Demucs matured into a production-ready algorithm, REAPER's ReaScript ecosystem reached critical capability, and producers collectively reached their breaking point with cloud-based stem services that charge per-minute fees and raise serious ownership questions about uploaded audio. STEMwerk-reaper rides this wave as the only fully open-source, local-first solution that integrates this deeply with a professional DAW.

Key Features That Make It Irresistible

STEMwerk-reaper isn't a toy—it's a production-hardened tool with features that rival expensive commercial alternatives:

🎯 Multi-Model Stem Separation The engine supports multiple Demucs variants: standard 4-stem separation (vocals, drums, bass, other), plus optional 6-stem models that add guitar and piano extraction. Choose between Fast (htdemucs, ~84MB), Quality (htdemucs_ft, ~337MB), or 6-Stem (htdemucs_6s, ~55MB) models depending on your accuracy vs. speed needs.

⏱️ Flexible Selection Workflows Process entire tracks, specific items, or time selections without touching the rest of your project. Multi-item tracks get per-item processing for cleaner naming and organization. This isn't all-or-nothing—it's surgical.

🔄 Dual Output Modes Create new tracks with separated stems (optionally grouped in folders) or replace source items in-place as multi-take containers. The STEMwerk_Explode_Takes.lua helper lets you quickly explode these takes when needed.

⚡ One-Click Presets Built-in presets eliminate repetitive configuration: Karaoke (remove vocals), Instrumental (keep everything except vocals), Drums Only, Bass Only, Vocals Only, or All Stems. Assign these to toolbar buttons for lightning-fast access.

🖥️ Intelligent Device Management Auto-detects GPU capabilities with graceful CPU fallback. Supports NVIDIA CUDA on Windows and Linux, AMD DirectML on Windows, AMD ROCm on Linux, and Apple Silicon (CPU). The system automatically forces sequential processing when DirectML multi-job stability is a concern.

📦 Batch Processing Queue Queue multiple tracks or items and process them in parallel (when safe) or sequential mode. The progress window shows real-time stage tracking, ETA estimates, and explicit mode indicators.

🔒 Complete Local Privacy Your audio never leaves your machine. No cloud uploads, no usage tracking, no subscription gates. The logs are transparent and local—bootstrap.log, separation_log.txt, stdout.txt, and stderr.txt give you full visibility into what's happening.

🎨 Polished Native UI Day/night theming, procedural art gallery, audio-reactive visuals, keyboard shortcuts (1-4 for stem toggles, K/I/D for presets, Enter to start, Esc to cancel), and three-language support. This doesn't feel like a hack—it feels like REAPER grew a stem separation superpower.

Real-World Use Cases Where STEMwerk-reaper Dominates

🎛️ Remix Production Without the Workflow Death

You're remixing a track and need clean vocal, drum, and bass stems. Old workflow: export, upload to [redacted cloud service], wait, download, import, discover artifacts, cry. With STEMwerk-reaper: select the stereo mix, hit your "All Stems" preset, grab coffee while it processes locally, come back to perfectly organized tracks. Time saved: 10-15 minutes per track, minimum.

🎤 Podcast Dialog Cleaning and Music Bed Isolation

Editors receive mixed interview files where music competes with voice. STEMwerk-reaper's "Vocals Only" preset isolates dialog while "Instrumental" gives you the music bed for level adjustments. No more spectral editing marathons or expensive iZotope licenses for simple separation tasks.

🎓 Education and Analysis

Music educators need isolated parts for transcription, ear training, or arrangement study. STEMwerk-reaper makes this trivially repeatable—select any commercial recording, separate stems, and present students with individual instrument parts. The local processing means no legal gray areas with uploading copyrighted material to cloud services.

🎮 Sound Design Source Material

Sound designers can deconstruct existing recordings into elemental components, then recombine them in unexpected ways. The "Other" stem often contains rich textural material that's perfect for further processing. Since everything stays in REAPER, your separated stems are immediately available for resampling, time-stretching, and effects chains.

🎤 Karaoke Track Creation

The dedicated Karaoke preset strips vocals while preserving instrumental backing. Event DJs and karaoke hosts can generate custom karaoke versions from any stereo file in seconds, not hours. The in-place take replacement means you can quickly A/B between original and karaoke versions.

Step-by-Step Installation & Setup Guide

Windows (Recommended Path)

Step 1: Download the correct installer

Step 2: Run the installer The Windows installer handles Python virtual environment creation, backend package installation, FFmpeg verification, and path configuration. Be patient—first setup may appear paused for several minutes while packages resolve. This is normal, not frozen.

Step 3: Verify in REAPER Open REAPER, check the Action List for STEMwerk: Setup and STEMwerk: Main. Run STEMwerk-SETUP.lua once to confirm runtime health.

Linux Installation

# Option A: AppImage (portable, no install needed)
chmod +x STEMwerk-v2.2.2.1-Linux-x86_64.AppImage
./STEMwerk-v2.2.2.1-Linux-x86_64.AppImage

# Option B: Debian/Ubuntu
sudo dpkg -i STEMwerk-v2.2.2.1-Linux-amd64.deb

# Option C: RPM-based distros
sudo rpm -i STEMwerk-v2.2.2.1-Linux-x86_64.rpm

After package installation, open REAPER and run STEMwerk-SETUP.lua from the Action List to build the Python backend runtime.

macOS and ReaPack (Cross-Platform)

For ReaPack users on any platform, add the repository:

https://raw.githubusercontent.com/flarkflarkflark/STEMwerk-reaper/main/index.xml

Then in REAPER:

1. Extensions -> ReaPack -> Import a repository
2. Paste the URL above
3. Extensions -> ReaPack -> Browse packages...
4. Search STEMwerk, install, synchronize
5. Run STEMwerk-SETUP.lua to verify/rebuild runtime

⚠️ Windows ReaPack Warning: ReaPack installs only scripts, not the full runtime. On Windows, always use the installer first. ReaPack is fine for updates after initial setup.

Manual/Developer Install

For those who want full control:

# 1. Ensure Python 3.x is on your PATH
python --version

# 2. Clone the repository
git clone https://github.com/flarkflarkflark/STEMwerk-reaper.git
cd STEMwerk-reaper

# 3. In REAPER: Actions -> Show action list -> ReaScript: Load ReaScript...
# 4. Load scripts/reaper/STEMwerk-SETUP.lua and run it
# 5. Then load and run scripts/reaper/STEMwerk.lua

If REAPER can't locate Python, STEMwerk-SETUP.lua provides an interactive prompt to specify the interpreter path directly.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from STEMwerk-reaper's codebase to understand how this integration works under the hood.

Example 1: ReaPack Repository Index URL

The project's ReaPack distribution is controlled through a centralized index:

https://raw.githubusercontent.com/flarkflarkflark/STEMwerk-reaper/main/index.xml

This XML index defines package metadata, version dependencies, and file mappings that ReaPack uses to install and update STEMwerk-reaper. The raw.githubusercontent.com CDN delivery ensures fast, reliable global access without GitHub's rate limiting on API calls. When you import this URL, ReaPack parses the index, downloads the specified script files to REAPER/Scripts/STEMwerk-reaper/, and registers them in REAPER's Action List. The folder structure mirrors the installer layout precisely, ensuring compatibility between ReaPack and traditional installation methods.

Example 2: Version Synchronization Workflow

STEMwerk-reaper maintains version consistency through an explicit tooling pipeline:

# Before any release, the maintainer runs:
python tools/version_sync.py --write

This script propagates the canonical version from the VERSION file across all distribution artifacts—installer manifests, ReaPack index, in-script version checks, and documentation. The --write flag performs in-place updates rather than dry-run verification. After synchronization, the standard release ritual is:

# 1. Edit VERSION file to new version string
echo "2.2.2.1" > VERSION

# 2. Synchronize all derived version references
python tools/version_sync.py --write

# 3. Commit the synchronized changes
git add -A
git commit -m "Release v2.2.2.1"

# 4. Tag matching the VERSION content exactly
git tag v2.2.2.1

# 5. Push for CI/CD release build
git push origin main --tags

This discipline prevents the version drift that plagues many ReaScript projects, where the Action List shows different versions than the installed package or GitHub releases.

Example 3: Runtime Diagnostics and GPU Detection

The project includes dedicated tooling for environment validation:

# Check GPU availability and backend compatibility
python tools/gpu_check.py

# Warm up models for faster first separation
python tools/warmup.py

# Stress test the separation pipeline
python tools/stress_bench.py

These utilities live in the tools/ directory and are invoked by STEMwerk-SETUP.lua during verification, or can be run manually for troubleshooting. The gpu_check.py script is particularly critical—it probes for CUDA, DirectML, and ROCm availability, then reports compatible backends to the REAPER layer for device selection dropdown population.

The warmup.py script performs a dummy separation pass to trigger model compilation and cache warming, eliminating the cold-start penalty on your first real separation job. For production environments, running this after installation ensures consistent latency for time-sensitive sessions.

Example 4: Core Separation Process Architecture

The actual audio processing flows through scripts/reaper/audio_separator_process.py, which bridges the REAPER Lua environment with Python's ML ecosystem:

# Conceptual architecture (based on project structure documentation)
# scripts/reaper/audio_separator_process.py

import sys
import os

# Add bundled tools to path for imports
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'tools'))

from audio_separator.separator import Separator
# Separator class from audio-separator package wraps Demucs inference

def process_item(input_path, output_dir, model_name, device):
    """
    Core separation worker called by REAPER's Lua layer.
    
    Args:
        input_path: Absolute path to source audio file
        output_dir: Directory for stem output
        model_name: 'htdemucs', 'htdemucs_ft', or 'htdemucs_6s'
        device: 'cpu', 'cuda', 'directml', 'rocm', or 'auto'
    """
    separator = Separator(
        model_file_dir=os.path.expanduser('~/.cache/stemwerk/models'),
        output_dir=output_dir,
        model_name=model_name,
        device=device
    )
    
    # Demucs inference: returns list of output file paths
    output_files = separator.separate(input_path)
    
    # Return paths to Lua layer for track/take creation
    return output_files

This Python backend is spawned as a subprocess from Lua, with JSON-RPC style communication over stdout/stderr. The separation logs mentioned in troubleshooting (separation_log.txt) capture the full device information—Python version, PyTorch build, ONNX Runtime version, and selected compute device—making remote diagnosis straightforward when issues arise.

Advanced Usage & Best Practices

🚀 GPU Acceleration Strategy Always run STEMwerk-SETUP.lua after graphics driver updates. The PyTorch 2.5.1 pin in v2.2.2.1 prevents the weights_only breakage, but driver-PyTorch mismatches can still cause silent CPU fallback. Check separation_log.txt for actual device utilization.

⚡ Parallel Processing Discipline Parallel mode is fantastic for batch workflows, but understand when it's forced sequential: DirectML multi-job runs (Windows AMD stability safeguard) and auto-detected CPU fallback. The progress window explicitly states the reason—use this to optimize your queue strategy.

💾 Model Cache Management Downloaded models live in %LOCALAPPDATA%\STEMwerk\models (Windows) or ~/.cache/stemwerk/models (Unix). If you're using offline installers, verify these directories are populated before disconnecting from internet. The offline patch installer intentionally skips "cleanup models" to preserve bundled payloads.

🎛️ Toolbar Optimization Assign strips_90x30/ icons for standard DPI or strips_180x60/ for hiDPI displays. The 3-state strips (normal/hover/active) provide visual feedback during processing. For custom layouts, single/ directory contains individual sizes (24/30/36/48/64px).

🔧 Diagnostic Ritual When separation fails: collect bootstrap.log + separation_log.txt + stdout.txt + stderr.txt before filing issues. These four files contain complete environment state and are explicitly requested by maintainers.

Comparison with Alternatives

The verdict: STEMwerk-reaper uniquely combines Demucs quality, complete local privacy, zero cost, and native DAW integration. Spleeter requires manual environment management. iZotope RX is excellent but expensive and doesn't integrate this deeply with REAPER's track management. Online services trade convenience for ownership, privacy, and ongoing costs.

FAQ

Q: Does STEMwerk-reaper work with REAPER v7? A: Yes. The ReaScript API is stable across REAPER versions. The v2.2.2.1 release validates on current REAPER builds.

Q: How much RAM do I need? A: Minimum 8GB system RAM recommended; 16GB+ preferred for Quality model or parallel processing. GPU VRAM requirements vary by model: Fast model works on 4GB, Quality model prefers 6GB+.

Q: Can I use this commercially? A: Absolutely. MIT License permits commercial use, modification, and distribution. The Demucs models have their own licenses (MIT for htdemucs variants) permitting commercial application.

Q: Why is first setup so slow? A: The installer creates a Python virtual environment, installs PyTorch/ONNX/audio-separator packages, and downloads your first model. This is one-time; subsequent separations use cached runtime. Expect 5-15 minutes depending on internet speed and hardware.

Q: My separation is running on CPU despite having a GPU—why? A: Check separation_log.txt for device detection. Common causes: outdated GPU drivers, PyTorch CUDA version mismatch, or Apple Silicon where GPU acceleration remains best-effort. Run STEMwerk-SETUP.lua to rebuild runtime with correct device bindings.

Q: Can I process multiple files unattended? A: Yes. Queue multiple tracks or items with Parallel enabled (when compatible with your device). The batch system processes sequentially or in parallel based on stability safeguards, with per-job progress tracking.

Q: What's the difference between "new tracks" and "in-place" output? A: New tracks creates separate tracks for each stem, optionally folder-grouped—best for remixing. In-place replaces the source item with stems as takes—best for quick A/B comparisons or karaoke workflows. Use STEMwerk_Explode_Takes.lua to split in-place takes to separate tracks later.

Conclusion

STEMwerk-reaper represents something rare in audio software: a tool that eliminates friction without adding complexity. It doesn't ask you to learn a new DAW, subscribe to a service, or trust your unfinished work to distant servers. It asks one thing: select your audio, choose your stems, and keep creating.

The v2.2.2.1 release is production-ready, battle-tested on Windows NVIDIA/AMD, Linux AMD ROCm, and macOS Intel. The installer system handles the traditionally painful Python ML environment setup. The ReaPack distribution keeps updates seamless. And the entire pipeline stays where it belongs—on your machine, under your control.

If you're still exporting tracks to separate stems, you're living in the past. The future is local, integrated, and open source. Grab STEMwerk-reaper from the official GitHub releases, run the installer, and never leave REAPER for stem separation again.

Your workflow will thank you. Your clients will thank you. And that 15 minutes you used to spend uploading and downloading? Spend it on the music instead.

Have you tried STEMwerk-reaper? What's your stem separation workflow? Drop your experience in the comments—let's build the definitive resource for REAPER producers.