Music & Sound Effects

Stable Audio 3 self-hosted: 6.52GB of VRAM for 6 minutes 20 of stereo

In May 2026 Stability AI pushed long-form music generation onto consumer cards. The medium model is 1.4B parameters, caps at 380 seconds, and peaks at 6.52GB — one RTX 3090 covers it, at $0.193/GPU-hour on NexGPU.

Stable Audio · self-hosted

Stable Audio 3.0 is a family, not a single checkpoint. small-music and small-sfx are 459M-parameter diffusion backbones paired with the 108M SAME-S autoencoder, capped at 120 seconds. medium is a 1.4B backbone on the 852M SAME-L, good for 380 seconds — six minutes twenty. large is 2.7B and ships only through the API and paid self-hosting; no weights. The first three are open on Hugging Face as stabilityai/stable-audio-3-small-music, stable-audio-3-small-sfx and stable-audio-3-medium, with inference and training code at github.com/Stability-AI/stable-audio-3. Everything outputs 44.1kHz stereo.

The reason the VRAM figure is so small is architectural. SAME — the Semantically-Aligned Music autoEncoder — compresses stereo waveforms at a 4096x downsampling ratio into a 256-dimensional latent sequence running at roughly 10.76Hz, far more aggressive than the 1024x–2048x typical of earlier audio autoencoders. A 380-second track is only a few thousand latent tokens. The backbone conditions on T5Gemma (t5gemma-b-b-ul2) and samples with ping-pong sampling in 8 steps, with no classifier-free guidance. Stability's published H200 numbers: medium renders 380 seconds in 1.31 seconds of sampling at a 6.52GB peak, or 0.43 seconds with TensorRT. small renders 120 seconds in 0.45 seconds at a 2.40GB peak.

So the cost of self-hosting Stable Audio 3 was never about whether it runs. It is about how many takes per hour, and whether you can fine-tune it into your own sound. A game audio pipeline wants batch throughput. An independent producer wants a LoRA trained on their own sample library. A product team wants the weights on their own machine so prompts never leave it. All three start on one cheap Ampere card, billed by the second and stopped when you are done — which is exactly what NexGPU's 1,175 verified rentable nodes are for.

01 —

Every Stable Audio 3 variant, with real VRAM

Stability's published peak VRAM (H200, unchunked decode) alongside community quantisation sizes

Version	Parameters	VRAM	Context	Notes
Stable Audio 3 Small-Music	459M (DiT) + 108M (SAME-S)	peak 1.69GB (5s) / 1.89GB (30s) / 2.40GB (120s)	up to 120s	Music-only lightweight branch, officially CPU-capable — the only open-weight model that composes full tracks on-device.
Stable Audio 3 Small-SFX	459M (DiT) + 108M (SAME-S)	peak 1.69GB (5s effect) / 2.40GB (120s)	up to 120s	Sound-effects branch, driven with the TrackType: SFX prefix. The pick for batching footsteps, ambiences and UI stingers.
Stable Audio 3 Medium	1.4B (DiT) + 852M (SAME-L)	peak 5.07GB (5s) / 5.49GB (30s) / 6.49GB (120s) / 6.52GB (380s)	up to 380s (6m20s)	The flagship among the open weights. Distributed in F32 — roughly 5.5GB of DiT plus 3.2GB of SAME-L, about 8.8GB on disk. Those VRAM numbers assume a bf16 load.
Stable Audio 3 Medium-Base	1.4B (DiT) + 852M (SAME-L)	LoRA training ~6.5GB; ~5.5GB with --base_precision bf16 --adapter_type lora-xs	up to 380s	The designated fine-tuning starting point. scripts/train_lora.py takes this as --model, not the released medium checkpoint.
Stable Audio 3 Medium GGUF (community)	1.4B, served through sa3.cpp (C++/GGML)	file sizes: F16 ~4.4GB / Q8_0 ~2.3GB / Q5_K_M ~1.7GB / Q4_K_M ~1.5GB (DiT + SAME combined)	up to 380s	The community treats F16 as the production path — roughly 3.5s for 12s of audio on an 8GB laptop GPU. Q4 mainly saves load footprint; fidelity drops.
Stable Audio Open 1.0 (previous line)	~1.1B, T5-base text encoder	8GB entry point in community practice; decode stage climbs to around 14.5GB of memory	up to 47s	The 2024 generation, now superseded: 47 seconds became 380, and dozens of sampling steps became 8. Fine to keep running; no reason to start there.

