YuE2 in ComfyUI: Complete Install Guide (Windows 11/Ubuntu/Kali)

YuE2-3B — the 3B open-weights song model whose WildSongBench score sits above Suno v5’s — now runs natively in ComfyUI, and the install is the surprise: Comfy-Org, the organization behind ComfyUI, repackaged the whole model into plain safetensors files, the ready-made workflows ship inside ComfyUI’s own Template Library, and on Windows 11 there is no Python virtual environment, no WSL, no dependency pins — just the Comfy Desktop app, one 3.96 GB file dropped into a folder, and a template search. This guide walks the entire route on Windows 11 and Kali Linux: what to download, where each file goes, your first song, covers with SheetSage2, and the failure modes nobody else writes up.

Jake’s nephew’s garage band is back, and this time they brought reinforcements. Their first gig is in two weeks and they want a polished demo track to secure the slot. The plan from the command-line route scared two of them off — the drummer treats a terminal like a haunted room — but the third one, Denny, already does AI art in ComfyUI on his home machine and saw a video about running YuE2 in it. Denny’s argument was simple: “I already have the app open.” Jake, who funds the pizza and owns the only 24 GB card in the room — an RTX 4090 he keeps under the shop counter — wanted to know whether that shortcut actually holds up. Ethan had the opinion ready before the question finished.

What “YuE2 in ComfyUI” Actually Means

ComfyUI is a node-based creation tool — instead of writing code, you wire boxes together on a canvas, each box doing one job, and the wires carry the work between them. It started as the image-generation crowd’s favorite control panel and now, per its own repository, generates images, video, 3D, and audio, with native support for a list of open models that includes ACE-Step 1.5, Stable Audio 3, MiniMax Music 3 — and YuE2. “Native support” is the important phrase: the YuE2 logic is inside ComfyUI itself, not a bolt-on custom node from a stranger.

The second half of the story is the packaging. Comfy-Org — the organization behind ComfyUI, whose repository stars run past a hundred thousand — published a repository on Hugging Face called Comfy-Org/YuE2 with the model’s files repackaged for ComfyUI, crediting the original m-a-p model repositories for the weights. A checkpoint, in this world, is the finished model file; safetensors is simply the file format it ships in. The official ComfyUI tutorial for YuE2 links straight to this repackaged download. So when Denny said “I already have the app open,” he was closer to right than he knew: the tool he already runs added this model to its own shelf.

“So I don’t install Python at all?” Jake asked. “The other guide had me building a venv and pinning versions.”

“On Windows, with the desktop app, that entire layer disappears,” Ethan said. “The desktop app ships its own Python. Your job shrinks to: update ComfyUI, put files in folders. The venv existed to stop dependency fights. ComfyUI already fought that battle for you.”

What Your Machine Needs

Two requirement sets stack here, and honest guides keep them separate. The desktop app’s needs are modest on paper: a dedicated GPU (NVIDIA or AMD) recommended but not required, and at least 4.85 GB of disk per installation. The model card still governs the model itself: a 24 GB NVIDIA GPU with BF16 support and 24 GB of host RAM, with the authors’ measured peaks of 11.18 GiB in normal use and 14.08 GiB worst-case. VRAM is the memory on the card itself — the desk everything in progress has to fit on at once.

Does the ComfyUI route need less? No ComfyUI-specific VRAM figure has been published for YuE2. What the repository does list among the engine’s general features is “smart VRAM and RAM management, model offloading, and support for quantized models” — offloading meaning the engine can shuffle parts of a model between system RAM and the GPU. That is the honest boundary: the model card’s envelope is the documented number, ComfyUI manages memory intelligently, and nobody has published the ComfyUI-specific ceiling when i checked for writing this post...

Disk is the easy math. The Comfy-Org/YuE2 repository totals 13.1 GB, but you do not need all of it:

