MiniMax Music3 Studio

Full-length AI music on your own GPU. One executable — no Python, no Node.js, no launcher.

English · Русский · 中文 · 日本語 · 한국어

A Windows desktop studio for MiniMax Music3. Write a caption and lyrics, generate a full-length track on your own GPU, and keep everything — audio, settings and the exact request that produced it — in a local library.

One executable. No Python, no Node.js, no launcher script, nothing phoning home unless you ask it to.

Given this repository, an agent can set everything up and drive the studio by itself:

1. Install the studio from the latest release and start it.
2. Connect to its MCP server at http://127.0.0.1:8765/mcp: claude mcp add --transport http minimax-studio http://127.0.0.1:8765/mcp
3. Read the skill it serves (resource studio://skill, prompt studio), the same text as docs/mcp-skill.md, and start with the tool studio_status.

llms.txt says the same for tools that look for it. To keep the skill in Claude Code, save docs/mcp-skill.md as ~/.claude/skills/minimax-music3-studio/SKILL.md.

• A player of its own — a ten-band equalizer on Winamp's frequencies with its presets, your own and .EQF files; a MilkDrop visualiser with hundreds of presets or a spectrum in ten looks, over the studio, fullscreen or in its own window; and a Winamp mode that turns the whole window into a skinned Winamp 2 whose windows move apart, dock and resize — the original skin and ten more included, sharp at any scale, the Winamp Skin Museum one click away, Ctrl+M to switch. The song, its place and the equalizer carry over both ways.
• Save as, and a Files panel — songs, stems, MIDI, lyric sheets, scores and videos are saved where you say, in Windows' own Save dialog, and the Files panel shows each save.
• A proxy for the whole studio — HTTP, HTTPS, SOCKS5 or SOCKS4, with a login: model downloads, Hugging Face, OpenRouter and updates go through it.
• Generate music locally with the complete Music3 component set: caption, lyrics, duration, DiT steps, LM CFG and top-k, DiT CFG, peak clip, separate DiT and LM seeds, several songs per prompt and several variations per song, MP3 or 16/24/32-bit WAV.
• Reproduce any track exactly. Every generation stores its request and its audio codes, so a track can be re-rendered deterministically, or re-rendered with different steps, seed or output format.
• Word-level karaoke — enhanced LRC with a timestamp on every word, aligned by Parakeet, Whisper or a cloud model. Your lyrics are kept; only the timing is borrowed.
• Karaoke video written with the bundled ffmpeg, hardware-encoded when the machine can and software-encoded when it cannot.
• A writing assistant for captions and lyrics, from a local GGUF model or OpenRouter, following MiniMax's own published prompting skill. Lyrics you wrote yourself get their section tags with one button, the words exactly as you wrote them.
• Cover art from templates — write the look once with {title}, {style} and {excerpt}, and the track fills the rest in.
• Manage your library — search, playlists, favourites, rename, import your own audio, export tracks, edit audio in the built-in editor.
• Watch what generation costs — live GPU load, VRAM, temperature, power draw, RAM and engine memory, in the sidebar or in a pop-out panel.
• Add cloud capabilities when you want them. Speech-to-text, a caption/lyrics assistant, cover art and cloud music can each independently use OpenRouter, chosen from the live model catalog. Local stays the default.
• Split a finished track into six stems — drums, bass, other, vocals, guitar and piano — with HT-Demucs on the GPU, or on the CPU when you prefer. The model is an optional download like everything else.
• Any track to MIDI — a song, a stem or a processed take becomes multi-instrument MIDI (34 instrument groups and drums) with MuScriptor on the GPU, through HOT-Step's native port. A piano roll fills in while it listens; play it against the original, mute or solo an instrument, save the .mid. Downloaded the first time it is used.
• Every result is a track — stems, a processed take, a re-render and a cover land in the library as tracks of their own, each linked to the one it was made from and keeping the settings it was made with.
• Export files that carry their own data — MP3s are written with ID3v2.4: title, artist, album, genre, tempo, the lyrics and the cover art.
• Choose your own quality/VRAM trade-off in the model manager. Nothing downloads by itself.
• LoRA — LoRA and LoKr for the language model (the composition) and for the DiT (the sound), each with its own strength, picked in the create form. The engine reads PEFT, LyCORIS, diffusers and ComfyUI files. A catalogue of ready ones with their authors credited, and a search on Hugging Face that downloads what you pick.
• Train your own LoRA — an optional tab on the LoRA page: songs of one artist or style become a language-model LoRA on your own card, with HOT-Step's mm3-lm-train and its HOT-PiZZA recipe. Every setting is editable. Datasets move between this studio and YuE2 Studio as a folder, and each saved checkpoint goes into the LoRA library in one click.
  • A three-step wizard — drop a folder of songs, check them, train. Albums with a cue sheet are cut into songs; titles and artists come from the tags, the file name and the folders.
  • Preparation on its own — lyrics come from the lyric databases players use (LRCLIB, QQ Music, Kugou), word for word; only a song none of them knows has its vocals separated and is heard by Whisper, with its usual hallucinations filtered out. The assistant lays the lyrics out in sections. MOSS-Music listens to every song and writes its structured caption, with the tempo and key measured on the card by Beat This! and S-KEY.
  • Every song shows where it is — lyrics and captions appear as each song is done, one model on the card at a time, each loaded once for the whole batch. A song that failed or was stopped has a button that finishes just that song.
  • Picks up after a restart — each song keeps what it has; a preparation cut off by a crash or a restart carries on by itself and redoes nothing.
  • Stop by steps or by epochs — a fixed number of steps, or a number of passes over the songs.
  • A trigger word from the start — every dataset gets a rare word made from its name, which you can change.
  • Train further — a finished LoRA-method run goes on from where it stopped: set a higher step count and the loss chart and the checkpoints continue instead of starting over. (PiSSA and HOT-PiZZA runs cannot: the trainer does not keep the frozen factors they are measured against.)
• Audio processing — noise reduction, the Spectral Lifter, a vocal naturaliser, your own VST3 plugins in a chain, and mastering to a reference track. Compare before and after while it plays, then keep the result as a version of the track or throw it away.
• MP3 made by the studio — the engine renders 32-bit float and the studio encodes the MP3 with LAME, so nothing is lost before the encoder.
• Fewer steps, same sharpness — below 30 DiT steps the engine raises the flow shift by itself (29/(steps-1)), so a fast render keeps its detail.

The equalizer with its curve and MilkDrop over the studio, as the song plays	The whole window as Winamp 2: equalizer, playlist and MilkDrop, skinned
Any track to MIDI — a piano roll of every instrument, played against the original	Your own LoRA trained on the card — the loss as it learns, a checkpoint every 100 steps
A dataset — lyrics found, the caption written by ear, tempo and key measured	The LoRA catalogue — styles, artists and sound, downloaded in one pass
Audio processing — noise reduction, Spectral Lifter, VST3, mastering to a reference	An agent over MCP — the address and the lines for Claude Code and other clients
Tracks made by tools stay in the library, linked to their original	Writing a track — the caption as a document, every parameter a slider
A finished track — cover, timed lyrics, the request that made it	Studio tools — six-stem separation on the GPU, transcription, editor
Model sets — one quantisation per role, switchable once installed	Every capability runs where you say, local or OpenRouter
Cover art — large preview, prompt templates filled from the track

The same screens are in the interface language you read: Русский, 中文, 日本語, 한국어 — on the project page, or in docs/screenshots.

Windows 10/11 x64 and an NVIDIA card from the GTX 900 series on. The studio ships two CUDA builds of the engine and picks the one your card and driver run: CUDA 13 for Turing and newer (GTX 16, RTX 20–50, Tesla T4, A100, RTX A-series, L4/L40, H100) with driver 580 or newer, CUDA 12 for Maxwell, Pascal and Volta (GTX 900/1000, Titan X/Xp/V, Tesla M40, P40, P100, V100) and for any card on a driver from 525 to 579. Both carry compiled code for every one of those architectures, so nothing is left for the driver to compile.

Training a LoRA is optional and needs an NVIDIA RTX 30-series card or newer with 22 GB of VRAM (an RTX 3090, 4090 or 5090) and about 10.5 GB more disk for the trainer and its weights, downloaded only when you open training. Describing songs by ear needs about 12 GB of VRAM and 10 GB more disk for MOSS-Music; without it the captions are written by hand.

While the studio is open it serves MCP at http://127.0.0.1:8765/mcp: an agent such as Claude Code, Claude Desktop or Cursor does everything the page does, through the same code - songs, the library, covers, stems, MIDI, karaoke, processing, video clips, the player, LoRA, and a LoRA from a folder of songs end to end - and sees and works the window itself: a screenshot, its controls, clicks and typing. 162 tools, grouped by area. MiniMax's own caption rules and reference captions come with the server, so the agent writes the captions, lyrics and lyric layouts itself instead of the studio's small assistant.

With Agent (MCP) chosen as the writing assistant (Settings, Models), the connected agent also answers the studio's own write buttons and dataset preparation. Settings, Agent (MCP) shows whether an agent is connected and what to paste into the client.

claude mcp add --transport http minimax-studio http://127.0.0.1:8765/mcp

docs/mcp-skill.md is the skill an agent reads: every tool, what the model expects, and step-by-step recipes.

A runnable Music3 installation is always five components: language model, RVQ depth decoder, condition encoder, DiT and vocoder.

The studio detects your GPU and preselects the profile it can actually run, but the download is always your decision. Every component is checksum-verified against a pinned Hugging Face revision and downloads resume where they stopped.

Every profile is the same five roles at a different quantisation. The heavier sets — Q5 and up, and the original BF16/F32 weights — come from Serveurperso/MiniMax-Music3-GGUF; the lighter ones that let the studio fit an 8 GB card — Q4 and below, plus the two FP4 formats — come from scragnog/MiniMax-Music3-GGUF. Both repositories are pinned to a fixed revision.

The files are written to, and can be dropped into by hand at:

• Installed: %LOCALAPPDATA%\MiniMax Music3 Studio\models\minimaxmusic-cpp\
• Portable: <the folder you unzipped>\data\models\minimaxmusic-cpp\

Filenames must match the catalogue exactly. The studio checks each file's size and SHA-256, so a file you place by hand is recognised as already installed and never re-downloaded.

Each part is downloaded when you first use it, and each file can be downloaded by hand and put into the studio's data folder — <the folder you unzipped>\data\ for the portable build, %LOCALAPPDATA%\MiniMax Music3 Studio\ for the installed one. A file with the exact name in the listed folder is recognised and not downloaded again.

The generator is a native CUDA program, not a Python stack. mm-server.exe loads a short chain of libraries, and the studio's job before it starts the engine is to make sure every link in that chain is present:

mm-server.exe
  ├─ ggml.dll → ggml-base.dll, ggml-cpu.dll, ggml-cuda.dll     shipped inside the app
  │                               └─ cublas64_13.dll, cublasLt64_13.dll   downloaded once
  │                               └─ nvcuda.dll                           your NVIDIA driver
  └─ vcruntime140.dll, msvcp140.dll, vcomp140.dll              Visual C++ runtime

Shipped inside the app. mm-server.exe, the four ggml*.dll files and neural-codec.exe are part of every release, in resources\minimaxmusic-cpp\ beside the main executable. They are built from the pinned minimaxmusic.cpp commit and never downloaded.

Downloaded once, on the first engine start.

Never downloaded. nvcuda.dll is part of your NVIDIA driver; if the engine complains about it, update the driver. A machine that already has the CUDA Toolkit installed has cuBLAS on its PATH and downloads nothing at all.

You can place the CUDA libraries by hand:

1. Download the cuBLAS archive from the NVIDIA link above and open the .zip.
2. Inside libcublas-windows-x86_64-13.5.1.27-archive\bin\, take cublas64_13.dll and cublasLt64_13.dll.
3. Drop both next to mm-server.exe — the resources\minimaxmusic-cpp\ folder beside the app's main .exe.
4. If the engine still won't start, install the Visual C++ runtime from the Microsoft link, and make sure your NVIDIA driver is current.

On startup the engine reads its own import table and fetches only what is genuinely missing, so a hand-placed DLL is simply found and used.

React UI ─┐
          ├─ MiniMax Music3 Studio.exe   (window + native service)
Rust axum ┘        │
                   ├─ minimaxmusic.cpp `mm-server`  (C++/CUDA, GGUF)
                   ├─ music-train.exe               (HOT-Step ace-train, LoRA training, optional)
                   └─ vst-host.exe                  (HOT-Step VST3 host, a process of its own)

The service is compiled into the desktop binary and supervises the C++ engine. Cloud capabilities go through a capability catalog fetched live from OpenRouter, so the studio never offers a model that does not declare the modality it would be used for.

Music generation, speech-to-text, the assistant and cover art are configured independently, which makes fully local, fully cloud and hybrid setups possible without changing anything about how projects are stored.

npm --prefix app install
npm --prefix desktop install
npm --prefix desktop run build      # the studio executable
cargo test --workspace

Developing the UI against a running service:

cargo run -p music-server           # service on 127.0.0.1:8765
npm --prefix app run dev            # UI on 127.0.0.1:3000

scripts/build-minimax-runtime.ps1 builds the pinned minimaxmusic.cpp runtime. Releases always stage a universal CUDA build; a card-specific build is for local testing only:

scripts\build-minimax-runtime.ps1 -OutputDirectory .\build\engine -RuntimeBackend cuda -CudaArchitecture native

scripts/build-release.ps1 -Version X.Y.Z produces the NSIS installer, a portable archive and a signed latest.json for the in-app updater. It needs the updater signing keys: it reads them from TAURI_SIGNING_PRIVATE_KEY, TAURI_SIGNING_PRIVATE_KEY_PASSWORD and TAURI_UPDATER_PUBKEY if they are set, and otherwise from %USERPROFILE%\.tauri\mm3-release.key, its .pub, and .password beside them. It stops if it can find the key neither way. Model weights are never included in an installer.

I build open-source software and do AI research. Most of what I create is free and available to everyone. Your donations help me keep creating without worrying about where the next meal comes from =)

