Overview

MiniMax-Music3 generates complete songs up to five minutes long from lyrics and detailed music descriptions, producing 32 kHz, 16-bit stereo WAV audio. Built by MiniMaxAI, the model combines an 8B Global LLM for long-range musical structure, a 0.6B Local LLM for frame-level acoustic detail, and a continuous hidden-state synthesis system using Flow Matching and Flow-VAE (2.4B and 123M respectively). The architecture processes music through eight layers of Residual Vector Quantization, with a semantic codebook of 16,384 entries and seven acoustic codebooks of 1,024 entries each. The Global LLM is initialized from Qwen3-8B and adapted during training to semantic music tokens. Inference requires CUDA and uses sglang-omni as the primary inference framework, with support for diffusers and ComfyUI pipelines. The most critical constraint before evaluating this model is that it requires 24GB+ VRAM for full precision inference, though CPU offloading can reduce this to 8GB with slower generation speed.

Best use cases

Long-form song composition with structural coherence. This model excels at generating complete tracks with intro, verse, pre-chorus, chorus, bridge, and outro sections that maintain consistent themes and vocal identity across five-minute spans. Unlike models that generate isolated clips, MiniMax-Music3 understands how songs evolve over time, making it suitable for producing finished compositions for independent musicians, small labels, or content creators who need full-length tracks without stitching multiple short generations together.

Lyric-driven music generation with semantic control. The model accepts explicit section tags like [Verse], [Chorus], and [Bridge] alongside lyrics, allowing precise structural planning while the music description controls style, emotional progression, and arrangement. This dual-input approach fits workflows where lyricists or songwriters have content they want set to music with specific instrumentation and vocal characteristics, rather than generating both lyrics and music from scratch.

Vocal-centric arrangements with expressive performance. The continuous hidden-state synthesis path preserves vocal articulation, timbre variation, and harmony details that discrete token-only approaches lose. This makes it particularly strong for intimate acoustic arrangements, vocal layering with harmonies, and expressive vocal performances that require subtle dynamic control rather than quantized acoustic representation.

Styled music generation with detailed arrangement specification. The model accepts structured captions covering Global Metadata (genre, BPM, key, emotional progression), Vocal Details (gender, timbre, performance style, effects), and Arrangement (instrument evolution across sections). This level of control suits projects requiring consistent sonic branding or specific production profiles, such as branded content, game soundtracks with defined sonic characteristics, or podcast intro/outro music with precise instrumentation requirements.

Reproducible generation with semantic seed control. The model supports seeding for deterministic output and maintains consistency when regenerating with the same lyrics and music description, making it suitable for iterative creative workflows where a director or producer needs to refine generated output while keeping structural elements consistent across variants.

Limitations

Inference requires CUDA hardware. The model does not support CPU-only inference, eliminating deployment options for serverless architectures, mobile devices, or edge hardware without NVIDIA GPUs. This constraint substantially increases deployment complexity and cost compared to CPU-compatible models.

No streaming generation support. Only non-streaming generation is currently available, meaning the model generates complete audio files without the ability to stream output in real time or interrupt generation early. This creates poor user experience for interactive applications and prevents progressive audio delivery to end users.

Moderate VRAM requirements. Full precision requires 24GB+ VRAM. With automatic CPU offloading, generation takes approximately 22GB; streaming the language model layer by layer enables 8GB fitting but with substantially slower generation speed. This eliminates GPU options below 24GB unless users accept significant latency penalties.

Text prompt tokenization limit of 5,000 tokens. The combined lyrics and music description must fit within 5,000 tokens, constraining the complexity and length of music descriptions and preventing extremely detailed specification or very long lyric sets in single generation requests.

Audio generation limited to 9,000 acoustic frames. At 25 frames per second, this translates to a theoretical maximum of 360 seconds (six minutes) of audio, though the documentation states five-minute generation. Generating extended compositions requires splitting into multiple segments or accepting practical limits below the stated five-minute maximum.

Section tags and specifications provide influence, not guarantees. Requested tempo, key, instrumentation, lyrics, and song structure may not always match the music description exactly. The model outputs probabilistic approximations rather than symbolic guarantees, meaning generated output sometimes deviates from specified constraints, particularly for less common genre or instrumentation combinations.

Limited handling of non-English lyrics. Documentation examples use English lyrics exclusively, and the model's linguistic grounding through Qwen3-8B initialization may perform inconsistently on languages with different phonetic or tonal characteristics.

No fine-tuning support documented. The README does not describe fine-tuning procedures or whether adapting the model to custom vocal styles, genres, or domains is feasible, limiting customization beyond prompt engineering.

