---
title: "YuE2-GGUF"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/5c031f13-7ab7-4b31-9032-8dd7c7e51b9e"
updated: "2026-11-13"
---

# YuE2-GGUF

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Pre-quantized GGUF files for yue2.cpp, a C++ song generator that turns style tags and lyrics into stereo audio plus the score it composed. For musicians and tinkerers who want to run it on their own computer.

YuE2-GGUF is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Serveurperso

## About

### What it is

YuE2-GGUF holds pre-quantized GGUF files for yue2.cpp, a portable C++17 version of the YuE2 song generator built on GGML. You give it style tags and lyrics. The result is a stereo track at 48 kHz, and you also get the ABC score that the model wrote while composing. It runs on CPU, CUDA and Vulkan.

### Who it suits

Songwriters and hobbyists who want to generate music on their own machine, plus developers and researchers who want a local song model with a web interface and command line tools.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Music | Songwriters | Turn style tags and lyrics into a demo track | A short song built from their own lyrics |
| Self-hosting | Tinkerers with a spare GPU | Run song generation locally through the built-in web interface | Start the server and write prompts in a browser |
| Music research | People studying generated music | Inspect the ABC score before the audio is rendered | Run the planning step alone and read the score |

You can skip it if you need commercial use, since the license is non-commercial, or if you want a ready-made app with no building.

### Where to use it

- A computer with a C++ toolchain and CMake, using a CPU, CUDA or Vulkan
- A web browser, for the interface the server provides
- A terminal, for the command line tools

| Use case | Who | What they get back |
| --- | --- | --- |
| Generate a song | Songwriters | An audio track from style tags and lyrics |
| Read the composed score | Musicians | The ABC score the model wrote |
| Render from a recording | Cover makers | A cover path that turns a recording into a melody first, using the optional transcriber |

### How to set it up

You build yue2.cpp from source, then download the model files with the script it ships. The default script fetches the Q8\_0 set, about 5.4 GB.

- Git, CMake and a C++17 compiler
- Python and pip, for the hf tool
- A GPU for CUDA, or use CPU or Vulkan

1. Clone the yue2.cpp repository with its submodules.
2. Install hf and run the model download script.
3. Build the project with CMake.

```bash
cd yue2.cpp

pip install hf
./models.sh           # downloads the Q8_0 set (~5.4 GB)

mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j$(nproc)
cd ..
```

To fetch the repository files yourself, Hugging Face gives these steps:

```sh
pip install -U huggingface_hub
hf download Serveurperso/YuE2-GGUF
```

### How to use it

Start the server, then open its web interface in your browser on port 8087. In that interface you type tags and lyrics, press generate, check the score, then listen to or save the tracks.

```bash
./build/yue-server --host 0.0.0.0 --port 8087 \
    --model models/YuE2-3B-Q8_0.gguf \
    --vae models/YuE2-Vae-F32.gguf
```

The command line tools read one request file that holds the style, lyrics and seeds.

```bash
# full pipeline: score, semantic codes, flow matching, VAE
./build/yue-synth \
    --model models/YuE2-3B-Q8_0.gguf \
    --vae models/YuE2-Vae-F32.gguf \
    --request request.json \
    --out song.mp3

# symbolic stage alone: the ABC score the model intends to play
./build/yue-plan \
    --model models/YuE2-3B-Q8_0.gguf \
    --request request.json \
    --out score.abc
```

| Tool | What it does |
| --- | --- |
| yue-server | Serves the web interface for writing, generating and playing tracks |
| yue-synth | Runs the full pipeline and writes an mp3 file |
| yue-plan | Writes only the ABC score |
| models.sh | Downloads the Q8\_0 model set |

### Example

In the web interface you enter a few style tags such as "mellow piano, slow tempo" and a couple of lines of lyrics. You press generate. A song comes back as stereo audio, and the interface shows the ABC score the model wrote for it.

### For newcomers and experts

If you are new, build the project, start the server and make one short song from a few tags. Everything you need is on that single page.

