What You'll Build
A working text-to-music pipeline that turns a text prompt + optional lyrics into a full song (vocals, instruments, up to ~4 minutes) on a single RTX 5070 Ti, either through the official Gradio app or as a ComfyUI custom node.
Hardware data: RTX 5070 Ti (16 GB VRAM) · text-to-music, lyric-aligned vocals, top-10 supported languages per HF model card · See benchmark data
ℹ️ Not a TTS model. ACE-Step generates music — instruments and lyric-aligned vocals — from a text description. It is filed under our
ttsvertical because the catalogue groups all audio-output models together, but it is not a text-to-speech engine. If you want spoken speech synthesis on this GPU, see Kokoro or VoxCPM. If you want sung vocals over generated backing, you are in the right place.
Requirements
| Component | Minimum | Tested |
|---|---|---|
| GPU | 8 GB VRAM with optimization flags, 12 GB at default precision | RTX 5070 Ti (16 GB) |
| RAM | 16 GB | — |
| Storage | ~8.3 GB for the 3.5B weights + DCAE VAE + vocoder + UMT5-base text encoder | — |
| Software | Python 3.10, PyTorch with CUDA (cu128 wheels for Blackwell sm_120), ComfyUI (optional) | — |
The RTX 5070 Ti is a Blackwell GB203 (sm_120) card — 8960 CUDA cores, ~896 GB/s memory bandwidth, 16 GB GDDR7 on a 256-bit bus, 300 W TDP. Its 16 GB envelope clears the ~11.7 GB default-precision peak (observed on a 12 GB RTX 3060, see Results) with several GB of headroom — no optimization flags are required at default precision.
Installation
1. Clone the repo and create the conda environment
git clone https://github.com/ace-step/ACE-Step.git
cd ACE-Step
conda create -n ace_step python=3.10 -y
conda activate ace_step
2. Install PyTorch with Blackwell (sm_120) kernels
The official README installs a cu126 PyTorch wheel. On a Blackwell RTX 5070 Ti (sm_120), make sure the wheel ships sm_120 kernels — use the CUDA 12.8 index:
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
(The README's stock command targets cu126; on Linux you can usually skip this step and let pip install -e . pull a current torch, but pin the CUDA 12.8 wheel if the default build lacks sm_120 kernels for your driver. For other PyTorch installation options, refer to the official PyTorch website.)
3. Install the package
pip install -e .
This pulls in diffusers, transformers, accelerate, and the project's audio dependencies. Weights for ACE-Step/ACE-Step-v1-3.5B are downloaded automatically from HuggingFace on first launch (to ~/.cache/ace-step/checkpoints unless you pass --checkpoint_path).
4. (Optional) ComfyUI custom node
If you would rather drive the model from a ComfyUI workflow:
cd ComfyUI/custom_nodes
git clone https://github.com/billwuhao/ComfyUI_ACE-Step.git
Then download the weights into ComfyUI/models/TTS/ACE-Step-v1-3.5B/ — the folder layout is documented in the custom node README (needs ace_step_transformer, music_dcae_f8c8, music_vocoder, and umt5-base subdirectories).
Running
Gradio app (official)
acestep --port 7865 --bf16 true
Then open http://localhost:7865. In the Text2Music tab, enter descriptive tags (style, mood, instruments) and optional lyrics (use [verse], [chorus], [bridge] structure tags), set an audio duration, and generate. The app returns a downloadable audio file.
Memory-optimized launch (free headroom for other workloads)
acestep --torch_compile true --cpu_offload true --overlapped_decode true --port 7865
These three flags together are what get the model down to the official 8 GB floor — useful if the 5070 Ti is also driving a display, running a browser, or sharing the card with other inference workloads. On a 16 GB card you do not strictly need them, but they cut peak resident VRAM substantially. (--torch_compile needs pip install triton-windows on Windows.)
Python API (programmatic)
ACE-Step is a music model, so the HuggingFace card's pipeline_tag is text-to-audio and the card carries no copy-pasteable code snippet — do not reach for a generic diffusers image/text pipeline. The canonical entry point, per the repo's infer.py, is the ACEStepPipeline class, instantiated and then called directly (there is no .text2music() method — text2music is only the Gradio tab label and the internal task string):
from acestep.pipeline_ace_step import ACEStepPipeline
pipe = ACEStepPipeline(
checkpoint_dir="", # "" → auto-download to ~/.cache/ace-step/checkpoints
dtype="bfloat16",
torch_compile=False,
cpu_offload=False,
overlapped_decode=False,
)
pipe(
audio_duration=60,
prompt="upbeat synthwave, driving bass, retro 80s",
lyrics="[verse]\nNeon city lights\n[chorus]\nWe ride tonight",
infer_step=27,
guidance_scale=15.0,
save_path="output.wav",
)
The generated audio is written to save_path. See infer.py for the full argument list (scheduler type, CFG type, seeds, guidance interval, ERG flags).
Results
- Speed: No RTX 5070 Ti benchmark is cited yet, so no speed figure is claimed for this card. For reference only, the official ACE-Step GitHub README reports an RTX 4090 generates one minute of music in 1.74 s (RTF 34.48×, 27 steps) and an RTX 3090 in 4.70 s (RTF 12.76×, 27 steps) — these are the project's own numbers on those cards, not measurements on the 5070 Ti. Once a community benchmark lands it will appear at /check/acestep-1-5-xl/rtx-5070-ti. If you run ACE-Step on a 5070 Ti, please contribute your numbers via the submission form.
- VRAM usage: Default half precision peaks at 11.7 GB / 12 GB on an RTX 3060, per community user
akandein HF discussion #4 (May 2025): "For me it runs on my 3060 and consumes 11.7GB / 12GB vram. […] Because i don't use any arguments other then --port to start." The official minimum is 8 GB withcpu_offload + torch_compile + overlapped_decodeenabled, confirmed by the ACE-Step team (memberxushengyuan) in the same thread: "The minimum VRAM requirement for full-length generation is now just 8 GB. We tested it on an RTX 4060, and it delivers decent performance beyond our expectations (1.16it/s)." The 5070 Ti's 16 GB envelope leaves ~4 GB of comfortable headroom at default precision over the 11.7 GB peak. See /check/acestep-1-5-xl/rtx-5070-ti. - Quality notes: Performs best in the top 10 supported languages; rare instruments may render imperfectly; outputs beyond ~5 minutes can lose structural coherence; the model is highly seed-sensitive ("gacha-style" results, per the HF card's Limitations section).
For the full benchmark data, see /check/acestep-1-5-xl/rtx-5070-ti.
Troubleshooting
The HuggingFace Quick-start snippet does not work
ACE-Step's HF card has pipeline_tag: text-to-audio and ships no usable inference snippet — if you paste a generic diffusers pipeline(...) call (or an .images[0]-style snippet from a similarly-templated card) it will not produce music. Use the ACEStepPipeline class from the repo's infer.py (shown in the Python API section above): instantiate ACEStepPipeline(...) and call it directly with prompt / lyrics / audio_duration / save_path. The Gradio CLI (acestep) is the simpler path if you do not need the library API.
Out of memory at default precision
The 16 GB envelope of the RTX 5070 Ti should clear the cited 11.7 GB peak comfortably, but if you are also running a desktop session or other CUDA workloads, enable the launch-flag combination:
acestep --torch_compile true --cpu_offload true --overlapped_decode true
cpu_offload is the heaviest hitter — it streams transformer layers from RAM into VRAM on demand. Combined with overlapped_decode (which pipelines VAE decoding with diffusion) you hit the official 8 GB floor that the ACE-Step team measured on an RTX 4060 per HF discussion #4.
acestep command not found after pip install -e .
The -e (editable) install registers the acestep entry point in your conda env. If the shell can't find it, you are probably in a different env — re-activate with conda activate ace_step and verify with which acestep. The GitHub repo README documents the entry point.
Generations sound unstructured past ~5 minutes
This is a documented limitation, not a bug. The model card calls it out under "Limitations" — the model loses long-range structural coherence beyond ~5 minutes. Either keep prompts inside that window or use the repaint/extend operations on shorter segments and stitch them.
Vocals sound coarse / lyrics are mispronounced
The model's "Vocal Quality" limitation (per the HF card) — synthesis is functional but lacks fine nuance, especially for low-resource languages outside the top 10. For polished vocals, the model's RapMachine LoRA fine-tune is one option; see the official GitHub repo for the LoRA loading documentation.
If you hit something not covered here, please report via the submission form so we can add it to the catalogue.