YuE2

On 9 September 2026 M-A-P shipped YuE2, and within a week it was number one on GitHub and number one on Hugging Face's text-to-audio board. It is the first open music model to claim it beats Suno v5 at full-song generation, lyrics and vocals included. Before you pull 7.3 GB of weights, two facts change what you can do with them: the benchmark it wins on was built by the same lab, and the weights moved from Apache 2.0 in YuE v1 back to non-commercial in YuE2. The model is genuinely good. The headlines are doing some work.

YuE2 is not a v2, it is a different model

YuE v1 was a two-stage LLaMA-based language model over xcodec audio tokens, with a decoupled dual-track scheme that let it emit vocals and instrumental separately. YuE2 keeps the name and the repository, and throws out the rest. One AR-NAR Mixture-of-Transformers backbone predicts a musical score and semantic tokens autoregressively, then generates acoustic latents with flow matching, and a VAE decodes those latents to stereo audio.

The shipped config is specific. 3,630,684,224 parameters in BF16 across 28 layers, hidden size 2048, 16 attention heads over 8 KV heads, and a 184,704-token vocabulary. Context is 24,576 tokens, and that is not a soft limit: the code asserts it and raises if you change it. The project page rounds the parameter count to 3.59B, so expect to see both numbers quoted.

Audio comes out at 48 kHz in stereo. The VAE downsamples by 1920, which puts latent frames at exactly 25 Hz, and the flow-matching solver runs 32 ODE steps with a midpoint method. The semantic budget of 9,000 tokens at 25 Hz works out to 360 seconds, so roughly six minutes is the practical song ceiling. ComfyUI exposes a 900-second option, but the pull request that raised it says plainly that nobody tested whether the model supports that length.

Training used 346,000 hours, described as "primarily CC0 music and synthetic data", with Tokenwave.AI supplying most of the synthetic set under license. There is no technical report yet. The citation block still points at the YuE v1 paper, so every architecture claim here comes from a README and a model card, not from peer review.

The license went backwards

This is the part that decides whether you can build on it. In January 2025 the YuE team relicensed the v1 weights to Apache 2.0 under a banner reading "A New Era Under Apache 2.0". YuE2's weights ship under CC BY-NC 4.0 instead, with a dated creator permission bolted on top.

That permission is narrower than it first reads. It grants "personal users, content creators and musicians acting in an individual capacity" the right to use the weights free of charge and to "publish, distribute, sell, license or otherwise monetize those outputs", waiving the NonCommercial restriction for exactly that. Then it draws the line: the permission "does not authorize commercial use of the model weights by companies."

So if you are one person making songs, you can sell them. If you are a company that wants to ship YuE2 inside a product, you need a negotiated license from HKGAI. The code, the agent skill and the docs stay Apache 2.0, which means you can fork the harness freely and still be blocked on the weights. There is open community pressure to change this, in both a GitHub issue asking for commercial terms and a Hugging Face thread proposing a revenue-threshold license, and neither has an answer from the authors.

The benchmark is theirs

Every Suno comparison you have seen comes from WildSongBench, a 192-prompt benchmark M-A-P built and published alongside the model. No third party has reproduced any of it. To their credit the authors say so themselves, noting that "the small gap between the highest means does not establish statistical significance" and that these are "documented system comparisons, not matched-compute experiments". A blind listening arena is running and its results are not out.

Read the fine print on that top row. Standard YuE2 picks the lower-error candidate from two generations, but best-of-8 selects on SongBench Musicality first, which is one of the dimensions being reported. The authors flag it: that selection "is not equivalent to one unselected pipeline call". Both YuE2 rows also use the legacy VAE, not the decoder you get by default, because the legacy one scores higher while the default sounds better.

The honest headline is the one nobody is printing, because it compares the model to itself. YuE 1 to YuE2 is 4.9165 to 6.7316 on the same benchmark, and phoneme error rate falls from 36.38% to 8.44%. Lyrics that used to come out as mush now come out as words. That is a same-team, same-metric result, and it is far more defensible than beating Suno by 0.09 of a point.

YuE2 also loses in places. Suno v6 scores higher on SongEval and lower on phoneme error, Suno v5 leads on both text-audio alignment metrics, LeVo 2 has the best raw audio quality of all seventeen systems tested, and MiniMax Music 3 has the best phoneme error rate of any open model at 6.27%.

What is genuinely new: you can edit the score

The interesting part of YuE2 is not the audio, it is the step before it. The model writes a chord-annotated ABC transcription first, then renders audio from it, and that intermediate score is plain text you can read and change. Change a note in the ABC, feed it back with the same request, and the model re-renders. In the authors' editing study, local changed-note melody attainment goes from 0.0083 to 0.9375 when you edit the score instead of re-prompting.

Three planning modes control this. The default writes a full score with chords, a melody mode writes melody only, and turning planning off gives you direct lyrics-to-audio like v1. Covers work through the same door: a companion model called SheetSage2 transcribes a source track to a melody score, and YuE2 re-renders it in a new style. Identity is carried by the notation, not the timbre.

The repository also ships a first-party agent skill, an Anthropic-style SKILL.md with helper scripts for planning, ABC inspection and transcription. As far as we can tell that is a first for a generative audio model, and it is a sensible bet: this pipeline has four stages and a text artifact in the middle, which is exactly the shape an agent can drive.

