UVR5 UI: separating vocals from tracks with a Gradio front end
Ultimate Vocal Remover 5 with Gradio UI. Separate an audio file into various stems, using multiple models
At a glance
- What is it?
- UVR5 UI wraps the python-audio-separator engine in a Gradio interface so that a track can be split into stems with ensembles of up to six models. It targets users with an NVIDIA RTX 2000 series card or newer, and it needs a compiler, FFmpeg and roughly 10 GB of disk.
- Who is it for?
- UVR5 UI fits people who separate their own music on a machine with an RTX 2000 series card or better and want a browser interface over the python-audio-separator engine instead of a command line. It does not fit a laptop without a discrete NVIDIA GPU, since the documentation states that CPU use will be very slow and points you to hosted notebooks and a Hugging Face Space instead.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 11 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 24, 2026, and from our analysis. They are not legal advice.
Editorial analysis
A browser front end over the python-audio-separator engine
UVR5 UI is the graphical half of a two part project. The README states that it is based on python-audio-separator, described there as a CLI version of UVR5, and that the interface project was originally created for the AI HUB community. The separation models and the actual audio work therefore come from that engine, and what this repository contributes is the Gradio layer on top, plus the installers, updaters and run scripts that make the whole thing usable on a desktop.
The scope of the interface is wide because the underlying engine supports many model architectures. The feature list names VR Arch models, MDX-NET models, Demucs v4, MDX23C, Mel-Band Roformer, BS Roformer, Music Source Separation models and VIP models. Alongside individual models there are ensembles, which combine between two and six models of any architecture using eleven algorithms, curated presets, or a combination you define yourself.
Two input paths are supported. You can upload a local audio file, and you can separate audio or video from any site supported by yt_dlp, with the project linking to that project's list of supported sites. Batch separation is available for people working through a folder rather than one track. Output file names can be set yourself, and there is a one-click download of all the stems once a job finishes. The UI is also translated into multiple languages and the project ships notebooks for Colab, Kaggle and Lightning.ai, so people without local hardware have a documented path in.
The split between interface and engine matters for anyone weighing alternatives. A command line tool and a browser tool are different products with different costs, and this repository is firmly on the browser side of that line.
The hardware floor: an RTX 2000 series card and 10 GB of disk
The requirements section is blunt about what this runs on. The stated hardware requirement is an Nvidia Series 2000 (RTX) card or higher, plus at least 10 GB of disk space. The note under it says older NVIDIA GPUs will be very slow and that CPU will be insanely slow, and it points users who fall short to the hosted options: Colab, Kaggle, Lightning.ai and a Hugging Face Space.
That is a real constraint rather than a formality. The pinned dependency list includes `audio-separator[gpu]==0.47.0` and `onnxruntime-gpu<1.27`, with a comment explaining that onnxruntime-gpu 1.27 and later target CUDA 13 while torch is pinned to a CUDA 12 build, so the older onnxruntime is kept for compatibility. The separation models themselves are large, and the update path downloads about 3 GB and needs roughly 6 GB of free disk space while it runs.
The software prerequisites are equally specific. Git is needed to clone the repository or to run the updater. FFmpeg is needed for media handling, and on Windows it has to be added to the PATH. A C compiler is required because one of the dependencies is built during installation, which is why the Linux package instructions include build-essential, base-devel or gcc with gcc-c++. The project also points to an automated FFmpeg installation script for Windows.
On Debian and Ubuntu the documented line is:
sudo apt install ffmpeg git build-essentialArch and Fedora users get the equivalent with pacman and dnf respectively.
Installing from a clone, then launching with the run scripts
Installation is script driven rather than package driven. You either clone the repository or download the source of the latest release, and then run the installer for your platform. The documented clone command is:
git clone https://github.com/Eddycrack864/UVR5-UI.gitOn Windows the README says to double-click `UVR5-UI-installer.bat`, with a warning not to run it as administrator. On Linux you make the shell installer executable and run it:
chmod +x UVR5-UI-installer.sh
./UVR5-UI-installer.shStarting the app follows the same pattern. Windows users double-click `run-UVR5-UI.bat`, Linux users make the run script executable and run it. The scripts accept the same options as `python app.py`, and the documented table lists `--share` for a temporary public Gradio link, `--listen-port 8080` to change the port from the default 9999, `--server-name 0.0.0.0` to reach the UI from other devices on the network, `--open` to launch a browser, and `--run-history` to keep a history of separations in the browser, which is off by default. The example given is `run-UVR5-UI.bat --share --listen-port 8080`.
The `--server-name 0.0.0.0` option deserves attention because it changes the exposure model of the application. The default binds locally, while that flag publishes the interface to every device that can route to the machine, and the interface accepts uploads. Similarly, `--share` hands you a public Gradio link, which puts your local machine behind a temporary tunnel. Neither is documented as safe for untrusted networks.
If something fails during install or startup, the project directs you to a troubleshooting file in the info directory first, and to open an issue only if the error is not described there.
User data and models live outside the update path
The updater is the piece of the design that most affects day to day use. Windows users double-click `UVR5-UI-updater.bat`, Linux users run `UVR5-UI-updater.sh` after making it executable. The documentation is explicit that your preferences, which it describes as language, theme and saved separation settings, live in the `user_data/` folder, and that your models live in `models/`. Updating never touches them.
That separation is what makes updating safe enough to be casual. It also means your disk usage is dominated by things the updater will never clean for you. The 10 GB figure in the requirements is a floor, and the models you download accumulate in `models/` whether or not you still use the architectures involved.
Version handling is also part of this story. UVR5 UI runs on Python 3.13, and the updater offers to rebuild the Python environment automatically if your installation is on Python 3.10. That rebuild downloads about 3 GB and needs about 6 GB of free disk space, and the documentation states that if anything fails, the previous environment is restored. In other words, the update path is designed to be reversible at the environment level, though the README does not document a manual rollback command.
For diagnosing a broken installation there is a separate status checker, `info/status-checker.bat` on Windows and `info/status-checker.sh` on Linux, which reports on the audio-separator core.
A layered Python package with a declarative model catalog
The repository is not a single script. The development section describes the app as a Python package named `uvr5_ui`, organised in layers, and the mapping in the README is worth reading because it explains how the model zoo stays manageable.
`app.py` is described as a thin launcher that can be run as `python app.py [options]` or as `python -m uvr5_ui`. Below that, `uvr5_ui/core/` holds separation, the model catalog, downloads and the leaderboard, with the note that it contains no Gradio imports and can be tested on its own. Above that, `uvr5_ui/ui/` is the Gradio layer, with one module per interface area.
The key file is `uvr5_ui/core/separation/specs.py`. It holds one declarative `ArchSpec` per architecture, covering parameters, ranges and defaults, and the README states that all separation tabs and the separation service are generated from it. In practice, adding a new model architecture means writing one spec rather than hand-building a tab and wiring up the parameters by hand. That is the kind of decision that keeps a project with eight named model families from turning into eight separate code paths.
The top level of the repository shows the supporting cast: `UVR_UI.ipynb` and its Kaggle and Jupyter variants for hosted execution, `ytdl/` for the yt_dlp path, `tools/`, `tests/`, and the `inputs/`, `models/` and `outputs/` directories. The pyproject.toml file holds only tooling configuration, pointing pytest at the `tests` directory and registering a `network` marker for tests that need internet access, with a comment that those are skipped unless pytest runs with `--network`.
Pinned dependencies and a slow release cadence
The runtime dependencies live in requirements.txt rather than in the pyproject.toml, and the file carries its own commentary explaining each constraint. `audio-separator[gpu]==0.47.0` is the engine. `onnxruntime-gpu<1.27` is held back so that the CUDA 12 build lines up with torch cu128. `librosa<1.0` is pinned because librosa 1.0 removed audioread, which audio-separator 0.47 still imports, and the comment notes that audio-separator is tested against librosa 0.11. Then there is `gradio==6.30.0`, `yt_dlp` and `pypresence`.
This is a project where dependency pins are doing real work, and it cuts both ways. The pins keep a fresh install consistent with a known good state, which matters when the upstream engine is moving fast. They also mean you inherit any bug in the pinned combination until the maintainers bump the file.
The licence is MIT, which is the permissive end of the scale and carries no source disclosure condition for anyone who modifies and redistributes the tool. The repository is not archived and the last push was on 2026-10-13, so the code is being changed.
Tagged releases tell a different story from the commit history. The recent releases listed are v1.8.4 on 2025-04-29, v1.8.3 on 2025-03-13 and v1.8.2 on 2025-03-08, so releases have come in bursts, with two of those three landing within a week in March 2025, and then a gap to April. If you plan to track this project by tag, note that the download link the README gives for the latest release source points at the releases page rather than at a specific version, and that the tagged history is much older than the last commit.
Where UVR5 UI is the wrong choice
The clearest case for skipping this project is hardware. The documentation is unambiguous that CPU use will be insanely slow and that older NVIDIA cards will be very slow, so a machine without a recent discrete GPU means a very different experience from what the UI is designed for. The hosted paths exist for exactly this reason, and the README links a Hugging Face Space running with a Zero GPU setup on an A100.
A second limitation is the dependency on external services for input. The yt_dlp path is convenient, but it depends on the site you are pulling from continuing to serve media in a form yt_dlp can read. That is outside the project's control, and the README does not describe any fallback when a download fails.
A third point concerns the comparison with the command line tool it is built on. python-audio-separator is the engine, and using it directly means no browser, no shared link and no model catalog UI, but it also means you are not tied to a Python 3.13 environment maintained by this project's installer scripts, and you are not bound by the pinned Gradio version. For someone who runs separations on a headless server and drives everything from a shell, the interface is overhead rather than value. The other difference worth noting is licensing: this interface is MIT, while the engine it wraps carries its own terms that apply to the separation models and the code underneath.
Finally, the interface is not a light add-on. On a machine that already meets the requirements, the install and update cycle downloads gigabytes and builds a compiled dependency. Anyone expecting a quick pip install and a small download should read the requirements first.
Editorial conclusion
UVR5 UI fits people who separate their own music on a machine with an RTX 2000 series card or better and want a browser interface over the python-audio-separator engine instead of a command line. It does not fit a laptop without a discrete NVIDIA GPU, since the documentation states that CPU use will be very slow and points you to hosted notebooks and a Hugging Face Space instead. Before adopting it, check the pinned dependency versions in requirements.txt against your CUDA setup, read the troubleshooting notes, and decide how you will handle the models directory, which the updater leaves untouched but never prunes.
Frequently asked questions
What hardware does UVR5 UI need to separate vocals?
The documented requirement is an Nvidia Series 2000 (RTX) card or higher and at least 10 GB of disk space. The README warns that older GPUs will be very slow and that CPU will be insanely slow, and points users without the hardware to Colab, Kaggle, Lightning.ai or the Hugging Face Space.
How do I install UVR5 UI on Linux?
You clone the repository, then make the installer executable and run it with `chmod +x UVR5-UI-installer.sh` followed by `./UVR5-UI-installer.sh`. Git, FFmpeg and a C compiler have to be present first, and FFmpeg must be on the PATH on Windows.
Which port does UVR5 UI use and how do I change it?
The default port is 9999. Passing `--listen-port 8080` to the run script or to `python app.py` uses a different port, and `--server-name 0.0.0.0` makes the interface reachable from other devices on your network.
Does updating UVR5 UI delete my models and settings?
No. The README states that preferences live in the `user_data/` folder and models in `models/`, and that updating never touches them. The updater can rebuild the Python environment, which downloads about 3 GB, and the previous environment is restored if that fails.
What is the difference between UVR5 UI and python-audio-separator?
UVR5 UI is based on python-audio-separator, which the README describes as a CLI version of UVR5. The interface adds a Gradio browser UI, model selection across several architectures, ensembles of two to six models, batch separation and a one-click download of all stems.
Can UVR5 UI separate audio from a video link?
Yes, the README lists separation of audio or video from all sites supported by yt_dlp, and links to that project's list of supported sites. The repository also includes a ytdl directory for that path.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/eddycrack864-uvr5-ui)Was this useful?