Z-Image-Turbo and Flux 2 Klein 4B: Local Image Generation on AMD iGPU and CPU with stable-diffusion.cpp

Two Models, One Engine

The diffusion model landscape has shifted fast. In late 2025 and early 2026, two compact models arrived that challenge the assumption that you need a high-end NVIDIA GPU for local image generation:

• Z-Image-Turbo — released by Comfy-Org in December 2025. A distilled model that generates images in 3 steps. Uses the FLUX.1-schnell VAE and a Qwen3-4B text encoder.
• Flux 2 Klein 4B — released by Black Forest Labs in January 2026. A 4B-parameter rectified flow transformer that generates images in 4 steps. Apache 2.0 license. Supports both text-to-image and image editing.

Both are designed for speed on consumer hardware. Both use the same Qwen3-4B text encoder. And both can run through the same tool: stable-diffusion.cpp.

Why stable-diffusion.cpp?

The standard Python approach is diffusers + PyTorch. PyTorch supports CUDA (NVIDIA), ROCm (AMD discrete GPUs), and CPU. It has no Vulkan backend. On an AMD Ryzen laptop with integrated graphics — no discrete GPU — that leaves CPU only.

stable-diffusion.cpp is the ggml-based equivalent of llama.cpp, but for image generation. It supports:

• Vulkan — works on virtually any GPU, including integrated AMD graphics
• CPU — with AVX2, FMA, and F16C optimizations
• Multiple models — SD1.x, SDXL, FLUX.1, FLUX.2, Z-Image, Wan, Chroma, and more
• GGUF quantization — same format as llama.cpp, with Q2_K through BF16

Same philosophy: run locally, no server, no cloud, no vendor lock-in.

Building stable-diffusion.cpp

We build two versions — CPU-only and Vulkan — from the same source. The CPU build enables SIMD flags that matter on AMD Zen 2 processors:

1
git clone --recursive https://github.com/leejet/stable-diffusion.cpp
2
cd stable-diffusion.cpp
3

4
# CPU-only build (with SIMD feature flags)
5
mkdir build-cpu && cd build-cpu
6
cmake .. \
7
  -DGGML_VULKAN=OFF \
8
  -DGGML_AVX2=ON \
9
  -DGGML_FMA=ON \
10
  -DGGML_F16C=ON \
11
  -DCMAKE_BUILD_TYPE=Release
12
cmake --build . --config Release -j$(nproc)
13

14
# Vulkan build
15
cd ..
16
mkdir build-vulkan && cd build-vulkan
17
cmake .. -DSD_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
18
cmake --build . --config Release -j$(nproc)

Use the Vulkan build when you have enough VRAM (discrete GPUs, or iGPU at 256x256). Use the CPU build when VRAM runs out or when you want higher resolutions. Both share the same model files.

Model Architecture

Both models follow the same three-component architecture. The key difference is the diffusion model and the VAE — the text encoder is shared:

The text encoder is the same file on disk — symlinked, not duplicated. The VAEs are different: Z-Image-Turbo uses the FLUX.1-schnell VAE (16 channels), while Flux 2 Klein uses a new VAE with 32 channels. Swapping them causes a tensor shape mismatch at load time.

Downloading the Models

1
mkdir -p ~/models/z-image-turbo
2
cd ~/models/z-image-turbo
3

4
# Diffusion model (GGUF, Q4_K quantization)
5
# Source: leejet/Z-Image-Turbo-GGUF — official quantizations by stable-diffusion.cpp author
6
hf download leejet/Z-Image-Turbo-GGUF z_image_turbo-Q4_K.gguf --local-dir .
7

8
# Alternative: unsloth/Z-Image-Turbo-GGUF — wider quant selection (Q4_K_M, Q5_K_S, etc.)
9
# Note: uses hyphens in filenames (z-image-turbo-Q4_K_M.gguf), files are larger
10
# hf download unsloth/Z-Image-Turbo-GGUF z-image-turbo-Q4_K_M.gguf --local-dir .
11

12
# Alternative: TwinFlow variant (experimental, Q4_0) by wbruna
13
# hf download wbruna/TwinFlow-Z-Image-Turbo-sdcpp-GGUF TwinFlow_Z_Image_Turbo_exp-Q4_0.gguf --local-dir .
14

15
# VAE (FLUX.1-schnell VAE — ungated mirror from Comfy-Org)
16
hf download Comfy-Org/z_image_turbo split_files/vae/ae.safetensors --local-dir .
17

18
# Text encoder
19
hf download unsloth/Qwen3-4B-Instruct-2507-GGUF \
20
  Qwen3-4B-Instruct-2507-Q4_K_M.gguf --local-dir .

1
mkdir -p ~/models/flux2-klein-4b
2
cd ~/models/flux2-klein-4b
3

4
# Diffusion model (GGUF, Q4_K_M quantization)
5
hf download unsloth/FLUX.2-klein-4B-GGUF flux-2-klein-4b-Q4_K_M.gguf --local-dir .
6

7
# Flux 2 VAE (NOT the same as FLUX.1 VAE)
8
hf download Comfy-Org/vae-text-encorder-for-flux-klein-4b \
9
  split_files/vae/flux2-vae.safetensors --local-dir .
10

11
# Symlink the shared text encoder
12
ln -s ../z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf .

1
~/models/
2
  z-image-turbo/
3
    z_image_turbo-Q4_K.gguf            3.9 GB
4
    split_files/vae/ae.safetensors     335 MB
5
    Qwen3-4B-Instruct-2507-Q4_K_M.gguf 2.5 GB
6
  flux2-klein-4b/
7
    flux-2-klein-4b-Q4_K_M.gguf       2.6 GB  (unique)
8
    split_files/vae/flux2-vae.safetensors 336 MB (unique)
9
    Qwen3-4B-Instruct-2507-Q4_K_M.gguf → symlink (shared)
10
                                        ─────
11
    Total unique:                      ~9.7 GB
12
    (saved 2.5 GB by symlinking the text encoder)

Generation: Z-Image-Turbo

Z-Image-Turbo needs only 3 steps and uses CFG scale 1:

1
# CPU — 1024x1024
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/z_image_turbo-Q4_K.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "a lovely cat sitting on a windowsill, golden hour lighting" \
9
  -H 1024 -W 1024 -t 12

jemalloc preload helps with memory fragmentation on long runs. The -t 12 flag sets CPU thread count.

Using the same prompt as Flux 2 Klein, the following image was generated on CPU at 1024x576 in 12 minutes 19 seconds:

1
# CPU — 1024x576 (sample output)
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/z_image_turbo-Q4_K.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024 \
14
  -o z-image-turbo-sample.png

1
# CPU — 1024x576 (TwinFlow variant, sample output)
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/TwinFlow_Z_Image_Turbo_exp-Q4_0.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024 \
14
  -o twinflow-sample.png

1
# CPU — 1024x576
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/z-image-turbo-Q4_K_M.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024

1
# CPU — 1024x576
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/z_image_turbo-Q4_K.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024

1
# CPU — 1024x576
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/z-image-turbo/z_image_turbo-Q4_0.gguf \
5
  --vae ~/models/z-image-turbo/split_files/vae/ae.safetensors \
6
  --llm ~/models/z-image-turbo/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 3 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024

Generation: Flux 2 Klein 4B

Flux 2 Klein needs 4 steps and also uses CFG scale 1. It’s a smaller model (2.6 GB diffusion) but compensates with an extra denoising step:

1
# CPU — 512x512
2
~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
3
  --diffusion-model ~/models/flux2-klein-4b/flux-2-klein-4b-Q4_K_M.gguf \
4
  --vae ~/models/flux2-klein-4b/split_files/vae/flux2-vae.safetensors \
5
  --llm ~/models/flux2-klein-4b/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
6
  --cfg-scale 1.0 --steps 4 \
7
  -p "a lovely cat sitting on a windowsill, golden hour lighting"

As a demonstration, the following image was generated on CPU at 1024x576 in 11 minutes 24 seconds:

1
# CPU — 1024x576 (sample output)
2
LD_PRELOAD=/usr/lib/libjemalloc.so.2 \
3
  ~/stable-diffusion.cpp/build-cpu/bin/sd-cli \
4
  --diffusion-model ~/models/flux2-klein-4b/flux-2-klein-4b-Q4_K_M.gguf \
5
  --vae ~/models/flux2-klein-4b/split_files/vae/flux2-vae.safetensors \
6
  --llm ~/models/flux2-klein-4b/Qwen3-4B-Instruct-2507-Q4_K_M.gguf \
7
  --cfg-scale 1.0 --steps 4 \
8
  -p "An AMD Ryzen laptop on a wooden desk, running a local AI image
9
     generation model, with two generated images displayed side by side
10
     on screen. Warm golden hour sunlight streaming through a nearby
11
     window. Shot at f/2.8 with shallow depth of field. Professional
12
     tech photography, minimalist aesthetic." \
13
  -H 576 -W 1024 \
14
  -o flux2-klein-hero.png

The prompt follows a structured approach with six sections: subject, visual details, lighting, depth/camera, background, and composition/style. Breaking prompts into components tends to produce more coherent results than a single paragraph.

Which Model Should You Use?

Key Takeaways

1. You don’t need an NVIDIA GPU. stable-diffusion.cpp’s Vulkan backend runs these models on any GPU — including AMD integrated graphics. For higher resolutions, the CPU build works everywhere.

2. Both models are distilled. Z-Image-Turbo needs 3 steps, Flux 2 Klein needs 4. That’s a massive speedup over the 20-50 steps of older diffusion models.

3. Share the text encoder. Both pipelines use Qwen3-4B. Setting up one model gives you ~65% of what you need for the other. Symlink it.

4. VAEs are NOT interchangeable. Z-Image-Turbo uses the 16-channel FLUX.1 VAE. Flux 2 Klein uses a new 32-channel VAE. Mixing them triggers a tensor shape mismatch.

5. AMD iGPU users hit a VRAM wall at 512x512. The Renoir’s 5.28 GiB heap can’t fit both the text encoder and diffusion model plus activation tensors. 256x256 works on Vulkan; 512x512+ needs CPU.

6. Build two versions of sd-cpp. The CPU build with AVX2/FMA/F16C flags is faster for CPU inference. The Vulkan build is faster when VRAM allows. Same models, different backends.

For the Giggles: Qwen Image via Cloud

The whole reason I got into testing local image generation is because I wanted to try Qwen Image locally. The problem? The model weights are 12+ GB. My laptop literally cannot handle that.

So I did the next best thing — used chat.qwen.ai to generate the same prompt with several Qwen models, both in “create image” mode and normal chat. Each image was generated in a few seconds on their servers.

An AMD Ryzen laptop on a wooden desk, running a local AI image generation model, with two generated images displayed side by side on screen. Warm golden hour sunlight streaming through a nearby window. Shot at f/2.8 with shallow depth of field. Professional tech photography, minimalist aesthetic.