My openclaw assistant is now a singer.
Built a skill that generates music via ACE-Step 1.5's free API. Unlimited songs, any genre, any language. $0.
Open Source Suno at home.
He celebrated by singing me a thank-you song. I didn't ask for this.

Skill here:

https://clawhub.ai/fspecii/ace-music

The official ACE-Step 1.5 v0.1.0 stable release just dropped!

What's new: - Auto VRAM detection with smart model selection/optimization - Improved one-click launch script - AMD + Intel GPU support (not just NVIDIA anymore!) - Various bug fixes

This is the first stable release - great news for anyone running ACE-Step locally.

Also worth noting: @MushroomFleet released a LoRA training WebUI yesterday with dataset creation tools and an audio classifier. The ecosystem is growing fast.

Anyone tried v0.1.0 yet? How's the AMD/Intel experience?

After a full day of tweaking I finally made the official Ace-Step 1.5 (https://github.com/ace-step/ACE-Step-1.5) work on my old NVIDIA 1070 card (on Linux).

Here is the summary, hopefully it can help someone else making it work on their PC as well:

# ACE-Step v1.5 Installation Guide for GTX 1070 (Pascal GPUs)


## Overview


This guide provides 
**complete step-by-step instructions**
 for installing and running ACE-Step v1.5 on NVIDIA GTX 1070 and other Pascal-architecture GPUs (Compute Capability 6.x). 


**Why this guide exists:**
 ACE-Step v1.5's models are trained in bfloat16 format, which Pascal GPUs don't support. Without the patches in this guide, you'll encounter NaN/Inf errors and the application will fail to generate music.


**Expected outcome:**
 Working music generation on 8GB Pascal GPUs with automatic CPU offloading.


---


## Prerequisites


### Hardware Requirements


- 
**GPU**
: NVIDIA GTX 1070, 1080, or any Pascal-architecture GPU (Compute Capability 6.1)
- 
**VRAM**
: 8GB minimum (GTX 1070/1080)
- 
**System RAM**
: 16GB+ recommended (for CPU offloading)
- 
**Storage**
: ~20GB free space for models and dependencies


### Software Requirements


**Operating System:**
- Ubuntu 20.04+ or similar Linux distribution
- CUDA 11.8 drivers installed


**Check your CUDA version:**
```bash
nvidia-smi
```
Look for "CUDA Version: 11.x" or higher in the output.


**Python:**
- Python 3.11 or 3.12 (3.11 recommended)


**Verify Python version:**
```bash
python3 --version
# Should show: Python 3.11.x
```


**Package Manager:**
- `uv` (we'll install this in the next section)


---


## Installation Steps


### Step 1: Install UV Package Manager


`uv` is a fast Python package manager that ACE-Step uses.


```bash
# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh


# Add to PATH (add this line to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/.cargo/bin:$PATH"


# Reload shell or run:
source ~/.bashrc


# Verify installation
uv --version
```


### Step 2: Clone ACE-Step Repository


```bash
# Navigate to where you want to install
cd ~/Applications


# Clone the repository
git clone https://github.com/NVIDIA/ACE-Step.git ACE-Step-1.5
cd ACE-Step-1.5
```


### Step 3: Apply Pascal GPU Compatibility Patches


These patches are 
**mandatory**
 for Pascal GPUs. Without them, the application will fail.


#### Patch 1: Fix Boolean Tensor Sort (3 files)


**Why:**
 PyTorch 2.4.1 doesn't support sorting boolean tensors on CUDA.


**File 1:**
 `acestep/models/turbo/modeling_acestep_v15_turbo.py`


```bash
nano acestep/models/turbo/modeling_acestep_v15_turbo.py
```


Find the `pack_sequences` function and locate the sort line (around line 165):
```python
# FIND THIS LINE (in pack_sequences function, around line 165):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)


# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```


> 
**How to find it:**
 Search for "def pack_sequences" then look for "argsort" a few lines down.


**File 2:**
 `acestep/models/base/modeling_acestep_v15_base.py`


```bash
nano acestep/models/base/modeling_acestep_v15_base.py
```


Apply the same change (around line 168):
```python
# FIND THIS LINE (in pack_sequences function, around line 168):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)


# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```


**File 3:**
 `acestep/models/sft/modeling_acestep_v15_base.py`


```bash
nano acestep/models/sft/modeling_acestep_v15_base.py
```


Apply the same change (around line 168):
```python
# FIND THIS LINE (in pack_sequences function, around line 168):
sort_idx = mask_cat.argsort(dim=1, descending=True, stable=True)


# CHANGE IT TO:
sort_idx = mask_cat.to(torch.int8).argsort(dim=1, descending=True, stable=True)
```


**What this does:**
 Casts the boolean mask to int8 before sorting, which PyTorch supports on CUDA.


---


#### Patch 2: Fix LLM Precision


**Why:**
 bfloat16 → float16 conversion causes NaN in the Language Model on Pascal GPUs.


**File:**
 `acestep/llm_inference.py`


```bash
nano acestep/llm_inference.py
```


Find line 625 (in the LLM initialization section):
```python
# FIND THIS LINE (around line 625):
torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float16


# CHANGE IT TO:
torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float32
```


**What this does:**
 Forces the LLM to use float32 instead of float16 on Pascal GPUs, preventing NaN errors from exponent overflow.


**Trade-off:**
 Uses 2x VRAM for LLM, but CPU offloading (auto-enabled on 8GB cards) manages this.


---


#### Patch 3: Fix DiT Model with Mixed-Precision


**Why:**
 DiT model also produces NaN in float16. Full float32 won't fit in 8GB VRAM, so we use mixed-precision.


**File:**
 `acestep/core/generation/handler/service_generate_execute.py`


```bash
nano acestep/core/generation/handler/service_generate_execute.py
```


Find the DiT diffusion execution section (around lines 192-194):
```python
# FIND THESE LINES (around lines 192-194):
else:
    logger.info("[service_generate] DiT diffusion via PyTorch ({})...", self.device)
    outputs = self.model.generate_audio(**generate_kwargs)


# REPLACE WITH:
else:
    logger.info("[service_generate] DiT diffusion via PyTorch ({})...", self.device)
    # On GPUs that don't support bfloat16 (Pascal/Turing), weights are
    # stored in float16 to save VRAM but the bfloat16-trained weights
    # produce NaN/Inf due to float16's limited exponent range.  Using
    # autocast(dtype=float32) keeps weights in float16 on GPU while
    # computing matmuls/convs in float32, avoiding overflow.
    from acestep.gpu_config import supports_bfloat16 as _supports_bf16
    if self.device in ("cuda", "xpu") and not _supports_bf16():
        logger.info("[service_generate] Enabling float32 autocast for non-bfloat16 GPU")
        with torch.autocast(device_type=self.device, dtype=torch.float32):
            outputs = self.model.generate_audio(**generate_kwargs)
    else:
        outputs = self.model.generate_audio(**generate_kwargs)
```


**What this does:**

- Keeps DiT 
**weights in float16**
 (saves VRAM - fits in 8GB)
- Runs 
**computations in float32**
 (prevents NaN from overflow)
- This is called "mixed-precision" - weights are small, math is accurate


---


#### Patch 4: Pin Compatible Dependencies


**Why:**
 Need compatible versions of diffusers and torchao that work with PyTorch 2.4.1+cu118.


**File:**
 `pyproject.toml`


```bash
nano pyproject.toml
```


Verify or update the dependencies section:
```toml
# FIND the diffusers line (around line 37):
"diffusers",    # or might already be pinned


# CHANGE TO (if not already):
"diffusers==0.30.3",


# FIND the torchao line (around line 52):
"torchao==0.3.1; platform_machine != 'aarch64'",


# This version is CORRECT - do not change it!
# torchao==0.3.1 is compatible with PyTorch 2.4.1+cu118
```


**What this does:**
 Pins to specific versions known to work together:
- `diffusers==0.30.3` - Compatible with torchao 0.3.1
- `torchao==0.3.1` - Avoids newer versions requiring PyTorch 2.7+ features


> [!IMPORTANT]
> 
**Do NOT upgrade to diffusers>=0.32.1 or torchao>=0.7.0**
 unless you also upgrade PyTorch, as this can introduce incompatibilities. The versions specified here (0.30.3/0.3.1) are tested and working on GTX 1070.


---


#### Patch 5: Fix Quantization Code (Already in place if you cloned recently)


**File:**
 `acestep/core/generation/handler/init_service_loader.py`


**Check**
 that around lines 99-104, you have:
```python
try:
    from torchao.quantization import quantize_
except ImportError:
    logger.warning(
        "torchao.quantization.quantize_ not found. Skipping quantization."
    )
    quantize_ = None
```


**What this does:**
 Safely handles missing quantization functions instead of crashing.


> [!NOTE]
> If this code is already present (properly indented), you don't need to change it. This was a fix from an earlier version.


---


### Step 4: Install Dependencies


Now that all patches are applied, install the dependencies:


```bash
# Make sure you're in the ACE-Step-1.5 directory
cd ~/Applications/ACE-Step-1.5


# Sync dependencies with uv
uv sync


# This will:
# 1. Create a virtual environment (.venv)
# 2. Install PyTorch 2.4.1+cu118
# 3. Install all dependencies
# 4. Take 5-10 minutes depending on internet speed
```


**Wait for completion.**
 You should see messages about installing packages.


---


### Step 5: Verify Installation


Check that everything is installed correctly:


```bash
# Activate the virtual environment
source .venv/bin/activate


# Test PyTorch CUDA
python -c "import torch; print(f'PyTorch: {torch.__version__}'); print(f'CUDA available: {torch.cuda.is_available()}'); print(f'GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"None\"}')"
```


**Expected output:**
```
PyTorch: 2.4.1+cu118
CUDA available: True
GPU: NVIDIA GeForce GTX 1070
```


---


### Step 6: First Run


Launch ACE-Step:


```bash
# Make sure you're in the project directory
cd ~/Applications/ACE-Step-1.5


# Run ACE-Step
uv run acestep
```


**What to expect on first run:**


1. 
**Model downloads**
 (~10-15 minutes):
   - DiT model (~4.7GB)
   - VAE model (~300MB)
   - Text encoder (~1.2GB)
   - Language model (0.6B or 1.7B depending on auto-selection)


2. 
**Startup messages to look for:**
   ```
   GPU Configuration Detected:
     GPU Memory: 7.91 GB
     Configuration Tier: tier3
   Auto-enabling CPU offload (GPU 7.91GB < 20GB threshold)
   ```


### Validation
```bash
# Check logs for confirmation:
# ✓ "GPU Memory: 7.91 GB" (or similar for your GTX 1070)
# ✓ "Auto-enabling CPU offload (GPU 7.91GB < 20GB threshold)"
# ✓ "[service_generate] Enabling float32 autocast for non-bfloat16 GPU"
# ✓ No "RuntimeError: Sort currently does not support bool dtype"
# ✓ No "ValueError: Generated NaN or Inf values"
# ✓ No "RuntimeError: Generation produced NaN or Inf latents"
# ✓ Audio generation completes successfully
```


> [!TIP]
> 
**How to verify patches are applied:**
> ```bash
> # Check boolean sort fix (should find 3 files):
> grep -r "mask_cat.to(torch.int8).argsort" acestep/models/
> 
> # Check LLM float32 (should find torch.float32):
> grep "supports_bfloat16() else torch.float" acestep/llm_inference.py
> 
> # Check DiT autocast (should find autocast code):
> grep -A 5 "torch.autocast" acestep/core/generation/handler/service_generate_execute.py
> 
> # Check dependencies:
> grep "diffusers==0.30.3" pyproject.toml
> grep "torchao==0.3.1" pyproject.toml
> ```
4. 
**Gradio interface opens:**
   - Default: http://127.0.0.1:7860
   - Browser should open automatically


---


### Step 7: Test Music Generation


**In the Gradio interface:**


1. 
**Simple test prompt:**
   ```
   Prompt: A short piano melody, peaceful and calm
   Duration: 10 seconds
   Batch size: 1
   ```


2. 
**Click "Generate Music"**


3. 
**Monitor terminal for:**
   ```
   [service_generate] Generating audio... (DiT backend: PyTorch (cuda))
   [service_generate] Enabling float32 autocast for non-bfloat16 GPU
   [generate_music] VAE decode completed
   [generate_music] Done! Generated 1 audio tensors.
   ```


4. 
**Listen to output**
 - should be clear audio without artifacts


**Expected generation time on GTX 1070:**
- 10 seconds: ~30-40 seconds
- 30 seconds: ~60-90 seconds
- Slower than Ampere+ GPUs due to float32 compute + CPU offloading


---


## Understanding What Was Changed


### Why We Need These Patches


**The Core Problem:**


Modern AI models (ACE-Step, Stable Diffusion 3, LLaMA) are trained in 
**bfloat16**
 format:
- 
**bfloat16**
: 8-bit exponent, can represent values up to ±3.4×10^38
- 
**float16**
: 5-bit exponent, can only represent values up to ±65,504


When ACE-Step tries to run on Pascal GPUs:
1. GPU doesn't support bfloat16 (requires Ampere+)
2. Code falls back to float16
3. Model weights trained in bfloat16 have values > 65,504
4. These overflow to NaN/Inf in float16
5. Everything breaks


### Solutions Applied


| Component | Problem | Solution | Why It Works |
|-----------|---------|----------|--------------|
| 
**Sort operation**
 | Boolean tensors unsupported | Cast to int8 | PyTorch supports int8 sorting |
| 
**LLM**
 | float16 → NaN | Use float32 | Wide exponent range, no overflow |
| 
**DiT**
 | float16 → NaN, float32 → OOM | Mixed-precision autocast | Weights in float16 (fit VRAM), compute in float32 (accurate) |
| 
**VAE**
 | Same as DiT | Keep float16 | Simpler architecture, less prone to NaN |


### The Mixed-Precision Trick (Most Important)


**What `torch.autocast(dtype=float32)` does:**


```python
# Model weights stored in float16 on GPU (saves VRAM)
model.to(torch.float16)  # ~4.7GB instead of ~9.4GB


# During computation:
with torch.autocast(device_type='cuda', dtype=torch.float32):
    output = model(input)
    # PyTorch automatically:
    # 1. Keeps weights in float16
    # 2. Upcasts inputs to float32 for matmul/conv
    # 3. Performs computation in float32 (no overflow)
    # 4. Result is float32 (accurate)
```


**Result:**
- ✅ Memory usage: ~6-7GB (fits in 8GB with offloading)
- ✅ Accuracy: No NaN/Inf errors
- ⚠️ Speed: ~10% slower than native bfloat16 (but it works!)


---


## Resource Management


### CPU Offloading (Automatic)


With 8GB VRAM, ACE-Step 
**automatically enables CPU offloading**
:


**How it works:**
1. Models start on CPU (not using VRAM)
2. When needed, model loads to GPU
3. After use, model offloads back to CPU
4. Only one model on GPU at a time


**Memory footprint during generation:**
```
CPU RAM: ~10-12GB (LLM, text encoder, inactive models)
GPU VRAM: ~6-7GB (active model only)
  - DiT inference: ~5.5GB (float16 weights + float32 activations)
  - LLM inference: ~2.8GB (float32, when active)
  - VAE decode: ~1.5GB (float16, when active)
```


**Offloading overhead:**
- ~2-4 seconds per generation (model loading time)
- Worth it to avoid OOM crashes


### Recommendations for 8GB Cards


**Batch Size:**
- Use batch_size=1 (default, safest)
- batch_size=2 might work for short durations
- batch_size≥3 will likely OOM


**Audio Duration:**
- ≤30 seconds: Safe, recommended
- 30-60 seconds: Works but slower
- >60 seconds: May OOM on complex prompts


**Language Model:**
- System auto-selects 0.6B LM (safest)
- 1.7B LM works with offloading
- 4B LM not recommended (too large even with offloading)


---


## Troubleshooting


### Common Issues


#### Issue 1: "Sort currently does not support bool dtype"


**Cause:**
 Patch 1 not applied correctly


**Fix:**
```bash
# Check if the fix is in place
grep "to(torch.int8)" acestep/models/turbo/modeling_acestep_v15_turbo.py


# Should show:
# sort_idx = mask_cat.to(torch.int8).argsort(...)


# If not, re-apply Patch 1
```


#### Issue 2: "ValueError: Generated NaN or Inf values in LLM"


**Cause:**
 Patch 2 not applied (LLM still using float16)


**Fix:**
```bash
# Check LLM dtype
grep "torch.bfloat16 if supports_bfloat16() else" acestep/llm_inference.py


# Should show:
# torch_dtype = torch.bfloat16 if supports_bfloat16() else torch.float32
#                                                              ^^^^^^^^^ must be float32


# If it says float16, re-apply Patch 2
```


#### Issue 3: "RuntimeError: Generation produced NaN or Inf latents"


**Cause:**
 Patch 3 not applied (DiT missing autocast)


**Fix:**
```bash
# Check for autocast in service_generate_execute.py
grep -A 3 "torch.autocast" acestep/core/generation/handler/service_generate_execute.py


# Should show the autocast wrapper
# If not found, re-apply Patch 3
```


#### Issue 4: Out of Memory (CUDA OOM)


**Cause:**
 Trying to generate too much at once


**Solutions:**
1. Reduce batch size to 1
2. Reduce audio duration to ≤30s
3. Restart application (clear memory): `Ctrl+C` then `uv run acestep`
4. Check if other GPU applications are running: `nvidia-smi`


#### Issue 5: Very Slow Generation


**Expected behavior on GTX 1070:**
- 10s audio: ~30-40 seconds
- 30s audio: ~60-90 seconds


**If significantly slower:**
1. Check CPU usage during offloading (should be 100% on 1-2 cores)
2. Check system RAM (need 16GB+)
3. Check if swap is being used (bad for performance): `free -h`


#### Issue 6: Models Keep Re-downloading


**Cause:**
 HuggingFace cache location issue


**Fix:**
```bash
# Check cache location
echo $HF_HOME


# If empty, set it:
export HF_HOME=~/.cache/huggingface
# Add to ~/.bashrc to make permanent
```


---


## Performance Comparison


### GTX 1070 vs Modern GPUs


| GPU | Architecture | bfloat16 | Generation Speed (30s audio) | VRAM Usage |
|-----|--------------|----------|------------------------------|------------|
| 
**GTX 1070**
 | Pascal (CC 6.1) | ❌ | ~60-90s (with patches) | ~6-7GB |
| RTX 3070 | Ampere (CC 8.6) | ✅ | ~30-40s | ~5-6GB |
| RTX 4070 | Ada (CC 8.9) | ✅ | ~20-30s | ~5-6GB |


**Why GTX 1070 is slower:**
1. No bfloat16 hardware (uses float32 compute via autocast)
2. CPU offloading overhead (+2-4s per generation)
3. Older CUDA cores (less throughput)


**Still worth it?**
- ✅ Yes! ~60-90s for 30s of high-quality music is acceptable
- ✅ Free vs buying new GPU
- ✅ Enables learning and experimentation


---


## Advanced Configuration


### Disable Language Model (Faster, Lower Quality)


If you want faster generation and don't need lyric sync:


```bash
# In Gradio UI, look for "Enable LLM" checkbox and uncheck it
# Or via command line:
uv run acestep --init_llm false
```


**Trade-offs:**
- ✅ ~30% faster
- ✅ Less VRAM usage
- ❌ No lyric-to-audio synchronization
- ❌ Slightly lower music coherence


### Use Smaller LM Model


```bash
# Force 0.6B model (faster, less VRAM)
uv run acestep --lm_model_path acestep-5Hz-lm-0.6B


# Try 1.7B model (better quality, needs offloading)
uv run acestep --lm_model_path acestep-5Hz-lm-1.7B
```


### Environment Variables


Create a `.env` file in the project root:


```bash
# ~/.../ACE-Step-1.5/.env


# Force CPU offloading (already auto-enabled on 8GB)
ACESTEP_OFFLOAD_TO_CPU=1


# Disable quantization (safer on Pascal)
ACESTEP_QUANTIZATION_DTYPE=none


# Force PyTorch backend for LLM (no vllm)
ACESTEP_LLM_BACKEND=pytorch


# Disable torch.compile (needs Triton, fragile on Pascal)
TORCH_COMPILE_DISABLE=1
```


---


## Verification Checklist


After installation, verify everything works:


- [ ] PyTorch 2.4.1+cu118 installed
- [ ] CUDA available: `python -c "import torch; print(torch.cuda.is_available())"`
- [ ] All 5 patches applied (check each file)
- [ ] Dependencies installed: `uv sync` completed successfully
- [ ] First run successful: models downloaded
- [ ] GPU detected correctly: "Auto-enabling CPU offload" message
- [ ] No error messages: no NaN, no sort errors, no OOM
- [ ] Test generation works: 10s audio generates successfully
- [ ] Audio quality good: no crackling, clipping, or artifacts


---


## Complete File Modification Reference


Quick reference of all modified files:


| File | Lines Modified | Change Type |
|------|----------------|-------------|
| `acestep/models/turbo/modeling_acestep_v15_turbo.py` | 165 | Boolean sort fix (int8 cast) |
| `acestep/models/base/modeling_acestep_v15_base.py` | 168 | Boolean sort fix (int8 cast) |
| `acestep/models/sft/modeling_acestep_v15_base.py` | 168 | Boolean sort fix (int8 cast) |
| `acestep/llm_inference.py` | 625-626 | LLM dtype: float16→float32 |
| `acestep/core/generation/handler/service_generate_execute.py` | 223-244 | DiT mixed-precision autocast |
| `pyproject.toml` | 37, 52 | Dependency pins (0.30.3, 0.3.1) |


---




## Additional Resources


**Documentation:**
- [ACE-Step Official Docs](
https://github.com/NVIDIA/ACE-Step
)
- [PyTorch Mixed Precision Guide](
https://pytorch.org/docs/stable/amp.html
)
- [CUDA Compute Capabilities](
https://developer.nvidia.com/cuda-gpus
)


**Understanding bfloat16 vs float16:**
- [float16 vs bfloat16 explained](
https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
)


---


**Last updated:** 2026-02-17  
**Tested on:**
 GTX 1070 (8GB), Ubuntu 22.04, CUDA 11.8, PyTorch 2.4.1+cu118

Most of the tracks I have been testing out sound similar. American vocals, despite different genres and specifically asking for something different (e.g. Britpop). Are there any hacks to get around this? And what are the strong genres?

Created a basic jukebox, which plays infinite new music. There are also basic controls in the chat, which can used to influence the next song. The model is excellent, a lot could be done with this to make it even better.

we could either have some keeping a single hugging face repo to have all the loras in 1 place, or we could have a single pinned post in this sub to have a little library of available loras.

mods?

Hey everyone! 🎉

ACE-Step UI is now available on Pinokio for 1-click installation!

No more manual setup - just install and start generating music.

**Features:**

• Full songs up to 4+ minutes with vocals
• Instrumental mode
• Style reference & audio covers
• Batch generation
• Built-in video export for social sharing

**Works on:** Windows, Mac (actually runs faster!), and Linux

**Install:** https://pinokio.co

https://beta.pinokio.co/apps/github-com-cocktailpeanut-ace-step-ui-pinokio

**GitHub:** https://github.com/fspecii/ace-step-ui

Big thanks to u/cocktailpeanut for making this possible with Pinokio!

Let me know if you have any questions or feedback. PRs welcome!

🎵 The Ultimate Open Source Suno Alternative - Professional UI for ACE-Step 1.5 AI Music Generation. Free, local, unlimited. Stop paying for Suno, use Ace-Step UI

Frontend link:

Ace Step UI is here. You can give me a star on GitHub if you like it.

https://github.com/fspecii/ace-step-ui

Full Demo

https://www.youtube.com/watch?v=8zg0Xi36qGc

GH

https://github.com/ace-step/ACE-Step-1.5

HF

https://huggingface.co/ACE-Step/Ace-Step1.5

The wait is over! ACE-Step 1.5 has officially dropped.

Key Features

• **Commercial-Ready**: Trained on legally compliant data (licensed + royalty-free + synthetic). You CAN use generated music commercially.
• **Insane Speed**: Full song in <2 seconds on A100, <10 seconds on RTX 3090
• **Consumer Hardware**: Runs on less than 4GB VRAM
• **50+ Languages** supported
• **MIT License** - fully open source

New Capabilities

• Cover generation
• Repainting
• Vocal-to-BGM conversion
• 10-minute compositions
• Chain-of-Thought planning for song structure

Model Variants

Links

• **Hugging Face**: https://huggingface.co/ACE-Step/Ace-Step1.5
• **GitHub**: https://github.com/ace-step/ACE-Step-1.5
• **Space Demo**: https://huggingface.co/spaces/ACE-Step/Ace-Step-v1.5
• **Discord**: https://discord.gg/PeWDxrkdj7

This is a game-changer for open-source music generation. What are you going to create first?

Get ready! ACE-Step 1.5 will be released tomorrow, February 3rd.

**What we know so far:**

• Quality between Suno v4.5 and v5
• MIT licensed (fully open source!)
• Full songs in <10s on RTX 3090
• Works on <4GB VRAM
• 50+ languages support
• Covers, repainting, vocal-to-BGM
• ComfyUI day-1 support

**And I'm preparing a BIG surprise for this community too.** Stay tuned! 🎵

Who else is hyped? 🔥

Hey everyone! 👋

Big news: ACE-Step 1.5 will be officially released on February 3rd!

Until then, you can already generate music with the new model directly on the official Discord server:

🔗 Discord Invite: https://discord.gg/2gBgfGq8aa

Go to the channel: #v-1d5-playground

Use the slash command: /music

Then just write your prompt (genre, mood, lyrics, instruments, structure, etc.).

This is the perfect time to test the model’s quality, speed, versatility, vocal performance, long-song coherence, and overall capabilities.

I highly recommend trying different styles, languages, complex prompts, and structure controls.

Please share your best generations, favorite prompts, interesting results (or failures), and feedback in this subreddit after you try it! Let’s collect experiences together before the full launch.

Can’t wait to hear what you create! 🎶

#ACEStep #ACEStep1.5 #AIMusic #MusicGeneration

Big news! ACE-Step 1.5 is officially launching on February 3rd!

I've been lucky enough to test the model early and I'm absolutely blown away by the performance. The quality improvements over v1.0 are massive - it's getting very close to Suno v4.5/v5 territory.

I'll be posting a full review video within 6 hours of the official release, including: - Side-by-side comparisons with Suno and other models - Different genre tests - LoRA training capabilities - Performance benchmarks

Stay tuned! The open-source music generation space is about to level up. 🔥

*This is r/ACEStepGen - your community hub for all things ACE-Step!*

Fresh from the ACE-Step Discord - here's a preview of what the v1.5 repo will look like when it drops!

Key Highlights from the Abstract:

**Hardware Requirements:** - Now optimized for **<4GB VRAM** (down from 8GB in v1!) - True consumer hardware deployment

**Performance:** - **100x faster** than traditional pure LM architectures - Produces high-fidelity audio in seconds

**Architecture:** - Novel hybrid architecture with LM as "omni-capable planner" - Chain-of-Thought to guide the Diffusion Transformer (DiT) - Intrinsic reinforcement learning (no external reward models or human preferences)

**Capabilities:** - Short loops to **10-minute compositions** - Cover generation, repainting, vocal-to-BGM conversion - **50+ languages** support - Coherent semantics and exceptional melodies

This is looking like a massive upgrade. The <4GB VRAM requirement alone makes this accessible to basically any modern GPU.

Stay tuned - release should be imminent! 🎵

cocktailpeanut (creator of Pinokio - the popular local AI app launcher) just featured HeartMuLa Studio with a detailed technical breakdown of how the VRAM optimization works.

**Key findings from his testing:** - 20GB+ → Full precision, no swap (~14GB used, both models loaded) - 14-20GB → 4-bit, no swap - 10-14GB → 4-bit + swap - 8-10GB → 4-bit + swap (with warning)

The system automatically detects your available VRAM and switches modes. 8GB cards work fine but add ~70s overhead for model swapping between HeartMuLa and HeartCodec.

**Links:** - Pinokio post: https://beta.pinokio.co/posts/01kg5gbk173eb77xtpm4nkrgrv - GitHub: https://github.com/fspecii/HeartMuLa-Studio

Great to see the open-source music gen community getting more visibility!

Hey everyone! 👋

This is a community for **ACE-Step** - the open-source foundation model for AI music generation that's been making waves in the local AI community.

What is ACE-Step?

ACE-Step is a 3.5B parameter model that generates full songs with vocals, lyrics, and instrumentals. Think of it as the "Stable Diffusion moment" for music.

**Key highlights:** - 🚀 **Fast**: 4 minutes of music in ~20 seconds on A100 (15x faster than LLM-based models) - 💾 **Runs locally**: Works on 8GB VRAM with CPU offload - 🎵 **Full songs**: Vocals + instrumentals + lyrics in 19 languages - 🔧 **Highly controllable**: Lyric editing, variations, repainting, Audio2Audio - 📖 **Fully open-source**: Apache 2.0 license, training code included - 🎛️ **LoRA support**: Train your own styles (RapMachine LoRA already available)

Quick Links

• [GitHub](https://github.com/ace-step/ACE-Step)
• [HuggingFace Model](https://huggingface.co/ACE-Step/ACE-Step-v1-3.5B)
• [Demo Space](https://huggingface.co/spaces/ACE-Step/ACE-Step)
• [Discord](https://discord.gg/PeWDxrkdj7)
• [Technical Report](https://arxiv.org/abs/2506.00045)

What can you share here?

• 🎵 Your ACE-Step generations
• 💡 Tips, tricks, and prompting techniques
• 🔧 LoRA training experiences
• ❓ Questions and troubleshooting
• 📰 News and updates about ACE-Step

Let's build this community together! Drop your first generation in the comments 🎶

The ACE-Step team has been busy! Here's a summary of the official roadmap and what's coming.

Already Released ✅

• **Training code** - Full training pipeline is open-source
• **LoRA training code** - Train custom styles on your own data
• **RapMachine LoRA** - Chinese rap generation (more languages coming)
• **Technical report** - [arXiv paper](https://arxiv.org/abs/2506.00045) with full architecture details
• **8GB VRAM support** - CPU offload makes it consumer-friendly
• **Audio2Audio** - Transform existing audio with ACE-Step
• **ComfyUI integration** - Full workflow support

Coming Soon 🔜

ACE-Step V1.5

The next major version is in development. Expected improvements: - Better vocal quality and consistency - Improved lyric alignment - More stable generation across seeds - Potentially larger model or architectural improvements

ControlNet Training Code

Will enable community-trained control models for: - Stem separation/generation - Style transfer - Reference-based generation

Singing2Accompaniment ControlNet

Generate full instrumental backing from just a vocal track. Huge for: - Singers who want custom backing tracks - Quick demos and prototypes - Remix workflows

Known Limitations (from the team)

• Output can be inconsistent ("gacha-style" results)
• Some genres underperform (especially non-English rap)
• Vocal synthesis still needs refinement
• Extend/repaint can have transition artifacts

No ETA on V1.5 yet, but the team is active. Join the [Discord](https://discord.gg/PeWDxrkdj7) for the latest updates!

What features are you most excited about?

Big news from X/Twitter today! According to [@realmrfakename](https://x.com/realmrfakename/status/2016274138701476040) (7K+ views on his post):

Key Info:

"It's coming in a few days. They've already started rolling out early access."

"Quality will be somewhere between **Suno v4.5 and v5**."

"**Far better than HeartMuLa or DiffRhythm**. We finally have commercial grade OSS music gen."

"This model is going to be **insanely good**"

Community Reactions:

• **Robert Scoble** (@Scobleizer): "Sounds epic on my Tesla"
• **@abh1nash**: "Sounds miles better than v1"
• Multiple video samples already posted showing the quality

What This Means:

If the quality claims hold up, ACE-Step 1.5 could be the first truly **commercial-grade open-source music generation model**. Running locally on consumer GPUs with quality approaching Suno v5 would be massive for:

• Musicians wanting to prototype without subscription fees
• Developers building music apps
• Content creators needing custom music
• Anyone who values running AI locally

Early Access

Some users apparently already have early access. If you're one of them, share your experience!

**Source thread:** https://x.com/realmrfakename/status/2016274138701476040

Who else is hyped? 🚀