# YuE2 Studio: local song generation with a score you can edit

> YuE2 Studio wraps the YuE2 song model in a Rust and React desktop app, generating full songs with vocals from a style and lyrics, returning the composition as ABC notation that can be edited and re-rendered, with a Windows installer that runs offline on an NVIDIA card with 6 GB of VRAM.

**timoncool/YuE2-Studio** — Local AI song generator with an editable score — YuE2 on your GPU: full songs with vocals, sheet music, covers, exact replay. Native Windows app, no Python, installer with auto-update.

- Repository: https://github.com/timoncool/YuE2-Studio
- Website: https://timoncool.github.io/YuE2-Studio/
- Stars: 1,943 · Forks: 227
- Language: TypeScript
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/timoncool-yue2-studio

## A model that writes the score before it sings

YuE2 is an open song model from M-A-P, and the property that distinguishes it is stated early: it writes a score before it sings.

The workflow the studio exposes follows from that. You describe a style, you write the lyrics, and the model composes a melody with chords as sheet music, then performs it as a full song with vocals. The score comes back with the track. You can read it, edit it, and render the same composition again with a different sound.

That is the whole idea in one paragraph, and it separates this from a text-to-music system that gives you an audio file and nothing else. Here the composition is an artefact you can hold, and the performance is a rendering of it. Change the tempo, the key or the notes, generate again, and the composition stays while the performance changes.

The studio also has a mode that skips the singing entirely, writing only the score from the style and lyrics, which the README describes as the studio's take on yue2.cpp's yue-plan. That mode is the point at which the score becomes the primary artefact: you compose, read, fix, and only then ask for a vocal performance. There is also a melody-only option and an option for no score at all, so the same model can serve three different workflows.

The audience is people who want local, offline music generation and care about the musical result being editable rather than a lucky take.

## A Tauri shell around a CUDA port with no Python in the path

The architecture is unusual enough to be worth describing precisely.

The README states that the studio is built on yue2.cpp, the native C++/CUDA port of YuE2, and that the studio around it is Rust and React in a Tauri window. The emphasis is on what is not there: nothing in the runtime path is Python.

The top line of the README is a single executable, no Python, no Node.js, no launcher. That matters more than it sounds. The usual failure mode for local generative media tools is an installer that quietly requires a Python environment, a specific CUDA build and a set of pip packages, and that breaks the next time the user updates a driver. Shipping a native port and wrapping it in a desktop app moves all of that into a compiled binary.

The Rust side is a Cargo workspace with four members, music-core, music-server, music-engine and audio-post, on edition 2024 with a shared workspace version of 0.1.0. The dependency list shows what the application actually does: axum for the HTTP server, tokio for the async runtime, rusqlite with the bundled feature for local state, and the ort crate pinned to 2.0.0-rc.13 with cuda and directml features, which is the ONNX Runtime binding doing inference. symphonia handles audio decoding across a long list of formats, parakeet-rs provides on-device speech handling, and reqwest is built with rustls, socks and multipart features.

The proxy feature is worth noting because it explains that dependency list. The studio can act as an HTTP, HTTPS, SOCKS5 or SOCKS4 proxy with a login, and model downloads, Hugging Face, OpenRouter and updates all go through it. That is for users whose network requires it, and it is implemented with hyper-util's client-proxy features.

## The score is the editable centre of the workflow

The score is written in ABC notation first and then engraved as sheet music by the studio. That choice of intermediate representation is what makes the editing story work, because ABC is plain text and can be handled like text rather than like an image.

From there the studio offers several levels of control. You can edit notes, tempo and key and create again. You can transpose generation by minus 24 to plus 24 semitones. Scores can be edited with a MIDI grid and octave controls, and there is a batch score-plan selection mode along with chord mirroring in repeated sections.

The song writing side is structured as well. A style can be built from its musical fields, and lyrics can be arranged into editable sections while keeping the plain text editable. The writing assistant takes a language, a target of 8 to 32 lines and additional instructions. On the voice side there are voice and tempo fields, plus section, line and stanza tools and text-case handling.