• The int8 checkpoint — 3.96 GB, the default download. Add the 4.85 GB ComfyUI install and a text-to-song setup lands under 9 GB of disk.
• The bf16 checkpoint — 7.8 GB. A larger, full-precision-weights alternative; more on the difference below.
• The SheetSage2 encoder — about 1.39 GB. Only needed for the cover workflow.

The License Didn’t Change With the Packaging

A friendlier install does not soften the fine print, and this is the part the whole “free Suno” excitement keeps skipping.

For the band: a demo to land a gig is a gray zone you should resolve with the rights holders, not with a workaround; the moment money changes hands for the track itself, the NC clause says no. For Jake’s customer-gift use case, it’s fine. “The packaging changed and the license didn’t,” Ethan said. “Read the NC part before you plan the release party.”

Install on Windows 11: The Comfy Desktop Route

ComfyUI’s documentation is unusually direct about the right choice: for Windows and macOS, “we highly recommend using the desktop app” — it is, in their words, the easiest and best way for new users. There is also a portable standalone build for Windows, but the repository itself labels it “not recommended for regular users” — it exists for specific GPU situations, and this guide follows the recommendation rather than the exception.

The desktop app ships as an NSIS installer — a standard Windows .exe — and the flow is short:

1. Download Comfy Desktop from the official ComfyUI download page and run the .exe installer, following the prompts.
2. Launch Comfy Desktop from the Start menu or the desktop shortcut. On first launch, create a new install — the documented option is a standalone, GPU-ready environment, which is the app quietly handling the Python and PyTorch for you.
3. Make sure you are on v0.35.0 or later (v0.35.1 or later if you’re on an AMD GPU) — that is the YuE2 requirement, and ComfyUI updates itself from inside the app’s settings.
4. Drop the YuE2 model files into the folders in the next section.
5. Search “YuE2: Text to Music” in the Template Library and queue your first song.

One Windows 10 note, because the question always comes: Windows 10 passed its end of support on October 14, 2025, and this guide walks the Windows 11 path. One Windows 11 trap while you’re in File Explorer moving model files: the right-click menu is condensed, and the legacy entries sit under Show more options (Shift+F10) — useful when a step tells you to right-click something that isn’t in the modern menu.

Install on Kali Linux: The Source Route

Kali is a rolling, Debian-based distribution — current release 2026.2, Xfce desktop, kernel 6.19 — and ComfyUI’s desktop app for Linux targets Ubuntu 22.04+, x64, and Node.js v22, installable from an official .deb or AppImage, or by cloning the repository and running from source. Kali is not Ubuntu, so the documented path that “supports all operating systems and GPU types” is the manual one. The sequence below follows ComfyUI’s manual install documentation and kali.org’s own NVIDIA guide.

The order matters. Kali rolls continuously, and its NVIDIA driver is an out-of-tree module that gets rebuilt on every kernel change — so the kernel headers come first, always. Skip them and a routine update can leave you at a blinking cursor instead of a login screen.

1. Confirm contrib, non-free, and non-free-firmware are enabled in /etc/apt/sources.list.d/kali.sources (Kali 2026.2’s DEB822-format file), then run sudo apt update and sudo apt -y full-upgrade.
2. Install the headers for your running kernel — sudo apt install linux-headers-$(uname -r) -y — then sudo apt install -y nvidia-driver nvidia-cuda-toolkit, and reboot when the installer warns about the nouveau conflict.
3. After reboot, confirm the driver with nvidia-smi before going further.
4. Install python3-venv, python3-pip, and git from the Kali repositories, and create a virtual environment for ComfyUI. Python 3.13 is “very well supported” with 3.12 as the fallback.
5. Inside the venv, either run the documented helper — pip install comfy-cli then comfy install — or clone the ComfyUI repository and install the NVIDIA PyTorch stack with the documented command: pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130.
6. Place the YuE2 files from the next section into the models/ folders of your ComfyUI directory, and load the “YuE2: Text to Music” template.

One Kali trap : if apt update fails with Sub-process /usr/bin/sqv returned an error code, the repository signing key has expired. Refetch it and update again:

wget https://archive.kali.org/archive-keyring.gpg -O /usr/share/keyrings/kali-archive-keyring.gpg
sudo apt update

The Model Files: What Goes Where

Everything YuE2 needs lives in the Comfy-Org/YuE2 repository on Hugging Face, repackaged from the original m-a-p weights. The placement is the whole install:

The full folder layout, exactly as the Comfy-Org repository’s README draws it:

ComfyUI/
└── models/
    ├── audio_encoders/
    │   └── sheetsage2_bf16.safetensors
    └── checkpoints/
        └── yue2_3b_int8_convrot.safetensors

One documented nicety if you already keep model files elsewhere: ComfyUI reads additional model locations from extra_model_paths.yaml — in the standalone Windows build the template file ships in the ComfyUI directory; rename it and edit it to point at your existing folders, and both UIs can share one model library.

About those two checkpoint variants, since the difference confuses everyone: bf16 is bfloat16 — the compact half-precision format behind the model’s own published measurements; int8 is an even smaller 8-bit format, which is why that file is roughly half the size. Both come from Comfy-Org; the int8 file is the default; and beyond the file sizes, no separate performance or VRAM numbers exist for the two — so treat the int8 as the documented default, not as a measured “better.” What neither file is: a GGUF. That distinction matters more than you’d think, and the FAQ covers it.

Your First Song: The Text to Music Workflow

The workflow ships inside ComfyUI: open the Template Library and search “YuE2: Text to Music,” or download the JSON from the official tutorial page. The steps, in order:

1. Write a description of the music you want in Style.
2. Enter your song lyrics in Lyrics, using section tags such as [Verse] and [Chorus].
3. Choose a planning Mode: full generates melody and chords, melody generates the melody only.
4. Set the Max Duration of the song.
5. Queue the workflow to generate.

The craft is in the two text fields, and the rules for what belongs in each are unusually specific. Style takes the musical characteristics — genre (pop, jazz, rock, electronic, folk), vocals (warm female vocal, expressive male vocal, soft vocals), language, tempo (90 BPM, slow, upbeat), and instruments (piano, electric guitar, bass, drums, synths). A working example, worth copying as a starting point:

English, warm female vocal, contemporary pop, 96 BPM, piano, rounded electric bass, restrained drums, clear diction

Lyrics takes the words meant to be sung, structured with section tags — [Verse], [Chorus], [Bridge], [Outro] — and nothing else. A working example:

[Verse]
Morning light across the window you are good
City waking down below
[Chorus]
Run with me into the sunlight
Leave the shadows far behind because I'm good😅

The rule is flat: keep musical instructions in Style, not in the lyrics. “Slow it down here” belongs in the style box’s vocabulary, not shouted at the singer mid-verse. The model generates full song structures — intro, verse, chorus, bridge, outro — with vocals and instrumental accompaniment at 48 kHz stereo, in English, Chinese, and Japanese, with “and more” allowed in the style guidance.

Modes, Max Duration, and Editing the Score

What separates YuE2 from one-shot audio generators is the planning step. Before generating audio, YuE2 writes a symbolic music plan in ABC notation — sheet music as plain text, note letters and rhythm marks — a melody, optionally with chords, that you can inspect and edit. The Mode option controls it:

• full — creates a plan with melody and chords before generating the song. The recommended mode for general text-to-music.
• melody — creates a melody-only plan and lets the accompaniment be generated more freely.
• Leaving the abc input empty disables planning entirely and generates music directly from Style and Lyrics.

That editable score is the feature to actually use, not just admire: generate once, read the plan, change the one chord that’s wrong, and queue again. Results become steerable in a way one-shot generation never is.

Max Duration is the other number worth understanding before your first surprise. It sets the maximum song length in seconds, up to 900 — fifteen minutes, which is a lot of chorus for one evening. Two behaviors keep it honest: the song may finish earlier depending on the generated musical structure and lyrics, and for long prompts ComfyUI automatically reduces the token budget so generation still fits the model’s context. A token is one small piece of output the model writes at a time; the budget caps how many pieces it may write.