How it compares

  • MiniMax Music 2.5generates complete tracks with singing and backing music from lyrics and style descriptions. Choose- MiniMax-Music3for longer generation (five minutes vs shorter bounds on v2.5), superior long-range structural coherence, and more granular vocal and arrangement control through structured captions. Choose Music 2.5 if you need faster inference or have lower VRAM availability, as the earlier version uses smaller model components.

  • Music-1.5generates full-length songs up to four minutes with natural vocals and rich instrumentation. Choose- MiniMax-Music3for slightly longer generation (five minutes vs four), superior section-level coherence through explicit lyric tagging, and more detailed arrangement control via structured captions with Global Metadata, Vocal Details, and Arrangement specifications. Music-1.5 may offer faster inference as an earlier model iteration, though exact speed comparisons are not documented.

  • MiniMax Music 2.0generates music from text prompts using earlier MiniMax architecture. Choose- MiniMax-Music3for substantially longer generation capacity (five minutes vs undocumented limits on v2.0), better handling of long-form structure through hybrid-LM architecture separating global and local musical modeling, and more precise control through lyric section tags and structured captions. v2.0 may be viable only if you require deployment with minimal VRAM and accept shorter output lengths.

  • Minimax-Music (original)is the first-generation MiniMax Music model generating music from text prompts. Choose- MiniMax-Music3for substantially improved long-form coherence, longer generation (five minutes vs shorter undocumented limits), superior vocal expression through continuous hidden-state synthesis, and much better structured control through explicit lyric tagging and detailed arrangement specification. The original is primarily relevant for legacy deployments or when extreme resource constraints require the smallest available model.

Technical specifications

Architecture and components:

  • Global LLM: 8B parameters, initialized from Qwen3-8B and adapted for semantic music tokens
  • Local LLM: 0.6B parameters for frame-level acoustic codebook prediction
  • Flow Matching module: 2.4B parameters
  • Flow-VAE Decoder: 123M parameters
  • Music Tokenizer: Eight-layer Residual Vector Quantization with semantic codebook of 16,384 entries and seven acoustic codebooks of 1,024 entries each
  • Hybrid-LM architecture separating global musical modeling (first RVQ codebook) from local acoustic modeling (remaining codebooks)
  • Continuous hidden-state synthesis fusing Global and Local LLM final hidden states instead of discrete token decoding

Audio specifications:

  • Output format: 32 kHz, 16-bit stereo WAV
  • Maximum output duration: 5 minutes (9,000 acoustic frames at 25 frames per second)
  • Frame rate: 25 frames per second

Input constraints:

  • Lyric section tags supported: [Intro],[Verse],[Pre-Chorus],[Chorus],[Post-Chorus],[Bridge],[Instrumental],[Solo],[Outro]
  • Maximum tokenized text prompt: 5,000 tokens (combined lyrics and music description)
  • Music description accepts structured captions with Global Metadata (genre, subgenre, BPM, key, scale, emotional progression, listening scenario, production profile), Vocal Details (gender, timbre, performance style, harmony, backing vocals, effects), and Arrangement (instruments, section-level evolution, groove, bass, percussion, textures, spatial effects)

Hardware and inference:

  • Minimum VRAM: 24GB for full precision inference; 22GB with automatic CPU offloading; 8GB possible with layer-by-layer streaming but with substantial latency increase
  • Compute requirement: CUDA required (no CPU-only inference)
  • Inference framework support: sglang-omni, diffusers, ComfyUI
  • Model download: Via Hugging Face Hub with hf download MiniMaxAI/MiniMax-Music3

Supported inference frameworks:

  • SGLang with cookbook integration
  • diffusers with ModularPipeline (requires PR commit installation until merge)
  • ComfyUI with official tutorials

Training and model details:

  • Training procedure: Semantic codebook optimized first, then all eight codebooks jointly trained
  • Global LLM initialization: Qwen3-8B base with adapted embedding and output layers
  • Flow-VAE architecture: Adapted from MiniMax Speech and retrained for music dynamic range and spectral characteristics
  • No documented fine-tuning support or procedure

Model inputs and outputs

Inputs

  • Lyrics: Text with optional structural section tags on separate lines (- [Verse],- [Chorus], etc.); combined with music description must not exceed 5,000 tokens
  • Music description: Natural language or structured caption specifying Global Metadata (genre, BPM, key, emotional progression), Vocal Details (gender, timbre, performance style, harmony, effects), and Arrangement (instruments, section-level evolution, production profile)
  • Generation parameters:- max_new_tokens(sets maximum audio frames, default recommended 750),- seed(for reproducible output),- response_format(set to "wav")
  • Optional:- audio_durationparameter (in seconds) for diffusers pipeline

Outputs

  • WAV audio file: 32 kHz, 16-bit stereo WAV format
  • Duration: Variable up to 5 minutes, with generation terminating early if model emits end-of-audio token before reaching- max_new_tokenslimit
  • Sampling rate: 32 kHz
  • Bit depth: 16-bit
  • Channels: Stereo

