Z-Image-Turbo-GGUF by leejet

Z-Image-Turbo-GGUF by leejet

Generates images from text on modest GPUs, using quantized Z-Image-Turbo files made for stable-diffusion.cpp. For people who run image models on their own computer.

Made by leejet on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This repository holds quantized GGUF copies of Z-Image-Turbo from Tongyi-MAI, a text to image model with 6.2 billion parameters. leejet converted them with stable-diffusion.cpp, and you use them with that same program. The record lists English and Chinese, and about 3.1 GB at 4-bit by estimate.

Who it suits: It suits people who want to make pictures from text on their own machine, including those with a small graphics card. The card points to a guide for a GPU with only 4 GB of video memory.

Industry | Who uses it | How they use it | Example
Design | Illustrators and concept artists | Generate moody scenes from a text prompt on a home PC | A night city photo with neon light and a quote across it
Marketing | Small marketing teams | Make draft visuals without a cloud service | A quick poster background
Software | Developers | Run the model from a command line in scripts | A batch of renders with fixed settings
Hobby | Local AI fans | Try different quantization types on limited hardware | Compare a q8_0 render with a q4_K one

People who want a chat model or an app with a ready interface can skip it, since this is a set of model files for a command line tool.

Where to use it:

• stable-diffusion.cpp, the program the files were converted for
• Windows, macOS or Linux with Python, for downloading the files
• A GPU with as little as 4 GB of video memory, following the guide the card names

Use case | Who | What they get back
Text to image on a small GPU | Hobbyists | A generated picture from a written prompt
Size and quality trade-offs | Tinkerers | Eight quantization types to compare, from bf16 down to q2_K
Scripted image runs | Developers | Image files written by one command per prompt

How to set it up: You need a few things first.

• Python and pip, for the Hugging Face hub tool
• A stable-diffusion.cpp build that provides the sd program
• A VAE file and a Qwen3-4B-Instruct GGUF file, both named in the card's example command

1. Install the hub tool and download the repository files.
2. Get the extra VAE and language model files the example names.
3. Point the command at your quantized file, the VAE and the language model.

pip install -U huggingface_hub
hf download leejet/Z-Image-Turbo-GGUF

How to use it: You run one command with your prompt and the paths to the three model files. The card gives this Windows example, where -H and -W set the image size.

Put your own value in its key setting first.

Tool | What it does
sd.exe | The stable-diffusion.cpp program that generates the image
--diffusion-model | Points to the quantized GGUF file
--vae | Points to the VAE file, ae.safetensors in the example
--llm | Points to the language model file the command uses
-p | Holds the prompt text
-H and -W | Set the image height and width, 1024 and 512 in the example
--cfg-scale | Sets the guidance strength, 1.0 in the example

Example: You ask for a moody night photo of a lone hooded figure in a wet neon city, with a philosophical line printed across it, and run the command above. It generates one image, 1024 high and 512 wide, from that prompt using the Q3_K file.

For newcomers and experts: GGUF is a compact way to package a model so it runs on smaller machines, and each quantization type trades some fidelity for size. If you are new, run the card's example command first with the Q3_K file, then swap in a larger type to compare.

The files are conversions of the original Z-Image-Turbo made with stable-diffusion.cpp, and their license follows the original. The card shows sample renders for eight types, from bf16 and q8_0 down to q3_K and q2_K, so you can judge the loss yourself. The example also turns on CPU offloading, which suits cards with little memory.

Prompt goes through the language model file
Quantized diffusion model builds the image
VAE turns the result into pixels
Image is written to a file

Good to know:

• License: Apache 2.0, the same as the original Z-Image-Turbo.
• Cost to run: no API key or paid service named. You supply the hardware and the extra VAE and language model files.
• Data it reaches: the model files you download and the image files you write to disk.
• Not for: use outside stable-diffusion.cpp, since the card names only that program. It is also not a ready app, only the model files.

On Hugging Face, 13 November 2026

• Task: text to image
• Parameters: 6.2B
• Weights: about 3.1 GB at 4-bit (estimate)
• Formats: GGUF
• Downloads in the last 30 days: 268,204
• Likes: 63
• License: apache-2.0
• Languages: en, zh
• Based on: Tongyi-MAI/Z-Image-Turbo
• Tags: gguf, text-to-image, image-generation, stable-diffusion.cpp, z-image-turbo, z-image

Links

• Model: https://huggingface.co/leejet/Z-Image-Turbo-GGUF
• Files: https://huggingface.co/leejet/Z-Image-Turbo-GGUF/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download leejet/Z-Image-Turbo-GGUF

Then follow the usage in its model card. Nothing in this kit runs by itself.