Covers with SheetSage2

The second workflow in the Template Library — search “YuE2: Music Cover” — reimagines an existing recording in a new style. It needs both model files (the YuE2 checkpoint plus the SheetSage2 encoder in models/audio_encoders/), and the steps are four: load a reference song in Audio, describe the new musical direction in Style, enter the lyrics you want sung in Lyrics, and queue. An example reference file, yue2_reference_song.flac, ships with the workflow for the matching LoadAudio node.

The part worth internalizing is what the workflow does not do: it does not feed your reference audio to YuE2 directly. The chain is:

Reference Audio
    ↓
SheetSage2 (transcription)
    ↓
Melody ABC score
    ↓
YuE2 (generation with new Style and Lyrics)

The melody is the connection to the original song — everything else is new. That leads to the one piece of craft advice for covers: they work best when the new lyrics stay reasonably close to the original phrasing and syllable count. Write a lyric sheet the melody can actually hold. A working cover style:

English, soulful jazz-pop, expressive male vocal, relaxed 88 BPM, Rhodes piano, upright bass, brushed drums, warm saxophone, intimate late-night atmosphere

Denny’s plan for the band’s demo, for the record: their roughest original as the reference, a tighter style prompt, new lyrics with the same syllable counts, and the 4090 under the shop counter for the heavy lifting. “The drummer doesn’t have to touch anything scarier than a volume slider,” Denny said, which the drummer confirmed was the entire point.

ComfyUI or the Python Wheel? An Honest Comparison

Both routes run the same underlying model, from the same original weights, under the same license. The differences are all around the model:

Ethan’s opinion, in his own voice: “The node graph is the right interface for this particular model, because the plan and the audio are two visible branches — you can see where the score gets written and where it becomes sound. But if nobody’s watching the canvas and you just need songs out of a queue, the wheel route is the factory. Pick by what you’re doing, not by which install scared you less.”

When It Breaks: the Honest Failure Modes

The failure modes below come straight from the guide and the repository, causes named rather than symptoms:

And the when-nothing-works paragraph, because you’ll need it at the end of a bad evening: if your card is under the model card’s 24 GB envelope, no template combination fixes physics — the honest move is a bigger card like the 4090 under the counter, a cloud GPU, or patience. If the workflow simply isn’t there, you’re on an old ComfyUI — update and look again before you reinstall anything. If Kali’s driver stack has fallen over after an update, it’s headers, and kali.org’s troubleshooting page is the reference. What we cannot tell you is which of these your machine will hit, because nobody in this chain ran any of it — every fix above is the vendor’s fix, quoted, not a war story.

Frequently Asked Questions

Is YuE2 officially supported in ComfyUI?

Yes — natively. ComfyUI’s repository lists YuE2 among its natively supported audio generation models, the official tutorial lives in ComfyUI’s own documentation, and Comfy-Org republished the model files in a dedicated Hugging Face repository. This is not a community custom node.

Which ComfyUI version do I need for YuE2?

v0.35.0 or later is required, and v0.35.1 or later is recommended on AMD GPUs — that’s the official requirement. ComfyUI releases weekly, so updating an older install is the first step of any fix.

What GPU do I need to run YuE2 in ComfyUI?

A dedicated NVIDIA or AMD GPU is recommended for the desktop app, not required. The model’s own requirement is a 24 GB NVIDIA GPU with BF16 support — the authors’ peaks are 11.18 GiB in normal use and 14.08 GiB worst-case. No ComfyUI-specific VRAM figure has been published.

How much disk space does YuE2 need in ComfyUI?

About 9 GB for a text-to-song setup: 4.85 GB or more for the ComfyUI desktop install, plus the 3.96 GB int8 checkpoint. Add roughly 1.39 GB more for the SheetSage2 encoder if you want covers, or 7.8 GB instead of 3.96 if you choose the bf16 checkpoint.