02 —

Pick the card by the job

This is a small model. Do not rent an H100 for it unless you are matching the published benchmark.

Batch asset generation with small-music / small-sfx
RTX 3090 24GB$0.193/GPU-hour
A 2.40GB peak means you can run a dozen inference workers side by side in 24GB. It is the cheapest Ampere card here, and the cheapest one that can take flash-attn 2 at all.
medium rendering full 380-second tracks with the Gradio UI
RTX 4090 24GB$0.540/GPU-hour
Ada architecture, so the prebuilt flash-attn 2 wheels install cleanly, and there is plenty of room past the 6.52GB peak for batched decoding and concurrent streams.
LoRA on medium-base to bake in your own sample library
RTX A6000 48GB$0.817/GPU-hour
The default dora-rows config sits near 6.5GB; 48GB lets you raise rank, batch and dataset cache together and run thousands of steps without an OOM restart.
Reproducing the official TensorRT latency, or one card serving heavy concurrency
H200 141GB$6.660/GPU-hour
The headline "380-second track in 0.43 seconds" was measured on an H200 with TensorRT. Same silicon, same numbers. Everyday rendering does not need it.

03 —

From bare instance to your first six-minute render

Four steps, straight from the official repo — no third-party wrapper

01
Boot an Ampere-or-newer card
medium depends on flash-attention 2, which needs sm80 or above. Turing (Tesla T4), Volta (V100) and Pascal (P40) cannot run it — that is the real reason most people's first render comes out as static. Pick an RTX 3090, A10 or RTX 4090, start from a prebuilt PyTorch image, SSH in and confirm the compute capability first.
```
nvidia-smi --query-gpu=name,compute_cap,memory.total --format=csv
```
02
Clone the repo and sync with uv
The official repo manages dependencies with uv and installs PyTorch for CUDA 12.6 by default. On a different CUDA version, install the matching torch manually before running uv sync. --extra ui adds the Gradio interface, --extra lora adds the fine-tuning scripts.
```
git clone https://github.com/Stability-AI/stable-audio-3 && cd stable-audio-3 && uv sync --extra ui --extra lora
```
03
Install the prebuilt flash-attn wheel and verify it
Compiling flash-attn from source on a per-second-billed card is pure waste; Stability points at prebuilt wheels for exactly this reason. Always verify the import afterwards — a clean import is what tells you medium will not render noise.
```
uv pip install https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.7.16/flash_attn-2.6.3+cu126torch2.7-cp310-cp310-linux_x86_64.whl && uv run python -c 'import flash_attn; from flash_attn import flash_attn_func; print(flash_attn.__version__)'
```
04
Pull the weights, generate, open the UI
medium is a gated repo on Hugging Face: you must accept both the Stability AI Community License and the Gemma Terms of Use, because the T5Gemma text encoder is redistributed under Gemma terms including the Section 3.2 use restrictions. Once the weights land, render from the CLI, or run uv run python run_gradio.py --model medium and reach the UI over an SSH tunnel.
```
hf download stabilityai/stable-audio-3-medium && stable-audio --model medium -p 'TrackType: Music, VocalType: Instrumental, Genre: ambient techno, 118 BPM, warm analog pads, tape saturation' --duration 380 -o track.wav
```

What this actually costs