Lyric preservation has two specific modes, Keep and Words, along with a notion of exact checkpoint tokens, which is the mechanism for holding a lyric fixed while the music around it moves.

The scale of the output is stated too: full songs of up to ten minutes, in the languages the model sings. There is a language specific detail for Russian, where a stress mark, the combining acute U+0301 entered as Alt+0769 on Windows, placed after a vowel moves the sung stress onto it.

For rendering there is a vocals-only path through native HT-Demucs, and the audio format is either lossless FLAC or MP3.

## Exact replay and the settings that are actually exposed

The feature the studio calls exact replay is the one that changes how you work with the tool.

Every track keeps its request and its audio codes, so it can be re-rendered bit for bit, or re-rendered with other steps, with a new sound seed, with several variations, or in another output format, without composing again. Once a take is good, you can experiment around it without losing it, and you can regenerate the identical audio when you need to be sure of what you had.

The engine settings are exposed rather than hidden. The README lists all seven sampling knobs, temperature, top-p, top-k, the repetition penalty and its window, and the minimum and maximum tokens, applied separately for the score and for the audio codes. There are flow-matching steps, guidance, both seeds, and the choice of lossless FLAC or MP3.

Prompts can be opened and saved as JSON or YAML in the engine's own request format, and the point of that is interoperability: the same prompt files move between the studio, the yue2.cpp WebUI and the yue-synth command line tool. For anyone who already works with yue2.cpp directly, the studio is not a walled garden, it is a front end over the same request format.

There are also 110 ready examples that ship with yue2.cpp, style and lyrics and score sets with covers included, loadable in one click. That is a fast way to see what the model does well before writing a prompt of your own.

## Covers through transcription, and the fit problem they have

The covers feature is the most interesting one technically, because it changes the order of operations.

The description covers SheetSage2, which listens to a recording and writes its melody as a score, and then YuE2 sings that melody in your style. The transcription step replaces the model as the source of the melody, and the vocal generation step becomes a performance of someone else's tune in your chosen style.

The README is unusually honest about the constraint this creates. The words have to fit the melody: the original lyrics work best, and new ones need the same syllables line by line with the stresses on the same notes, or the singing drifts off the tune, with lines stretching, pausing and sliding into the wrong section. Transcription mistakes carry into the cover too, which is a real property of the pipeline rather than a defect in the studio.

A track from your own library can be transcribed from its menu.

This is the clearest case in the project of a feature whose value depends on an input property you cannot control, the fit between words and melody. For a cover where you have the original lyrics, it works. For a cover where you intend to write new words to a melody you did not write, it does not, and no amount of prompt tweaking in the studio will fix it.

## An MCP server so an agent can drive the studio

The README has a section addressed to AI agents, and it describes a concrete integration path rather than a general aspiration.

The instructions are three steps. Install the studio from the latest release and start it. Connect to its MCP server at http://127.0.0.1:8791/mcp, with the given command:

```bash
claude mcp add --transport http yue2-studio http://127.0.0.1:8791/mcp
```

Then read the skill the server serves, the resource studio://skill and the prompt studio, which is the same text as docs/mcp-skill.md, and start with the tool studio_status.

There is a second path for tools that look for it: llms.txt at the repository root says the same thing. And for keeping the skill in Claude Code, the README suggests saving docs/mcp-skill.md as ~/.claude/skills/yue2-studio/SKILL.md.

The architecture supports this because the studio has a local server, music-server in the Cargo workspace, bound to a local port. That server is what an agent talks to, and the same server is presumably what the desktop window talks to.

This is the part of the project that makes it most interesting to an automated workflow, because the studio is not only a GUI. It is a local service with a documented protocol, a status tool and a skill file, and the skill file is the intended entry point for an agent.

## Windows first, a fast release line and an MIT licence

The platform story is narrow and honest.

The download badge points to a Windows x64 build, and the project ships a Windows installer with auto-update or a portable folder. It runs offline on an NVIDIA card with 6 GB of VRAM or more, and AMD and Intel cards through Vulkan are described as experimental. The repository carries rust-toolchain.toml and a Cargo.lock, and the dependency set is full of Windows-specific plumbing, with windows-sys features for job objects and threading.

For a music tool the offline requirement is the point rather than a limitation: the studio is meant to be used without sending your lyrics and audio to a service.

Release activity is high. Version 3.6.0 was tagged on 2026-10-16, 3.5.5 on 2026-10-14, and a music-train-ee7286d1 tag on 2026-10-19 described as a LoRA trainer for HOT-Step at commit ee7286d1. The repository is not archived, and the last push was on 2026-10-20.

Two details are worth reading for anyone planning to extend the project. The crates/ directory shows a clean split between core logic, the server, the engine binding and audio post-processing, and the engines/ directory suggests the model engines are pluggable rather than welded in. The licences/ directory at the root is a good sign for a project that wraps third party models, since it implies the licence text of those components is collected in one place, which is exactly what you need to check before shipping.

The project is MIT licensed, which the Cargo workspace metadata also records, along with the author Ilya Timonin.

## Conclusion

Adopt YuE2 Studio if you want to generate music with vocals entirely on your own Windows machine and then work on the composition rather than re-rolling a take, since the score comes back in ABC notation, can be edited and re-rendered, and every track keeps its request and audio codes for exact replay, with the repository not archived and a last push on 2026-10-20. Do not adopt it if you need macOS or Linux support, since the download is a Windows x64 build, or if your machine has an AMD or Intel card, which the README describes as experimental through Vulkan. Before you commit, verify two things: that you have an NVIDIA card with at least 6 GB of VRAM, since that is the stated baseline, and that the runtime path suits you, because the studio deliberately keeps Python out of it and depends on yue2.cpp for the model itself.

## FAQ

### What hardware does YuE2 Studio need to run?

The README states it runs offline on an NVIDIA card with 6 GB of VRAM or more. AMD and Intel cards are supported through Vulkan but are described as experimental.

### How do I install YuE2 Studio?

It is distributed as a Windows x64 build, either as an installer with auto-update or as a portable folder, from the latest release page. The studio needs no Python, no Node.js and no separate launcher.

### How can an AI agent drive YuE2 Studio?

Start the studio and connect to its MCP server at http://127.0.0.1:8791/mcp, using cla mcp add --transport http yue2-studio http://127.0.0.1:8791/mcp. Then read the skill served as the resource studio://skill, the same text as docs/mcp-skill.md, and start with the studio_status tool.

### Can I edit the generated song before rendering it again?

Yes. The model writes its composition in ABC notation and the studio engraves it as sheet music, so you can edit notes, tempo or key and create again, and the composition stays while the performance changes. There is also a mode that writes only the score without singing it.

### How long does it take to render a song in YuE2 Studio?

The README states that on an RTX 4090 with the Q8_0 set, a 3:38 song renders in about 46 seconds. Songs can run up to ten minutes, and the model sings in the languages it supports.

### What licence is YuE2 Studio released under?

MIT. The Cargo workspace metadata records license = "MIT" with edition 2024 and the author Ilya Timonin, and the repository carries a LICENSE file alongside a licenses/ directory for the third party components it wraps.

## Sources

- [License: MIT](https://github.com/timoncool/YuE2-Studio/blob/main/LICENSE)
- [Project website](https://timoncool.github.io/YuE2-Studio/)
- [README](https://github.com/timoncool/YuE2-Studio/blob/main/README.md)
- [Releases](https://github.com/timoncool/YuE2-Studio/releases)
- [timoncool/YuE2-Studio on GitHub](https://github.com/timoncool/YuE2-Studio)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/timoncool-yue2-studio