What's the difference between the bf16 and int8 checkpoints?

bf16 is the half-precision number format behind the model’s own published measurements; int8 is a smaller 8-bit format, which is why that file is roughly half the size (3.96 GB vs 7.8 GB). The int8 file is the default download. Beyond the file sizes, no separate performance or VRAM numbers exist for the two variants.

Can I run YuE2 in ComfyUI through Ollama, GGUF, or llama.cpp?

No. Comfy-Org publishes YuE2 as safetensors files — an int8 variant and a bf16 variant — and neither is a GGUF. Ollama and llama.cpp run single-file text models in their own format; YuE2 is a multi-stage music pipeline (score planning, then audio generation with a separate decoder), which is not the kind of model those runners load. The int8 checkpoint is the closest thing to a “smaller download,” and it is not GGUF.

Is YuE2 a Llama-family model?

No. Its backbone is an AR–NAR Mixture-of-Transformers design that writes a symbolic score first, then generates audio through flow matching and a separate VAE decoder — a music pipeline, not a text LLM. That is exactly why the LLM world’s usual tooling (Ollama, llama.cpp, Unsloth-style fine-tuning) does not apply to it.

Does YuE2 work natively on Windows 11 through ComfyUI?

Yes. The Comfy Desktop app for Windows is the documented, recommended install — no WSL and no Python environment to manage. The model card’s Linux-first quick start applies to the command-line route, not this one.

Can I run ComfyUI with YuE2 on Kali Linux?

Yes, via the manual route. The ComfyUI desktop app for Linux targets Ubuntu 22.04+, so on Kali you install from source: the kali.org NVIDIA driver steps first, then a Python 3.13 virtual environment, ComfyUI via comfy-cli or a repository clone with the cu130 PyTorch stack, then the model files in their folders.

How long can a YuE2 song be in ComfyUI?

Max Duration goes up to 900 seconds — fifteen minutes. The song may finish earlier depending on the generated structure and lyrics, and for long prompts ComfyUI automatically reduces the token budget so generation still fits the model’s context.

Which languages can YuE2 sing?

English, Chinese, and Japanese, with “and more” allowed in the style guidance. The original model repository lists English and Chinese, and the authors’ demos include a Mandarin track.

How do I make a cover of an existing song in ComfyUI?

Load the “YuE2: Music Cover” workflow from the Template Library, put the SheetSage2 encoder in models/audio_encoders/, load your reference song into the Audio input, then write the new Style and Lyrics and queue. SheetSage2 transcribes the melody into an ABC score and YuE2 re-sings it; keep the new lyrics close to the original phrasing and syllable count.

Can I edit the song before the audio is generated?

Yes — that is YuE2’s signature feature. In full or melody mode it first writes a symbolic plan in ABC notation — a melody, optionally with chords, that you can inspect and edit — and the final song is rendered from that plan. Leaving the abc input empty disables planning.

Can I sell songs I make with YuE2 in ComfyUI?

No. The Comfy-Org/YuE2 repository carries the same CC BY-NC 4.0 license as the original weights — attribution, non-commercial. Sharing and remixing are fine; selling the songs or using them to sell something is not.

Why did my song come out shorter than the Max Duration?

Because the song may finish earlier depending on the generated musical structure and lyrics — expected behavior, not a failure. If you need a longer song, more lyrics and sections are the lever — the structure grows from what there is to sing.

Should I use ComfyUI or the Python package from the model card?

Use ComfyUI if you want a visual interface, a native Windows install, and ready-made workflows — it is the documented easy route. Use the Python wheel if you are automating, batching, or serving many users — its vLLM runtime is measured at 373 songs per hour at concurrency 32, which the ComfyUI route does not replace.

Related guides on this site

Revision note. Written September 2026. ComfyUI releases weekly and the model repository is a week old, so file sizes and version numbers on this page might vary when you check,. If you’ve spent the evening between a missing workflow and a driver that won’t load, take heart: it’s almost always one update and one folder, and the queue button is one click past that.