Start with the ceiling. Stability reports medium rendering a 380-second (6m20s) track in 1.31 seconds of sampling on an H200. NexGPU lists the H200 141GB at $6.660/GPU-hour, so 3600 / 1.31 is roughly 2,748 tracks per hour, or $6.660 / 2748 = about $0.0024 each. On the TensorRT path at 0.43 seconds it is about 8,372 tracks per hour, roughly $0.0008 each. That is under a cent for six minutes of finished stereo. Now the sensible option. medium peaks at 6.52GB, which an RTX 3090 24GB swallows without effort at $0.193/GPU-hour. Even if that card were an order of magnitude slower and took 15 seconds per track, you would get 240 tracks an hour at $0.193 / 240 = about $0.0008 each — the same unit cost as TensorRT on an H200, for 2.9% of the rent. That is the whole argument against sending this model to a big card. Fine-tuning: the standard LoRA config sits near 6.5GB and starts at 1000 steps. On an RTX 4090 24GB at $0.540/GPU-hour, budgeting two hours per run is 2 x $0.540 = $1.08. A 20GB sample dataset at $0.414/GB-month is 20 x $0.414 = $8.28 per month, or $0.276 a day; stop the instance when the run ends and compute billing stops immediately while the data stays put for the next iteration. Metered per second, no minimum, no setup fee — an unsatisfying run costs less than the change from a coffee.

04 —

FAQ

How much VRAM does Stable Audio 3 actually need? Is an 8GB card enough?

Stability's figures: small peaks at 2.40GB for 120 seconds, medium at 6.52GB for 380 seconds. So 8GB does run medium in bf16, but the headroom is thin and long-duration decoding sits close to the ceiling. The community GGUF path is explicit that F16 does about 12 seconds of audio in 3.5 seconds on an 8GB laptop GPU. If you are doing real work, just take 24GB: NexGPU's RTX 3090 24GB is $0.193/GPU-hour, cheaper than the hours you would spend tuning around 8GB.

The small models are advertised as CPU-capable. Do I still need a GPU?

It depends on volume. In the published benchmark, small renders 120 seconds in 5.92 seconds on Mac CPU, 3.09 seconds via CoreML, and 0.45 seconds on an H200. For one or two takes that is irrelevant, but sound libraries mean thousands of variants and the gap multiplies. NexGPU bills per second — an hour of batch work on an RTX 3090 is $0.193, then you stop the instance. Cheaper than running your laptop fans all night.

Why does my output come out as static glitch noise?

Nine times out of ten flash-attention 2 is not working. This is a named failure mode in the official README and it only affects medium. Verify with import flash_attn first; if the error is about unsupported architecture, the card is wrong — FA2 needs sm80 or newer, so T4, V100 and P40 are out. On NexGPU, switching to an RTX 3090 ($0.193/GPU-hour) or RTX 4090 ($0.540/GPU-hour) takes minutes.

Can Stable Audio 3 generate vocals with lyrics?

No, and that is by design. The family targets instrumental audio; it will sometimes produce non-lexical vocal-like textures, but not intelligible lyrics. The official prompt guide recommends steering with prefixes: TrackType: Instrument for isolated instruments, TrackType: SFX for effects, VocalType: Instrumental to suppress vocal texture, plus Genre:, Instruments: and Format: tags. Training captions are predominantly English, so English prompts land noticeably better.

Can I use the open weights commercially, and how does large fit in?

small, small-sfx and medium ship under the Stability AI Community License: free commercial use, fine-tuning and derivatives for organisations under $1M in annual revenue, with an Enterprise License required above that line. Because the text encoder is T5Gemma, you also accept the Gemma Terms of Use and its Section 3.2 restrictions. The 2.7B large model has no public weights — API and paid self-hosting only. Confirm your own compliance position; NexGPU's part is simply that the weights run on your machine and your prompts never reach a third-party inference service.

I'm on Stable Audio Open 1.0. Should I move?

Yes. Open 1.0 is the 2024 line: roughly 1.1B parameters, a 47-second ceiling, a T5-base text encoder, an 8GB entry point and a decode stage that climbs to about 14.5GB of memory. Stable Audio 3 medium stretches to 380 seconds, cuts sampling to 8 steps, and still peaks lower at 6.52GB. Old pipelines can keep running, but there is no reason to start a new one on Open 1.0. Spin up two identical NexGPU instances for an A/B and the hour costs under fifty cents.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.