ai-local-rx580-stack

██████╗ ██╗  ██╗    ███████╗ █████╗  ██████╗
██╔══██╗╚██╗██╔╝    ██╔════╝██╔══██╗██╔═████╗
██████╔╝ ╚███╔╝     ███████╗╚█████╔╝██║██╔██║
██╔══██╗ ██╔██╗     ╚════██║██╔══██╗████╔╝██║
██║  ██║██╔╝ ██╗    ███████║╚█████╔╝╚██████╔╝
╚═╝  ╚═╝╚═╝  ╚═╝    ╚══════╝ ╚════╝  ╚═════╝
AIVisionsLab · Polaris Revival Project · 2026

GPU from 2017. SOTA AI in 2026. No CUDA. No ROCm. No cloud. No excuses.

---

The Narrative

"Your RX 580 can't run AI. Buy a new GPU."

AMD dropped ROCm for Polaris/GCN4 in v5.x. DirectML crashes with OpaqueTensorImpl. OpenVINO fails silently on Forge. The mainstream AI stack gave up on this card.

We didn't.

By compiling llama.cpp and stable-diffusion.cpp from source with Vulkan support, the RX 580 runs real, useful AI inference in 2026 — locally, offline, privately. This repository is the complete technical record of how.

RX 580 8GB  ──►  Vulkan API  ──►  ggml engine  ──►  17 tok/s LLM  +  72s/image SD
Xeon 2014   ──►  WSL2 CPU    ──►  ComfyUI       ──►  FLUX 16GB  +  AnimateDiff

---

Table of Contents

• Hardware
• Benchmarks
• Architecture: Dual-Path Stack
• Critical: Two GGUF Formats for FLUX
• What Failed (and Why)
• Quick Start: LLM via Vulkan
• Quick Start: Image Generation via Vulkan
• FLUX Hybrid Setup
• OpenWebUI + Docker Integration
• whisper.cpp: Audio Transcription
• Applio RVC: Voice Cloning
• AnimateDiff: Video Generation
• Linux Native: Ubuntu 26.04 LTS
• Windows vs Linux Comparison
• Troubleshooting
• Automation Scripts
• Community Timeline
• Pushing the 35B Limit: Qwen3.5 MoE Hybrid Experiment
• Repository Structure

---

Hardware

RX 580 2048SP note: The mining-variant with 2048 shader processors (vs the original 2304SP) performs identically through Vulkan. Both are Polaris/GCN4.

NVMe impact: Upgrading from HDD to NVMe reduced FLUX.1 model load time from 25 minutes to ~30 seconds. Storage is as critical as compute.

---

Benchmarks (Real Logs)

Whisper on Linux (Mesa RADV) is absurdly faster than Windows — ~150× speedup over pure CPU. VRAM usage: only 1.6GB of 8GB available.

---

Architecture: Dual-Path Stack

The core insight of this project: not every workload fits in 8GB of VRAM. The solution is routing intelligently between GPU and CPU rather than forcing everything through one path.

OpenWebUI  :3000  (Docker)
    │
    ├──► llama-server  :8081  ──►  RX 580 Vulkan  [llama.cpp]
    │         └── Ollama      :11434  ──►  CPU fallback
    │
    └──► sd-server     :7860  ──►  RX 580 Vulkan  [stable-diffusion.cpp]
              ├── SD 1.5 GGUF      ──►  72s / image   ✅
              └── FLUX hybrid      ──►  ~14 min / image  ✅
    
    └──► ComfyUI       :8188  ──►  Xeon CPU WSL2   [heavy models > 8GB VRAM]

Path 1 — GPU Vulkan (RX 580): All LLM inference + SD 1.5 image generation. Fast, responsive, daily driver.

Path 2 — CPU Xeon (WSL2): FLUX.1 16GB models, AnimateDiff video pipelines. Slow but stable. The 32GB ECC RAM acts as "virtual VRAM."

---

Critical: Two GGUF Formats for FLUX

⚠️ This trips up almost everyone.

Using a city96 GGUF in sd-server returns:

[ERROR] main.cpp:92 - new_sd_ctx_t failed

Always download FLUX weights from: huggingface.co/leejet/FLUX.1-schnell-gguf

---

What Failed (and Why)

We documented every dead end. These aren't opinions — they're error logs.

Full autopsy with logs: docs/what-failed.md

---

Quick Start: LLM via Vulkan (Windows)

Run these commands in Developer PowerShell for Visual Studio.

# Clone and compile with Vulkan backend
cd E:\
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j20

# Validate GPU detection
cd build\bin\Release
.\llama-cli.exe --list-devices
# Expected: Vulkan0: AMD Radeon RX 580 2048SP ✅

# Start LLM server
.\llama-server.exe -m "E:\models\Mistral-7B-Q4_K_M.gguf" `
  --host 0.0.0.0 --port 8081 --device Vulkan0

Verify it's using the GPU (not CPU):

log output during inference:
ggml_vulkan: Found 1 Vulkan device(s)
ggml_vulkan: 0 = AMD Radeon RX 580 2048SP | VRAM: 8192MB
17.77 t/s  ← RX 580 Vulkan ✅

If you see 3–5 t/s with no ggml_vulkan line — it's running on CPU. Check that --device Vulkan0 is present.

---

Quick Start: Image Generation via Vulkan

# Clone with submodules (required for ggml dependency)
git clone --recursive https://github.com/leejet/stable-diffusion.cpp
cd stable-diffusion.cpp
mkdir build && cd build
cmake .. -DGGML_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j20

# Successful build log:
# -- Found Vulkan: C:/VulkanSDK/1.4.341.1/Lib/vulkan-1.lib
# [100%] Built target sd-server ✅

# Start SD server (SD 1.5)
E:
cd "E:\stable-diffusion.cpp\build\bin\Release"
.\sd-server.exe --listen-ip 0.0.0.0 --listen-port 7860 `
  -m "E:\models\dreamshaper8.gguf"

# Server output confirms GPU:
# ggml_vulkan: 0 = AMD Radeon RX 580 2048SP | VRAM: 8192MB
# Server listening on http://0.0.0.0:7860 ✅

Flag compatibility note: Older builds use --host / --port. Newer builds (master-600+) use --listen-ip / --listen-port. Run sd-server.exe --help to check which your build expects.

---

FLUX Hybrid Setup (GPU + CPU)

FLUX.1 Schnell requires ~16GB total. The strategy: put the diffusion model on VRAM, offload T5XXL and VAE to RAM.

sd-server.exe --listen-ip 0.0.0.0 --listen-port 7860 ^
  --diffusion-model "E:\models\flux1-schnell-q4_k.gguf" ^
  --vae "E:\models\ae.safetensors" ^
  --clip_l "E:\models\clip_l.safetensors" ^
  --t5xxl "E:\models\t5xxl_fp16.safetensors" ^
  --cfg-scale 1.0 --steps 4 --clip-on-cpu --vae-on-cpu --vae-tiling

--vae-tiling is not optional — without it, VAE decode causes OOM and crashes the server. To save RAM: replace t5xxl_fp16 (~9.3GB) with t5xxl_fp8 (~5GB).

Timing per image (1024×1024):

Full memory architecture: docs/flux-setup.md

---

OpenWebUI + Docker Integration

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Connect LLM server:

1. Go to http://localhost:3000 → Admin Panel → Settings → Connections
2. Under OpenAI API, add:
   • URL: http://host.docker.internal:8081/v1
   • API Key: sk-local
3. Green badge = connected ✅

Connect image server:

1. Settings → Images → Engine: Automatic1111
2. URL: http://192.168.x.x:7860/ (use your local IP, not 127.0.0.1, with trailing slash)

Never use 127.0.0.1 for Docker connections — Docker runs in an isolated network and cannot reach the host's localhost. Use host.docker.internal for services, or your machine's LAN IP.

Windows Firewall fix (Docker subnet blocked by default):

# Run as Administrator
New-NetFirewallRule -DisplayName "sd-server AIVisionsLab" `
  -Direction Inbound -Protocol TCP -LocalPort 7860 -Action Allow

Full networking guide: docs/firewall-fix.md

---

whisper.cpp: Audio Transcription on RX 580

Vulkan-accelerated audio transcription. The large-v3-turbo model uses only 2.6GB of VRAM — plenty of headroom.

Compile (Developer PowerShell):

# Activate MSVC environment first (required each session)
& "C:\Program Files (x86)\Microsoft Visual Studio\...\vcvars64.bat"

cd C:\
git clone https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
cmake -B build -DGGML_VULKAN=ON -DGGML_HIPBLAS=OFF -DGGML_HIP=OFF -DGGML_CUDA=OFF
cmake --build build --config Release -j4

Download model:

Invoke-WebRequest `
  -Uri "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin" `
  -OutFile "models\ggml-large-v3-turbo.bin"

Transcribe (MP4 → TXT):

# Step 1: Extract audio (Whisper requires WAV on Windows)
ffmpeg -i "video.mp4" -ar 16000 -ac 1 -c:a pcm_s16le "audio.wav"

# Step 2: Transcribe
.\build\bin\Release\whisper-cli.exe `
  -m models\ggml-large-v3-turbo.bin `
  -f "audio.wav" -l pt --output-txt

# With translation to English:
.\build\bin\Release\whisper-cli.exe `
  -m models\ggml-large-v3-turbo.bin `
  -f "audio.wav" -l pt --translate --output-txt

Performance (15-min video, Windows):

VRAM used: 2.6GB of 8GB. CPU stays at ~5%.

⚠️ WSL2 does not expose the RX 580 to Vulkan — always use native Windows PowerShell for GPU transcription. ⚠️ --translate only outputs English. For other target languages, add a translation step after.

---

Applio RVC: Voice Cloning on AMD Windows

Full pipeline: Text → Balabolka (TTS) → WAV → Applio RVC (voice conversion) → final audio

Why this pipeline instead of pure TTS:

Key findings for AMD Windows (2026):

DirectML acceleration is effectively dead — torch-directml requires torch==2.4.1 while Applio requires torch==2.7.1. The version conflict is irreconcilable. Use CPU mode — it works, just takes time.

Training speed on Xeon E5-2690 v3: ~6 min/epoch. 200 epochs = ~20 hours.

Critical gotchas:

# NEVER set these — they silently break feature extraction:
# set CUDA_VISIBLE_DEVICES=-1
# set ROCM_VISIBLE_DEVICES=-1
# They leave logs/project/extracted/ empty, training "succeeds" but produces nothing.

# Always verify after extraction:
dir logs\my-project\extracted\   # Must contain .npy files

Create required mute files (missing from git install):

python -c "
import numpy as np, soundfile as sf, os
[os.makedirs(d, exist_ok=True) for d in [
    'logs/mute/sliced_audios','logs/mute/extracted',
    'logs/mute/f0','logs/mute/f0_voiced'
]]
sf.write('logs/mute/sliced_audios/mute40000.wav', np.zeros(int(40000*3.7)), 40000)
sf.write('logs/mute/sliced_audios/mute48000.wav', np.zeros(int(48000*3.7)), 48000)
np.save('logs/mute/extracted/mute.npy', np.zeros((196, 768)))  # shape (196,768) critical
np.save('logs/mute/f0/mute.wav.npy', np.zeros(100))
np.save('logs/mute/f0_voiced/mute.wav.npy', np.zeros(100))
print('OK')
"

Full guide: docs/applio-rvc.md

---

AnimateDiff: Video Generation

AnimateDiff injects temporal attention modules into SD 1.5, converting still-image diffusion into coherent video loops. Runs on Xeon CPU via ComfyUI in WSL2.

# WSL2 Ubuntu
conda activate comfy_env
python main.py --cpu --listen 0.0.0.0 --port 8188

Access from Windows: http://localhost:8188

Performance: ~141 seconds per frame on Xeon E5-2690 v3 (24 threads).

---

Linux Native: Ubuntu 26.04 LTS

Bare-metal Linux (no WSL2, no Docker GPU passthrough) with Mesa RADV open-source drivers.

System: Ubuntu 26.04 LTS (Resolute Raccoon), Kernel 7.0, Mesa RADV 26.0.3, Vulkan 1.4.341

Validate GPU:

lspci | grep -i vga
# AMD Radeon RX 580 2048SP detected

vulkaninfo --summary 2>/dev/null | grep -A5 "Devices"
# GPU0: DRIVER_ID_MESA_RADV | driverInfo = Mesa 26.0.3 ✅

LLM server:

~/llama.cpp/build/bin/llama-server \
  -m "/run/media/user/NVMe/models/Qwen3-4B-Q4_K_M.gguf" \
  --host 0.0.0.0 --port 8081 \
  -ngl 99 -t 24

FLUX image server:

~/stable-diffusion.cpp/build/bin/sd-server \
  --listen-ip 0.0.0.0 --listen-port 7860 \
  --diffusion-model /path/to/flux1-schnell-q4_k.gguf \
  --vae /path/to/ae.safetensors \
  --clip_l /path/to/clip_l.safetensors \
  --t5xxl /path/to/t5xxl_fp16.safetensors \
  --cfg-scale 1.0 --steps 4 --clip-on-cpu --vae-on-cpu --vae-tiling

--vae-tiling is mandatory on Linux too — without it, VAE decode crashes the GNOME display server. Avoid --backend vulkan0 for heavy models on Linux — causes context-loss bugs.

Whisper transcription:

~/whisper.cpp/build/bin/whisper-cli \
  -m ~/whisper.cpp/models/ggml-large-v3-turbo.bin \
  -f "audio.wav" -l pt --output-txt

Docker services running in parallel:

⚠️ ROCm is not usable on Polaris/GCN4. AMD dropped support. Running Ollama with GPU via Docker on RX 580 will fail. Use llama-server compiled with Vulkan instead, and keep Docker for frontends only.

---

Windows vs Linux Benchmarks

Why Linux is faster for LLM: Mesa RADV allows up to 20 GPU layers for the 35B model where Windows AMD drivers cap at 10. For smaller models, RADV's memory management is simply more efficient.

Why Windows wins SD 1.5: The proprietary AMD driver has more stable direct rendering for this specific workload.

Whisper gap explained: Mesa RADV's Vulkan compute path for whisper.cpp is significantly more optimized than the Windows AMD driver equivalent. A 13× speedup on the same GPU, same model.

---

Troubleshooting

generate_image returned no results / frozen terminal Cause: sd-server integer overflow bug with random seeds (Seed: -1). Fix: Set a fixed integer seed in OpenWebUI advanced options (e.g., 42, 1337).

Model trained successfully instantly (Applio) This is a silent failure. Training completes in seconds and produces nothing. Cause: CUDA_VISIBLE_DEVICES=-1 or similar environment variables were set, breaking feature extraction. Fix: Open a clean PowerShell with no prior set commands. Verify logs/project/extracted/ contains .npy files after extraction before starting training.

FLUX OOM / DeviceMemoryAllocation crash Fix: Ensure --vae-tiling flag is present. Confirm T5XXL is on CPU (--clip-on-cpu --vae-on-cpu). Consider switching to t5xxl_fp8 to save ~4.3GB RAM.

new_sd_ctx_t failed with FLUX GGUF You're using a city96 GGUF. These only work in ComfyUI with the ComfyUI-GGUF node. Fix: Download from leejet's repo instead.

Docker can't reach sd-server or llama-server Cause: Windows Defender blocks Docker's 172.x.x.x subnet by default. Fix: See OpenWebUI + Docker Integration — add the firewall rule.

Compilation errors in WSL2 for Vulkan builds WSL2 does not expose the RX 580 for Vulkan compute. Compile and run GPU workloads from native Windows PowerShell only. Use WSL2 exclusively for CPU workloads (ComfyUI, Applio, Ollama CPU fallback).

--override-tensor exps=CPU slows down inference on Vulkan This flag is optimized for CUDA/PCIe on Nvidia. Under Vulkan, the CPU↔GPU memory transfer overhead destroys any MoE offloading gains. Do not apply CUDA-optimized flags to Vulkan backends.

---

Automation Scripts

Save as iniciar_ia_server.bat on the Desktop:

@echo off
title Servidor IA Local - Producao
cls

:: Kill ghost processes holding VRAM/ports
taskkill /f /im sd-server.exe 2>nul
taskkill /f /im llama-server.exe 2>nul
timeout /t 2 /nobreak >nul

:: Start LLM server (Vulkan)
start "LLM Server - Vulkan RX580" C:\llama.cpp\build\bin\Release\llama-server.exe ^
  -m "E:\models\Mistral-7B-Q4_K_M.gguf" ^
  --host 0.0.0.0 --port 8081 --device Vulkan0

timeout /t 3 /nobreak >nul

:: Start SD server (Vulkan)
E:
cd "E:\stable-diffusion.cpp\build\bin\Release"
sd-server.exe --listen-ip 0.0.0.0 --listen-port 7860 ^
  -m "E:\models\dreamshaper8.gguf"

pause

Critical rules:

• taskkill before start: releases VRAM from stuck background processes
• --host 0.0.0.0: required for Docker to reach the server
• --device Vulkan0: without this, inference falls back to CPU (3–5 tok/s)
• Never use .\ before executables in CMD — it breaks the shell
• Jump drive (E:) before cd — CMD doesn't change drives automatically

---

Vulkan Diagnostics

Instant validation scripts — run before building anything.

# Linux / WSL2
./vulkan-diagnostic.sh

:: Windows CMD
vulkan-diagnostic.bat

Expected output:

ggml_vulkan: Found 1 Vulkan device(s)
ggml_vulkan: 0 = AMD Radeon RX 580 2048SP | VRAM: 8192MB  ✅

If your card doesn't appear — driver or Vulkan SDK issue. See Master Documentation.

---

Community Timeline

Three independent researchers. Same GPU. Same conclusion: the hardware was never the problem.

The shared technical foundation: ggml / llama.cpp / stable-diffusion.cpp by Georgi Gerganov. Vulkan compute backends in pure C++ that bypass the entire ROCm/CUDA ecosystem.

Credit: 艾米心 (Amihart), DH (DadHacks), leejet, ggerganov, woodrex, and all independent developers working on hardware preservation and open inference.

---

Pushing the 35B Limit: Qwen3.5 MoE Hybrid Experiment

Two lab sessions pushed the dual-path stack to its extreme: running a 34.66B-parameter MoE model (Qwen3.5-35B) on the same RX 580 8GB, using llama.cpp's automatic GPU/RAM fitting across 4 memory tiers (VRAM → DDR4 ECC → NVMe → HDD swap).

Quick links — six focused docs, one question each:

Full narrative lab reports (raw logs, timelines, complete test history):

• 📄 docs/qwen35-35b-hybrid-experiment.md (Session 1)
• 📄 docs/qwen35-35b-proving-hypothesis.md (Session 2)

Key takeaway: the RX 580 never crashed or throttled across either session (peak 80°C, limit ~90°C). Every failure traced back to software-side timeouts and context-buffer limits — not hardware capacity. With --ctx-size 8192 and Q4_K_M quantization, a 35B MoE model runs stable, full responses included, entirely on a 2017 GPU.

GPU from 2017 + CPU from 2014  ──►  34.66B parameters  ──►  5.6–6.6 tok/s

---

Repository Structure

rx580-local-ai-guide/
│
├── scripts/
│   ├── start-ai.bat              # Full stack — all services
│   ├── iniciar_sd_server.bat     # SD 1.5 only
│   ├── iniciar_flux_server.bat   # FLUX hybrid GPU/CPU
│   ├── reboot_stack.bat          # Kill all + restart
│   ├── vulkan-diagnostic.bat     # Vulkan validation (Windows)
│   ├── vulkan-diagnostic.sh      # Vulkan validation (Linux/WSL2)
│   ├── build-llamacpp.sh         # Compile llama.cpp (Linux/WSL2)
│   └── build-sdcpp.sh            # Compile stable-diffusion.cpp
│
├── docs/
│   ├── benchmarks.md             # Real hardware logs, full tables
│   ├── what-failed.md            # DirectML, ROCm, OpenVINO autopsy
│   ├── flux-setup.md             # FLUX hybrid memory architecture
│   ├── firewall-fix.md           # Docker + Windows Firewall
│   ├── wsl2-setup.md             # ComfyUI CPU on WSL2
│   ├── applio-rvc.md             # Voice cloning full guide
│   ├── whisper-cpp.md            # Audio transcription guide
│   ├── linux-ubuntu2604.md       # Ubuntu 26.04 bare-metal guide
│   ├── qwen35-35b-hybrid-experiment.md     # 35B MoE hybrid limit test — full log (Session 1)
│   ├── qwen35-35b-proving-hypothesis.md    # 35B MoE ctx-size/curl proof — full log (Session 2)
│   └── qwen35-35b/                         # Atomic SEO-focused docs, one question per page
│       ├── README.md
│       ├── running-35b-on-8gb-vram.md
│       ├── benchmarks.md
│       ├── thinking-mode-context-overflow.md
│       ├── openwebui-timeout-vs-server-truncation.md
│       ├── ctx-size-and-quantization-tuning.md
│       └── model-reasoning-about-its-own-architecture.md
│
├── vulkan-diagnostic.bat         # Quick validation (root, Windows)
├── vulkan-diagnostic.sh          # Quick validation (root, Linux)
└── README.md

---

Related Projects

• llama.cpp — The engine behind LLM inference
• stable-diffusion.cpp — Image generation in C++
• whisper.cpp — Audio transcription in C++
• OpenWebUI — The chat/image interface
• AIVisionsLab Portal — Full documentation (PT/EN)

---

Contributing

This guide is built from real hardware testing, real error logs, and real failures. If you:

• Got this working on a related card (RX 570, RX 590, RX 5500 XT)
• Found better build flags or quantization settings for Vulkan
• Have benchmarks from a different CPU/RAM configuration
• Fixed a bug in the scripts

Open a PR or issue. Everything here is MIT licensed — use it, fork it, share it.

---

License

MIT — do whatever you want with this. Just don't tell people their old GPU is useless.

---

Built in São Paulo, Brazil 🇧🇷 · Hardware from 2014–2017 · Running SOTA AI in 2026

"The problem was never the GPU."