I'm the sole founder of TeamAudiyo. I build Audiyo, a small Python library that runs Stable Audio Open and MiniMax-Music3 on small GPUs — with seeded output, memory presets, and LoRA fine-tuning for both backends.
This blog collects our announcements and guides: release notes, VRAM benchmarks, memory presets, and fine-tuning recipes. Everything is tested on real consumer hardware.
Audiyo is open source under Apache 2.0. Install it from PyPI or star it on GitHub.
If you want to get in touch about Audiyo or just to say hi, reach out on GitHub or Hugging Face.
Welcome to the TeamAudiyo blog. This is where we'll post announcements, guides, and notes on building audio AI — starting with a proper hello.
Audiyo is a small Python library that runs Stable Audio Open on as little as 8GB of RAM, with seeded output, memory presets, and a LoRA fine-tuning path. Install it and say your first hello:
pip install audiyo torchsde
from audiyo import AudioModel
model = AudioModel.from_pretrained(
"stabilityai/stable-audio-open-1.0",
device="auto",
memory_mode="balanced",
)
result = model.generate(
prompt="Rain against a window with distant thunder",
duration_seconds=10,
seed=42,
)
result.save("rain.wav")That's it — one install, ten seconds of rain. More guides, releases, and benchmarks are on the way. See you in the next post.
Two fix releases in two days, both about the same thing: quantization flags tripping up the Music3 loader. Straight from the GitHub release notes.
0.3.3 (Sep 17): the loader no longer sends quantization flags to the pipeline itself, which rejected them. Quantization now applies to the language model on its own after loading. It also ships the GGUF smoke-test script under scripts/.
0.3.4 (Sep 18, latest): quantized music loads use a proper quantization config object on current transformers instead of a bare flag that newer versions reject.
pip install -U audiyoYesterday was 0.3.1. Today is the fix release: the earlier build did not load the GGUFS correctly, so 0.3.2 reworks how Music3 models load and get called. Three changes, all verified.
Repo rename. We were still pointing at the old id in code, README, and docs. Everything now uses TeamAudiyo/Minimax-Music3-GGUF — config, backend dispatcher, estimator, tests, README, backend docs. Same six quant files (q3_k_m through f16), no trace of the old id, no alias kept:
model = AudioModel.from_pretrained(
"TeamAudiyo/Minimax-Music3-GGUF",
memory_mode="balanced",
)GGUF component loading. GGUF splits sometimes ship without the tokenizer, language model, or depth decoder — the exact thing that broke generation. After the pipeline loads, the new loader checks all three and pulls anything missing from the matching subfolder in MiniMaxAI/MiniMax-Music3, carrying your 8-bit/4-bit choice over to the language model. Filled pieces are recorded on the pipe, and if a piece can't load it fails naming the exact piece instead of generating wrong audio.
Call args per backend. This was the warnings fix. Stable Audio keeps its full call (timing window, guidance, negative prompt), while Music3 gets exactly what its blocks accept — prompt, lyrics, duration, steps, seed. Lyrics are now required for music with a clear error, clips always start at zero, one clip per call (use seeds for more takes), and the music duration cap is fixed to 360 seconds instead of the wrong 47. Every result records its backend and call args in settings.
Proof: 120 passed, 2 skipped, plus 8 new tests covering fallbacks, failure naming, call shapes, and an end-to-end music generate. Shipped as tag v0.3.2. Verify a CUDA box yourself:
python scripts/test_minimax_music3_gguf.py --duration 20 --seed 42
# needs: CUDA GPU, diffusers>=0.40, huggingface-cli loginFresh out today: Audiyo 0.3.1 keeps the same solid base and adds easier generation controls, quick quality checks, and a simple local web demo. Update once:
pip install -U audiyoNew since 0.2.1: score any clip with audiyo quality, A/B two renders with audiyo compare, batch-listen a folder into a CSV sheet, estimate VRAM before you commit with audiyo estimate — and try three seeds in one command:
audiyo generate "Rain on a roof" --seeds 1,2,3 -o rain.wav
audiyo quality rain.wav
audiyo compare before.wav after.wav
audiyo ui # local web demoExtras now cover lora, train, bench, test, ui, and all — install only what you need. Full notes live in the repo docs under docs/quality.md and docs/ui.md.
Since 0.2.1, Audiyo runs a second backend: MiniMax-Music3 via the TeamAudiyo/Minimax-Music3-GGUF checkpoint. Lyrics follow the MiniMax tag format — section tags alone on their own line — and songs run up to about six minutes:
from audiyo import AudioModel
model = AudioModel.from_pretrained(
"TeamAudiyo/Minimax-Music3-GGUF",
memory_mode="balanced",
)
result = model.generate(
prompt="upbeat synth-pop, bright analog arps",
lyrics="[verse]\nMorning light\n[chorus]\nWe run the night",
duration_seconds=30,
seed=42,
)
result.save("song.wav")Why it fits small GPUs: the 8B LLM, DiT, and vocoder swap in and out of VRAM sequentially, so a 6GB card handles the default q4_k_m quant (1.49 GB). Need more fidelity? Step up to q8_0 or f16 — same call.
Prefer notebooks? This Colab recipe installs everything, loads the GGUF Music3 checkpoint with int8 CPU offload for the language model, synthesizes 15 seconds, and saves the result for preview:
!pip install audiyo torchsde
!pip install -U "diffusers>=0.40" bitsandbytes
import torch
import gc
from audiyo import AudioModel
import IPython.display as ipd
# Optimize CUDA memory state
gc.collect()
torch.cuda.empty_cache()
print("Step 1: Loading model 'TeamAudiyo/Minimax-Music3-GGUF'...")
try:
# Pass the required parameters inside model_kwargs to configure the inner quantized engine safely
model = AudioModel.from_pretrained(
"TeamAudiyo/Minimax-Music3-GGUF",
model_kwargs={
"device_map": "auto",
"llm_int8_enable_fp32_cpu_offload": True
}
)
print("\nStep 2: Model successfully loaded! Preparing sound synthesis...")
result = model.generate(
prompt="upbeat synth-pop, bright analog arps",
lyrics="[verse]\nMorning light\n[chorus]\nWe run the night",
duration_seconds=15,
seed=42,
)
print("\nStep 3: Synthesis finished! Saving audio waveform to 'song.wav'...")
result.save("song.wav")
print("Step 4: Waveform saved! Rendering audio preview below:")
except Exception as e:
print(f"\nAn error occurred during execution: {e}")Two cells, one song. The model_kwargs pass-through keeps the quantized engine happy — no stray flags, matching the 0.3.3+ loader behavior. Swap the prompt and lyrics for your own track.
Stock Diffusers needs ~13.8 GB of VRAM for 10 seconds of stereo. Audiyo's presets trade speed for memory with offloading and tiling — measured on a Tesla T4:
# peak VRAM, 10s stereo, T4 / bfloat16
vanilla diffusers ~13.80 GB
performance 12.10 GB # RTX 3090, A100
balanced 5.86 GB # default: 3060, 4060, T4
low 4.20 GB # GTX 1080, 2060
minimal 3.10 GB # legacy 4GB cardsStart on balanced and step down only if you hit out-of-memory. Preview the cost up front, then verify after a run:
audiyo estimate --memory-mode balanced
audiyo benchmark --duration 10 --steps 20Lower presets are slower but bit-identical in output. Pick the fastest preset that fits your card — for most 8GB GPUs, that's balanced.