Turn an RTX 4060 into a Free Audio Separation Backend

Summary

Pixel’s announcement explores how UVR Online connects a cloud-hosted website to a Windows PC with an RTX 4060 to separate audio tracks. It details the Next.js and Go architecture, private Cloudflare R2 storage, and an outbound-only Python worker that processes tasks locally—showing how to offer worldwide access without a public home IP.

DEV Community

How I Turned My Idle RTX 4060 into the Backend for a Free Audio Separation Website

I had an RTX 4060 in my Windows PC that wasn’t getting much gaming time. Instead of leaving it idle, I connected it to a website. The result is UVR Online: users upload a song, choose a separation model, then listen to and download the separated tracks. The website runs in the cloud. The actual audio inference runs on my local computer in China, serving users around the world. I didn’t need a public IP address at home or port forwarding. The architecture Browser ── upload ──► Private Cloudflare R2
│ ▲
│ │ download input / upload results
▼ │
Next.js → Go API ◄──── Windows Python Worker
│ └── PyTorch CUDA → RTX 4060
├── PostgreSQL
└── Redis
Each part has a specific job: Next.js provides the interface, task pages and audio players. Go handles task creation, permissions, upload authorization and Worker coordination. PostgreSQL stores the authoritative task state. Redis handles rate limiting. Cloudflare R2 holds private input and output files. Python, PyTorch CUDA and FFmpeg handle audio validation, separation and encoding locally. The separation engine builds on the UVR ecosystem and headless inference code. I’m building the web service around existing models, rather than training a new separation model. The local PC pulls work The cloud server never opens a connection to my home computer. Instead, the Worker makes outbound HTTPS requests to register, send heartbeats and claim tasks. For each task, it: Downloads the input using a short-lived signed URL. Checks the actual audio with ffprobe. Runs the selected model on the GPU. Encodes and uploads the results to R2. Reports completion to the API. The browser also uploads directly to R2. This keeps large audio files out of the application server’s data path. Private results are accessed through short-lived signed URLs, rather than public bucket links. A home computer needs recoverable tasks A local PC can restart. The network can disconnect. A process can crash halfway through a song. To handle that, claimed tasks have a lease and an attempt token. The Worker renews the lease while it works. If the lease expires, the server can requeue the task within its retry limit. An old attempt cannot later overwrite the result of a newer attempt. Claiming is atomic in PostgreSQL, and completion is idempotent. Redis is useful for rate limiting, but it doesn’t become a second source of truth for task status. This provides recovery, not uninterrupted availability. A single local machine is still a single point of failure. The surprising bottleneck was file transfer My first assumption was that GPU inference would dominate the wait. In practice, moving audio between my local PC and overseas storage became an important bottleneck—especially over a slow VPN route. Output size matters too. A small MP3 can expand into much larger uncompressed tracks. For example, five minutes of 44.1 kHz, 16-bit stereo audio is roughly 50.5 MiB per WAV track, before headers. Two stems are about 101 MiB. That is why export format is an infrastructure decision as well as a user preference. I also changed the Worker from a fully serial workflow to a bounded pipeline: Task A: upload results
Task B: run inference
Task C: download input
Only one task uses the GPU at a time. Network transfers can overlap with inference, and temporary disk usage is bounded. This reduces avoidable GPU idle time. It doesn’t make the internet connection faster, and a backed-up upload stage still applies backpressure. Free processing still needs limits Removing a daily usage cap doesn’t remove the need for admission control. Free processing is constrained by file size, duration, supported formats and queue capacity. Each free user can have only one unfinished task. Network-level limits and bot verification add another layer of protection. The point is to let someone process another song after finishing t...
Turn an RTX 4060 into a Free Audio Separation Backend
Powered by Readybot.io

The latest from Pixel

Incident Response: Look Beyond the Red Alert

Pixel’s DEV Community announcement explores how teams can fixate on one failing service while overlooking the real cause of an outage, such as a full …

Sach: AI Fact-Checks WhatsApp Forwards in India

Pixel’s announcement introduces Sach, a tool that checks forwarded messages in English, Hindi, Telugu, and 14 other Indian languages against official sources. It gives cited …

Java 25 Removes SecurityManager: What to Fix

Pixel’s announcement explains how Java 24’s JEP 486 permanently disabled the SecurityManager, breaking test workarounds that intercept System.exit. It recommends returning exit codes or throwing …