Getting started

Using SGLang-Omni (simplest approach):

```

Install sglang-omni per official installation guide

sgl-omni serve --model-path MiniMaxAI/MiniMax-Music3 --port 8000

Generate music via curl

curl http://127.0.0.1:8000/v1/audio/speech \
-H 'Content-Type: application/json' \
-d '{
"model": "MiniMaxAI/MiniMax-Music3",
"input": "[Verse]\nMorning light filtering through the pine\n[Chorus]\nSoftly the world begins to breathe",
"instructions": "A warm acoustic pop song with intimate female vocals, fingerpicked guitar, soft piano, and a gradual emotional build into a wide final chorus.",
"response_format": "wav",
"seed": 7,
"max_new_tokens": 750,
"stream": false
}' \
--output minimax_music3.wav
```

Using diffusers pipeline (for direct Python integration):

```
import soundfile as sf
import torch
from diffusers import ModularPipeline

Load pipeline with bfloat16 for 24GB+ VRAM

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-Music3")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")
lyrics = """[verse]
Morning light filtering through the pine
Every quiet street is yours and mine
[chorus]
Softly the world begins to breathe"""
prompt = (
"Genre: acoustic pop. BPM: 96. Key: C major. Warm and intimate, building gently into the chorus. "
"Vocals: soft female lead, close and breathy, light stacked harmonies in the chorus. "
"Arrangement: fingerpicked guitar and soft piano; brushed drums and upright bass enter in the chorus."
)
audio = pipe(
prompt=prompt,
lyrics=lyrics,
audio_duration=60.0,
generator=torch.Generator("cuda").manual_seed(7),
output="audios",
)[0]
sf.write("song.wav", audio.T.float().cpu().numpy(), pipe.sampling_rate)
```

For low VRAM environments (8GB with CPU offloading and streaming):

```
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.hooks import apply_group_offloading
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-Music3", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

Layer-by-layer streaming for <8GB fitting (slower)

apply_group_offloading(
pipe.language_model, onload_device=torch.device("cuda"), offload_type="leaf_level", use_stream=True
)
```

Frequently asked questions

Q: What hardware do I need to run this model?

A: You need an NVIDIA GPU with at least 24GB VRAM for full precision inference. With automatic CPU offloading, 22GB is sufficient; with layer-by-layer streaming, 8GB is possible but generation becomes substantially slower due to continuous GPU-CPU transfers.

Q: Can I generate music longer than five minutes?

A: No, the model is limited to 9,000 acoustic frames maximum, which at 25 frames per second equals approximately 360 seconds (six minutes). Practical generation typically caps at five minutes. For longer compositions, split lyrics and descriptions into multiple segments and generate separately.

Q: How do I control the specific instrumentation and arrangement?

A: Use the music description input with a Structured Caption format specifying Global Metadata (genre, BPM, key), Vocal Details (gender, timbre, performance style), and Arrangement (instruments, section-level evolution). The music-caption-rewriter skill expands natural-language descriptions into this structured format automatically.

Q: What's the difference between MiniMax-Music3 and Music-1.5?

A: MiniMax-Music3 generates up to five minutes with superior long-range structure preservation, explicit lyric section tagging, and more detailed arrangement control through structured captions. Music-1.5 caps at four minutes and offers less granular section-level control, though it may inference faster on smaller hardware.

Q: Can I use this model commercially?

A: Check the license at https://huggingface.co/MiniMaxAI/MiniMax-Music3/blob/main/LICENSE. The model itself is available, but usage rights depend on this license file. Commercial deployment of generated audio requires confirming both model license terms and whether any licensing restrictions apply to derivative works.

Q: How accurate is the model at following my specified BPM, key, and instrumentation?

A: The model provides influence over these parameters but not strict guarantees. Generated tempo, key, instrumentation, and song structure may deviate from specifications, particularly for uncommon genres or instrumentation combinations. Section tags and structured captions provide probabilistic guidance rather than symbolic control.

Q: Does the model support languages other than English?

A: The documentation provides only English examples. The Global LLM initialization from Qwen3-8B provides multi-language support, but undocumented performance on non-English lyrics means results may vary significantly depending on phonetic and tonal characteristics of the target language.

Q: What's the difference between inference speed on 24GB vs 8GB VRAM?

A: Full precision on 24GB with automatic CPU offloading (~22GB actual usage) provides baseline inference speed. Layer-by-layer streaming on 8GB requires continuous GPU-CPU data movement and is substantially slower, with exact speedup unavailable in documentation. Only use 8GB mode if 22GB allocation is impossible.

This is a simplified guide to an AI model called MiniMax-Music3 maintained by MiniMaxAI.