All donation methods · Русский · 中文 · 日本語 · 한국어 | dalink.to/nerual_dreming | boosty.to/neuro_art

• BTC: 1E7dHL22RpyhJGVpcvKdbyZgksSYkYeEBC
• ETH (ERC20): 0xb5db65adf478983186d4897ba92fe2c25c594a0c
• USDT (TRC20): TQST9Lp2TjK6FiVkn4fwfGUee7NmkxEE7C

This studio is a fork of ACE-Step Studio with ACE inference replaced by MiniMax Music3; the ACE sources live in their own repository. MiniMax Music3 weights are governed by their own community license — commercial use must display the MiniMax-Music3 name and implement the safeguards that license requires.

One bundled component is under a different licence: the visualiser's spectrum looks come from audioMotion-analyzer, which is AGPL-3.0; its source, like the studio's, is public.

What changed and when is in CHANGELOG.md.

• MiniMax for MiniMax Music3.
• Serveurperso for minimaxmusic.cpp.
• scragnog for the GGUF conversions in scragnog/MiniMax-Music3-GGUF and for HOT-Step-CPP: the LoRA trainer the studio runs (mm3-codes and mm3-lm-train with the HOT-PiZZA recipe), the VST3 host, and the noise reduction, Spectral Lifter and mastering designs the audio processing is ported from.
• sergree for matchering, the reference mastering algorithm, and jeankassio for the vocal naturalizer in ComfyUI_MusicTools.
• ntc-ai for the sliders in the LoRA catalogue, each credited and linked on its card.
• The LAME project for the MP3 encoder.
• crmne for Spotifast (MIT): the equalizer solves its band gains as its eq.rs does.
• Jordan Eldredge and the Webamp team for Webamp (MIT), which the Winamp mode runs, and for the Winamp Skin Museum. Winamp and its base skin are Nullsoft's.
• Jordan Berg for Butterchurn and butterchurn-presets (MIT), MilkDrop in the browser. MilkDrop itself is Ryan Geiss's, and each preset is its author's, named in its title.
• Henrique Vianna for audioMotion-analyzer (AGPL-3.0), the spectrum looks of the visualiser.
• Borewit for music-metadata (MIT) and Stuart Knightley for JSZip (MIT), which read tracks and skins in the Winamp mode.
• The authors of the skins that come with the studio: Winamp's base skin 2.91 (Nullsoft); Winamp5 Classified (Sven Kistner, Zarko Jovic, GuidoD, Wildrose-Wally); Winamp3 Classified (Steve Gedikian, John Slegers, PeterPan, Wildrose-Wally); Bento Classified and Internet Archive (LuigiHann); Mac OS X 1.5 Aqua (DeeLight); TopazAmp (Kelly McLarnon); Vizor (ViDA); Zaxon Remake (Daniel Jansson); Green Dimension V2 (its author, who signs the readme in ASCII art); XMMS Turquoise (from the XMMS project). Each skin keeps its own readme inside the .wsz.