For experts, one backbone file holds two transformers that share attention. The first half writes the score and then semantic codes. The second half renders them by flow matching, and a VAE decodes the audio. Q8\_0 is near lossless. There is no Q4 file, because the author says an audio code model breaks below Q5.

Style tags and lyrics → Autoregressive half writes the score and codes → Non-autoregressive half paints the audio → VAE decodes to 48 kHz stereo

### Good to know

Backbone file size by quant in GB

| Label | Value |
| --- | --- |
| BF16 | 7.17 GB |
| Q8\_0 | 3.81 GB |
| Q6\_K | 2.94 GB |
| Q5\_K\_M | 2.62 GB |

- Optional parts: a transcriber and an audio tokenizer exist for the cover path, and neither is required
- VAE: kept in F32 and never quantized
- License: CC BY-NC 4.0, so it is for non-commercial use
- Cost to run: no API key or paid service named, but it needs a computer that can build and run C++ code
- Data it reaches: downloads model files, and the server listens on a port on your machine
- Not for: commercial use, since the license is non-commercial

## README

````markdown
# YuE2-GGUF

Pre-quantized GGUF files for yue2.cpp, a C++ song generator that turns style tags and lyrics into stereo audio plus the score it composed. For musicians and tinkerers who want to run it on their own computer.

Made by Serveurperso on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: YuE2-GGUF holds pre-quantized GGUF files for yue2.cpp, a portable C++17 version of the YuE2 song generator built on GGML. You give it style tags and lyrics. The result is a stereo track at 48 kHz, and you also get the ABC score that the model wrote while composing. It runs on CPU, CUDA and Vulkan.

Who it suits: Songwriters and hobbyists who want to generate music on their own machine, plus developers and researchers who want a local song model with a web interface and command line tools.

```table
Industry | Who uses it | How they use it | Example
Music | Songwriters | Turn style tags and lyrics into a demo track | A short song built from their own lyrics
Self-hosting | Tinkerers with a spare GPU | Run song generation locally through the built-in web interface | Start the server and write prompts in a browser
Music research | People studying generated music | Inspect the ABC score before the audio is rendered | Run the planning step alone and read the score
```

You can skip it if you need commercial use, since the license is non-commercial, or if you want a ready-made app with no building.

Where to use it:

- A computer with a C++ toolchain and CMake, using a CPU, CUDA or Vulkan
- A web browser, for the interface the server provides
- A terminal, for the command line tools

```table
Use case | Who | What they get back
Generate a song | Songwriters | An audio track from style tags and lyrics
Read the composed score | Musicians | The ABC score the model wrote
Render from a recording | Cover makers | A cover path that turns a recording into a melody first, using the optional transcriber
```

How to set it up: You build yue2.cpp from source, then download the model files with the script it ships. The default script fetches the Q8_0 set, about 5.4 GB.

- Git, CMake and a C++17 compiler
- Python and pip, for the hf tool
- A GPU for CUDA, or use CPU or Vulkan

1. Clone the yue2.cpp repository with its submodules.
2. Install hf and run the model download script.
3. Build the project with CMake.

```bash
cd yue2.cpp

pip install hf
./models.sh           # downloads the Q8_0 set (~5.4 GB)

mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j$(nproc)
cd ..
```

To fetch the repository files yourself, Hugging Face gives these steps:

```sh
pip install -U huggingface_hub
hf download Serveurperso/YuE2-GGUF
```

How to use it: Start the server, then open its web interface in your browser on port 8087. In that interface you type tags and lyrics, press generate, check the score, then listen to or save the tracks.

```bash
./build/yue-server --host 0.0.0.0 --port 8087 \
    --model models/YuE2-3B-Q8_0.gguf \
    --vae models/YuE2-Vae-F32.gguf
```

The command line tools read one request file that holds the style, lyrics and seeds.

```bash
# full pipeline: score, semantic codes, flow matching, VAE
./build/yue-synth \
    --model models/YuE2-3B-Q8_0.gguf \
    --vae models/YuE2-Vae-F32.gguf \
    --request request.json \
    --out song.mp3

# symbolic stage alone: the ABC score the model intends to play
./build/yue-plan \
    --model models/YuE2-3B-Q8_0.gguf \
    --request request.json \
    --out score.abc
```

