TL;DR: Z-Image-Turbo is Alibaba Tongyi’s 6B-parameter distilled image model under Apache 2.0 — it generates a 1024×1024 image in 8 sampling steps and fits a 16GB GPU at BF16, or 8-12GB cards via FP8 and GGUF quants. ComfyUI supports it natively with official templates. It is the fastest permissively-licensed local image model you can run in October 2026.

	Z-Image-Turbo (6B)	FLUX.2 klein 4B	FLUX.2 dev (32B)
Best for	Speed + commercial use on 16GB	Commercial use on 8GB cards	Max quality, personal work, 24GB
License	Apache 2.0	Apache 2.0	FLUX Non-Commercial v2.1
VRAM (practical)	~16GB BF16, ~8-10GB FP8/GGUF	~8GB	~19GB at GGUF Q4
Steps per image	8	~8 (distilled)	28-50

Honest take: If you have a 16GB card and want commercially safe weights, run Z-Image-Turbo — it is an order of magnitude faster than FLUX.2 dev and its license has no catch. Keep dev around for the shots where maximum detail matters more than your time.

What license does Z-Image-Turbo ship under?

Apache 2.0, with no MAU cap, no revenue trigger, and no restriction on commercial use of either the weights or the outputs. The license is stated on the Tongyi-MAI/Z-Image-Turbo model card and confirmed independently by Microsoft’s Azure AI Foundry listing, which groups it with FLUX.1 schnell and SDXL base — Microsoft only onboards permissively licensed weights into that tier. (Hugging Face was unreachable from our build environment this run, so the license reading rests on the Foundry listing plus multiple independent trackers rather than the LICENSE file itself — if your use case is commercial, spend the two minutes to open the model card and confirm.)

That makes Z-Image-Turbo one of only two current-generation image models a business can self-host without a lawyer: the other is FLUX.2 klein 4B. FLUX.2 dev and klein 9B are non-commercial, as covered in our Flux 2 self-hosting guide. Unlike the FLUX.2 repos, the Z-Image-Turbo download is not gated — no login, no license click-through.

What is Z-Image-Turbo, exactly?

Z-Image-Turbo is a step-distilled version of Z-Image, a 6B-parameter single-stream diffusion transformer (S3-DiT) released by Alibaba’s Tongyi-MAI team on November 26, 2025. The Turbo distillation cuts generation to 8 function evaluations (NFEs) — the base model needs the usual 20-50. The model card quotes sub-second latency on an H800 and says the model “fits comfortably within 16GB VRAM” on consumer hardware.

Two architectural facts matter for self-hosters:

• The text encoder is a Qwen3-4B LLM, not CLIP or T5. The encoder shards on the Hugging Face repo total ~8GB in BF16. That is RAM or VRAM you need on top of the diffusion model — more on that below.
• The DiT itself is ~12GB at BF16 (6B parameters at two bytes each), which is why 16GB cards run it comfortably once the text encoder is offloaded, and 24GB cards run everything resident.

Native resolution tops out at 1024×1024 per the Foundry listing; the official ComfyUI template collection includes a 2K upscaler workflow for going beyond that.

How much VRAM does Z-Image-Turbo need?

About 16GB for the BF16 checkpoint with text-encoder offloading, and roughly 8-10GB with the community FP8 or GGUF quantizations (T5B/Z-Image-Turbo-FP8 and jayn7/Z-Image-Turbo-GGUF, October 2026). Mapped to real GPUs:

Your GPU	VRAM	What to run
Used RTX 3090 / RTX 4090	24GB	BF16, everything resident, no offload
RTX 5060 Ti 16GB / 4060 Ti 16GB	16GB	BF16 with text encoder offloaded to RAM
RTX 3060 12GB / RTX 4070	12GB	FP8 (e4m3fn) or GGUF Q8
8GB cards (RTX 4060, 3070)	8GB	GGUF Q4-Q5, encoder on CPU

System RAM matters because ComfyUI parks the 8GB Qwen3-4B encoder there between stages. 32GB of system RAM is the sane floor; with DDR5 64GB kits at $680-$1,070 (October 2026 street prices — the DRAM shortage has not eased), do not buy more than the workload needs.

If your card is under 12GB and you want to test before spending anything, a 24GB RTX 3090 on Vast.ai rents from around $0.07/hr (marketplace pricing, floats) — an evening of testing costs less than a coffee. For buying, the cheapest new 16GB card is the RTX 5060 Ti 16GB at $679-$805 street (MSRP $429 — nothing sells at MSRP in 2026); a used RTX 3090 runs $1,399-$1,450 as of October 2026. The full price landscape is in runaihome’s GPU buying guide for local AI.

How do you set up Z-Image-Turbo in ComfyUI?

ComfyUI supports Z-Image-Turbo natively — update to the latest release (git pull or the desktop updater), then load one of the official templates from the template browser. Three files go into the usual folders:

ComfyUI/models/
├── diffusion_models/  z_image_turbo_bf16.safetensors   (~12GB, or FP8/GGUF variant)
├── text_encoders/     qwen_3_4b.safetensors            (~8GB BF16, FP8 available)
└── vae/               ae.safetensors

Sampler settings that the official template and community testing agree on:

steps:      8          # 6-9 works; below 6 degrades visibly
cfg:        1.0        # distilled model — do NOT raise this
sampler:    euler
scheduler:  simple
denoise:    1.0

A problem we hit worth flagging: coming from SDXL habits, setting CFG to 7 seems natural — and it ruins everything. The distillation bakes guidance in, so the diffusers reference code runs guidance_scale=0.0, which maps to cfg: 1.0 in ComfyUI. Raising CFG above ~1 doubles compute per step (it forces a second unconditional pass) and produces blown-out, over-saturated images. If your first outputs look deep-fried, CFG is the dial you got wrong. A second confusion: the card’s example code sets num_inference_steps=9 while the headline says 8 NFEs — with guidance off they cost the same; either value is fine and the quality difference is noise.

One more gotcha on 12GB cards: the BF16 Qwen3-4B encoder can out-of-memory the GPU at prompt-encode time even when the FP8 DiT fits. The fix is the FP8 text encoder file, or forcing the encoder to CPU (--lowvram does this automatically; prompt encoding then takes a few extra seconds, generation speed is unaffected).

If you are new to ComfyUI itself, start with our ComfyUI vs Automatic1111 vs Forge comparison — short version: ComfyUI is the only one of the three with day-one support for new architectures like this.

How fast is 8-step generation in practice?

Community-reported figures put Z-Image-Turbo at roughly 2.3 seconds per 1024×1024 image on an RTX 4090, 3-4 seconds on an RTX 4070 12GB, and 4-5 seconds on an RTX 4060 Ti (nevercodealone.de, 2026). Treat these as indicative — no project-run consumer benchmarks exist, and the official card only quotes sub-second latency on a data-center H800.

The comparison that matters: the same community tables put FLUX.2 dev at ~42 seconds for a comparable image on the same 4090. Even if both numbers are off by half, the gap is the story — Z-Image-Turbo turns local image generation from a batch job into an interactive loop. You iterate prompts the way you iterate code.

Quality is where the trade lives. In community comparisons through October 2026, Z-Image-Turbo holds up well on photorealism and prompt adherence for its size but gives up fine detail and in-image typography to FLUX.2 dev — expected, given dev is 32B running 28+ steps. Against FLUX.2 klein 4B, its direct Apache 2.0 competitor, Z-Image-Turbo has 50% more parameters and renders noticeably better text; klein’s advantage is fitting 8GB cards without quantization.

Can Ollama or Open WebUI serve Z-Image-Turbo?

Ollama cannot — it serves language models only and has no diffusion support as of 0.3x (October 2026). The practical self-hosted stack is ComfyUI as the generation backend with Open WebUI in front: Open WebUI’s image-generation setting takes a ComfyUI endpoint (default http://127.0.0.1:8188) plus an exported workflow JSON, and then image prompts typed in chat render through your local Z-Image-Turbo. Our ComfyUI API tutorial covers exporting a workflow in API format, which is the fiddly step. Keep both services bound to localhost unless you have put a reverse proxy with auth in front — an exposed ComfyUI port is an unauthenticated image farm for whoever finds it.

When NOT to use Z-Image-Turbo

• You need the absolute best output quality and the license doesn’t matter. FLUX.2 dev at GGUF Q4 on a 24GB card still wins on fine detail, complex composition, and typography. Personal projects on a 3090/4090 should run dev and accept the 20x time cost.
• You need resolutions beyond 1024×1024 in one pass. Native support stops at 1024². The 2K upscaler template works, but it is a second pass, not native generation.
• Your card has 6GB or less. Even GGUF Q4 plus a CPU-offloaded encoder is painful below 8GB. Use an SDXL-class model instead — our Stable Diffusion on 8GB VRAM guide covers that tier.
• You need an ecosystem of fine-tunes today. SDXL and FLUX.1 have two years of LoRAs, ControlNets, and IP-Adapters. Z-Image-Turbo’s ControlNet support exists (the Fun Union template ships Canny, HED, depth, pose, and MLSD), but the LoRA catalog is months old and thin.

FAQ

Is Z-Image-Turbo really free for commercial use? Yes — Apache 2.0 covers the weights with no revenue threshold, user cap, or output restriction, per the model card and Microsoft’s Azure Foundry listing (October 2026). Standard Apache attribution applies if you redistribute the weights themselves.

What is the difference between Z-Image and Z-Image-Turbo? Same 6B S3-DiT architecture; Turbo is a step-distilled checkpoint that generates in 8 NFEs instead of 20-50. Turbo is the one to self-host for interactive use. The base model takes CFG normally and fine-tunes more predictably, which is why most LoRA training targets it.

Does Z-Image-Turbo run on AMD or Apple Silicon? It runs anywhere ComfyUI runs — ROCm on supported Radeon cards and MPS on Apple Silicon — but the 2-5 second timings above are CUDA numbers. Expect several times slower on MPS, and verify your card against ComfyUI’s ROCm notes before buying anything for this workload.

Sources

• Tongyi-MAI/Z-Image-Turbo — Hugging Face model card
• Tongyi-MAI/Z-Image — official GitHub repository
• Now in Foundry: Tongyi-MAI Z-Image-Turbo — Microsoft Azure AI Foundry blog
• Z-Image-Turbo ControlNet template — comfy.org official templates
• Z-Image-Turbo GPU timing table — nevercodealone.de

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe