A 3-minute Korean song in 50 seconds on an RTX 5060 8 GB — hands-on with ACE-Step 1.5

• On a gcube RTX 5060 8 GB, we used the open-source music generation model ACE-Step 1.5 to generate a 3-minute Korean song with vocals in 50.2 seconds.
• Peak VRAM was 4.6 GB. We used the official recommended settings for the 8 GB tier (2B turbo + INT8 + CPU offload + 0.6B LM).
• We cover the three places you’re likely to get stuck on Ubuntu 24.04 / Python 3.12 and how to fix them, plus complete code you can run as is.
• Who this is for: developers who want to run music generation AI themselves on a consumer GPU

Introduction

AI music services like Suno and Udio are already familiar, but many people assume you need a high-end GPU to run a model yourself. So this time, we narrowed it down to a single question.

“Can an 8 GB consumer GPU produce a full Korean song with vocals at a practical speed?”

Our subject is ACE-Step 1.5, an open-source model under the MIT license, and our environment is a gcube RTX 5060 8 GB workload. We ran the same 8 cases twice to confirm reproducibility.

Note on language: Since this post tests Korean vocals, the lyrics in the code are in Korean and are shown exactly as we used them. Code comments are translated into English.

Benchmark results

• Test environment: RTX 5060 8 GB · Ubuntu 24.04 · Python 3.12 · PyTorch 2.10.0+cu128 · ACE-Step 1.5 commit ca1e85f
• VRAM is the peak value collected from nvidia-smi every 0.3 seconds, and the seed was fixed at 42.
• Between the first and second runs, generation time differed by ±1–3 seconds per song (the 3-minute song went from 47.3 s to 50.2 s).

Two things stand out. First, turning on the LM makes a 30-second song about 3x slower, but VRAM only rises by 0.2–0.4 GB. Second, even when the song gets 6x longer (30 s → 180 s), generation time only grows about 2.2x, so longer songs are more efficient.

How ACE-Step 1.5 works, and the 8 GB settings

ACE-Step 1.5 is a music generation foundation model released by ACE Studio and StepFun. It supports lyrics in more than 50 languages, creates songs from 10 seconds to 10 minutes long, and includes editing features such as covers and regenerating sections (repaint).

Generation is split between two models.

ACE-Step checks GPU memory at startup to pick a tier. According to the official GPU compatibility docs, these are the recommended values for the 6–12 GB range, and this walkthrough follows them as is.

We left the 4B XL model out of scope, since it needs 12 GB or more even with offloading on.

Hands-on: running it on gcube

The whole thing takes 15–20 minutes. Run the installation (cells 1–3) once, and the model loading (cells 4 and 5) each time you open the notebook.

Step 1. Create a workload

# Container command
bash -c "apt-get update -qq && apt-get install -y -qq git ffmpeg libsndfile1 >/dev/null && pip install -q jupyterlab && mkdir -p /workspace && jupyter lab --ip=0.0.0.0 --port=8888 --allow-root --no-browser --ServerApp.root_dir=/workspace"

Step 2. Check the environment and install

# [Cell 1] On RTX 50 series (Blackwell), sm_120 must appear in the list
!nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
!python3 -c "import torch;print(torch.__version__, torch.cuda.get_arch_list())"

# [Cell 2] Install ACE-Step (without flash-attn, about 2 min 14 s)
%cd /workspace
!git clone -q https://github.com/ace-step/ACE-Step-1.5.git
%cd /workspace/ACE-Step-1.5
!grep -v -i flash requirements.txt > req_noflash.txt
!pip install -q -r req_noflash.txt && pip install -q -e . --no-deps

# [Cell 3] LM for the 8 GB tier (0.6B) — not included in the default download
from huggingface_hub import snapshot_download
snapshot_download("ACE-Step/acestep-5Hz-lm-0.6B",
                  local_dir="/workspace/ACE-Step-1.5/checkpoints/acestep-5Hz-lm-0.6B")

Step 3. Load the models

On the first run, the main model (about 9.4 GB) downloads automatically (2–5 minutes).

# [Cell 4] Load DiT + LM (recommended settings for the 8 GB tier)
import os, sys, time, torch
sys.path.insert(0, "/workspace/ACE-Step-1.5")
os.chdir("/workspace/ACE-Step-1.5")
from acestep.handler import AceStepHandler
from acestep.llm_inference import LLMHandler
from acestep.inference import GenerationParams, GenerationConfig, generate_music

dit = AceStepHandler()
print(dit.initialize_service(project_root="/workspace/ACE-Step-1.5", config_path="acestep-v15-turbo",
      device="cuda", offload_to_cpu=True, offload_dit_to_cpu=True, quantization="int8_weight_only"))
llm = LLMHandler()
print(llm.initialize(checkpoint_dir="/workspace/ACE-Step-1.5/checkpoints",
      lm_model_path="acestep-5Hz-lm-0.6B", backend="pt", device="cuda", offload_to_cpu=True))

Both outputs should end with True.

# [Cell 5] Generation helper function
def make_song(name, caption, duration, lyrics="", lang="unknown", bpm=None,
              instrumental=False, thinking=True, seed=42):
    torch.cuda.reset_peak_memory_stats()
    p = GenerationParams(caption=caption, lyrics=lyrics, instrumental=instrumental, vocal_language=lang,
                         bpm=bpm, duration=duration, thinking=thinking, seed=seed)
    cfg = GenerationConfig(batch_size=1, audio_format="wav", use_random_seed=False)
    start = time.time()
    r = generate_music(dit, llm, p, cfg, save_dir=f"/workspace/out/{name}")
    print(f"{name}: success={r.success} |{time.time()-start:.1f}s | "
          f"peak{torch.cuda.max_memory_allocated()/2**30:.1f}GB (torch)")

Step 4. Generate

# [Cell 6] Smoke test: 10-second instrumental, LM off
make_song("01_lofi_10s", "chill lo-fi hip hop, mellow piano, soft vinyl crackle, relaxed drums",
          duration=10, bpm=80, instrumental=True, thinking=False)

# [Cell 7] 30-second Korean ballad, LM on
ballad = """[Verse]
창문 너머 불빛이 번져
오늘도 너를 떠올려
작은 방 안에 남은 온기
아직 여기 머물러

[Chorus]
괜찮다고 말해줘
내일은 더 밝을 거라고
멀리 있어도 들려줘
우리의 노래를"""

make_song("02_ko_ballad_30s", "emotional Korean ballad, female vocal, piano and strings, warm and nostalgic",
          duration=30, bpm=72, lyrics=ballad, lang="ko")

# [Cell 8] 3-minute full song — add enough section tags for the length to reduce repetition
ballad_full = """[Intro]

[Verse 1]
창문 너머 불빛이 번져
오늘도 너를 떠올려
작은 방 안에 남은 온기
아직 여기 머물러

[Pre-Chorus]
시간은 자꾸 흘러가도
마음은 그 자리에

[Chorus]
괜찮다고 말해줘
내일은 더 밝을 거라고
멀리 있어도 들려줘
우리의 노래를

[Verse 2]
낡은 사진 속 웃음소리
귀가에 다시 맴돌아
함께 걷던 그 골목길
아직 따뜻한 걸

[Chorus]
괜찮다고 말해줘
내일은 더 밝을 거라고
멀리 있어도 들려줘
우리의 노래를

[Bridge]
언젠가 다시 만나면
웃으며 인사할게

[Outro]
우리의 노래를"""

make_song("03_ko_ballad_180s", "emotional Korean ballad, female vocal, piano and strings, warm and nostalgic, full song structure",
          duration=180, bpm=72, lyrics=ballad_full, lang="ko")

# [Cell 9] Play the results (48 kHz WAV)
import glob
from IPython.display import Audio, display, Markdown
for f in sorted(glob.glob("/workspace/out/*/*.wav"), key=os.path.getmtime):
    display(Markdown(f"**{f.split('/')[-2]}**"))
    display(Audio(f))

Tips for writing lyrics: Split sections with tags like [Verse] and [Chorus], and leave a blank line between sections. Six to ten syllables per line works well. For caption, list the genre, vocals, instruments and mood in English, separated by commas, and if you want a different version, change only the seed.

Troubleshooting

These are problems we actually ran into across the two runs. The code above already includes every fix.

Comparing our second run (without flash-attn) with our first run (with it, on a conda Python 3.11 image), we found no meaningful difference in generation time or VRAM.

FAQ

Q. Can you generate AI music on an 8 GB GPU? Yes. With INT8 quantization and CPU offloading on the ACE-Step 1.5 2B turbo model, an RTX 5060 8 GB can generate a 3-minute song with vocals at a peak of 4.6 GB VRAM.

Q. How long does it take to make a 3-minute song? About 50 seconds on an RTX 5060 8 GB with the LM on. Turning off the LM makes it about 3x faster for a 30-second song.

Q. Does it handle Korean lyrics? Yes. ACE-Step 1.5 supports more than 50 languages; just set vocal_language="ko".

Q. Can I use it commercially? The ACE-Step 1.5 code and models are MIT-licensed. However, feeding in lyrics or audio from existing songs can raise copyright issues, so use lyrics you wrote yourself.

Q. Do I need flash-attn? Not with the 8 GB settings (PyTorch backend). It matters if you use the vLLM backend or LoRA training.

Wrapping up

An RTX 5060 8 GB was enough to run music generation AI practically. It made a 3-minute full song in under a minute with nearly half its VRAM to spare, so you can quickly compare multiple versions while changing lyrics and genres. We didn’t evaluate audio quality or Korean pronunciation numerically, so have a listen and judge for yourself.

Get started on gcube right away Even without a local GPU, you can run the code in this post as is by creating an RTX 5060 workload on gcube.

• Go to gcube: https://bit.ly/4uhRePt
• Contact (KakaoTalk channel): http://pf.kakao.com/_jBeTn

References

• ACE-Step 1.5 GitHub
• ACE-Step 1.5 official docs
• 5Hz LM 0.6B (Hugging Face)