```table
Tool | What it does
yue-server | Serves the web interface for writing, generating and playing tracks
yue-synth | Runs the full pipeline and writes an mp3 file
yue-plan | Writes only the ABC score
models.sh | Downloads the Q8_0 model set
```

Example: In the web interface you enter a few style tags such as "mellow piano, slow tempo" and a couple of lines of lyrics. You press generate. A song comes back as stereo audio, and the interface shows the ABC score the model wrote for it.

For newcomers and experts: If you are new, build the project, start the server and make one short song from a few tags. Everything you need is on that single page.

For experts, one backbone file holds two transformers that share attention. The first half writes the score and then semantic codes. The second half renders them by flow matching, and a VAE decodes the audio. Q8_0 is near lossless. There is no Q4 file, because the author says an audio code model breaks below Q5.

```flow
Style tags and lyrics
Autoregressive half writes the score and codes
Non-autoregressive half paints the audio
VAE decodes to 48 kHz stereo
```

Good to know:

```chart
Title: Backbone file size by quant in GB
BF16: 7.17 GB
Q8_0: 3.81 GB
Q6_K: 2.94 GB
Q5_K_M: 2.62 GB
```

- Optional parts: a transcriber and an audio tokenizer exist for the cover path, and neither is required
- VAE: kept in F32 and never quantized
- License: CC BY-NC 4.0, so it is for non-commercial use
- Cost to run: no API key or paid service named, but it needs a computer that can build and run C++ code
- Data it reaches: downloads model files, and the server listens on a port on your machine
- Not for: commercial use, since the license is non-commercial

## On Hugging Face, 13 November 2026

- Parameters: 632M
- Weights: about 316 MB at 4-bit (estimate)
- Formats: GGUF
- Downloads in the last 30 days: 8,466,401
- Likes: 31
- License: cc-by-nc-4.0
- Languages: en, zh, ja, ko, fr, es
- Based on: m-a-p/YuE2-3B
- Tags: gguf, music-generation, text-to-music, ggml, yue2, flow-matching, abc-notation

## Links

- Model: https://huggingface.co/Serveurperso/YuE2-GGUF
- Files: https://huggingface.co/Serveurperso/YuE2-GGUF/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download Serveurperso/YuE2-GGUF
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[Serveurperso/YuE2-GGUF on Hugging Face](https://huggingface.co/Serveurperso/YuE2-GGUF)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| YuE2-GGUF (this page) | 8,466,401 | 31 | 632M | cc-by-nc-4.0 | 2026-10-08 |
| [MLTNT Militant Roots Reggae LoRAs for YuE2](https://mindket.com/p/b881a3fd-b27c-46ee-a4e4-f0e0bd2a5823) | 0 | 27 | — | cc-by-nc-4.0 | 2026-11-03 |
| [YuE2-3B](https://mindket.com/p/4a5fb8f5-8740-4c8f-a836-2f8f79f6674a) | 22,317 | 1,253 | 3.6B | cc-by-nc-4.0 | 2026-10-06 |
| [YuE2 Particle Sliders v2](https://mindket.com/p/a551e1dc-17a6-4f37-9f89-48b9b885ba4c) | 0 | 22 | — | cc-by-nc-4.0 | 2026-10-07 |
| [YuE2-3B-instrumental-kto-lora](https://mindket.com/p/61380567-1b45-4008-873d-acd71a4eec60) | 0 | 7 | — | cc-by-nc-4.0 | 2026-11-08 |
| [Qwen3-TTS GGUF](https://mindket.com/p/ab5107b1-bdce-42f1-b3e2-abd1bae80d7c) | 1,347,066 | 67 | 915M | apache-2.0 | 2026-09-09 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-08
- First published: 2026-09-12
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Serveurperso/YuE2-GGUF on Hugging Face](https://huggingface.co/Serveurperso/YuE2-GGUF)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/5c031f13-7ab7-4b31-9032-8dd7c7e51b9e)
- [Its page on Mindket](https://mindket.com/p/5c031f13-7ab7-4b31-9032-8dd7c7e51b9e)