What it lost

YuE2 cannot clone a voice. The request format has no field for reference audio, phonemes, BPM, a negative prompt or a reference singer, and the repository documentation states that plainly. This removes v1's in-context learning mode entirely. The GitHub topic list still carries a "voice-cloning" tag, which is left over from v1 and is now misleading. If open voice work is what you came for, MisoTTS is the better fit.

There are no stems either. v1 could emit vocals and instrumental as separate tracks; YuE2 gives you one mixed stereo file. There is also no reliable instrumental-only mode, and the community workaround (plan in full mode, omit language and singer from the style, then supply empty section tags) is unreliable enough that people are writing ComfyUI nodes to strip vocal voices out of the generated score instead.

Officially it is Linux only, with Python 3.12. The model card lists just Chinese and English, while the demo page's own data ships examples in six languages including Japanese, Korean, Russian and Spanish, so real coverage is wider than the metadata admits. Jazz and blues players should know that the rhythm grid cannot encode a triplet or swing, and that is an open issue, not a prompting problem.

What it takes to run

The stated requirement is a 24 GB NVIDIA card, and that number is conservative. The authors' own table peaks at 11.18 GiB, because the 24 figure is a memory budget default rather than a floor.

So a 3.6-minute song takes about 71 seconds on a 4090, which is roughly three times faster than real time. At Q4_0 the whole thing fits in 7.6 GB, which puts it on an 8 GB card, and one user reports a stable run on a 10 GB GPU peaking at 9.7 GiB. You may see a 4.5 GB figure on aggregator blogs. We could not find a primary source for it, and the lowest number with evidence behind it is 7.6 GB.

Run it today

The official path is a virtual environment and one command. Python 3.12 is not optional, and the pinned runtime is PyTorch 2.10.

git clone https://github.com/multimodal-art-projection/YuE.git
cd YuE
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install .
python examples/generate.py --output outputs/first-song

A request is now a single JSON object instead of v1's pair of text files. Style carries genre, instruments, vocal character, language and tempo as free text, and section tags are capitalised.

{
  "id": "city_lights",
  "style": "English, warm piano pop, expressive female voice, acoustic piano, rounded bass and light drums, 88 BPM",
  "lyrics": "[Verse]\nNeon fades along the lane\n\n[Chorus]\nLet the day come into view",
  "cot": "full",
  "seed": 831001
}

If you would rather not build an environment, ComfyUI has had native support since v0.35.0, which shipped the same day as the model, and audio.cpp added GGUF inference the day after. Cover generation needs a second virtual environment on Python 3.10 or 3.11, because SheetSage2 pins an older Transformers and NumPy that will not coexist with the YuE2 one. One thing to watch: a finished job does not mean an untruncated song, so check the truncation flags rather than trusting the status field.

If you are on a Mac, read this first

Apple Silicon runs YuE2 through MPS, and on the pinned PyTorch 2.10 it is silently wrong. The causal mask in scaled dot-product attention is applied per block of four query positions, so a query can attend up to three keys into the future. No error, no warning, no NaN. One reporter measured a relative error of 0.452 against CPU float32 at sequence length 128, and a second reporter confirmed it independently on different hardware.

The upstream fix landed in PyTorch 2.13, and a later reporter measured the error dropping to 0.003 on 2.14. The issue is still open and the pin is still 2.10.0. If you are generating on a Mac with the default install, you are getting degraded audio and nothing will tell you. Either upgrade PyTorch past the pin or use one of the community MLX ports.

YuE2 or ACE-Step 1.5

For most people running models at home, ACE-Step 1.5 is still the default. It is MIT for both code and weights, it fits under 4 GB, and it generates a song in under ten seconds on a 3090 against YuE2's seventy-one on a 4090. It scores 6.0118 to YuE2's 6.7316, so you are trading about 0.72 of a benchmark point for roughly thirty times the speed, a third of the VRAM, and a license you never have to think about.

Pick YuE2 when quality is the point, when you want the editable score, or when you are doing covers where melodic identity has to survive a style change. Pick ACE-Step when you want to iterate fast, ship commercially without a lawyer, or run on a small card. If what you actually want is a whole studio rather than a model, our local AI music studio coverage tracks theDAW, and part two covers the migration after the project was renamed.

Sources and further reading

• YuE2 on GitHub
• YuE2-3B model card and weights on Hugging Face
• MODEL_LICENSE, including the individual creator permission
• WildSongBench methodology and the authors' own caveats
• Project page, demos and training-data disclosure
• SheetSage2, the transcription model behind covers
• GGUF quantizations and measured VRAM figures
• Hosted Gradio demo on Hugging Face Spaces
• ComfyUI YuE2 tutorial
• The first-party agent skill

Ten minutes, no install: open the hosted demo, generate one song with planning on, and read the ABC score it produces before you listen to the audio. That score is the whole argument for this model, and it is the fastest way to tell whether the argument lands for you.

Tested on: not independently tested. Architecture figures come from the published config.json and the model card. Benchmark numbers are author-reported on WildSongBench, a benchmark M-A-P built, with no independent replication as of this date. VRAM and speed rows marked community-reported come from GGUF users and open issues, not from our own hardware.
Date checked: 2026-09-20