Run Z-Image Turbo in ComfyUI on a cloud GPU

Z-Image Turbo is the image model I would start with when speed and a clean licence matter more than anything else: a 6B Apache-2.0 model from Alibaba's Tongyi Lab that makes an image in 8 steps, and its ComfyUI files come to 20.69 GB at full precision (our calculation). Tongyi says it fits comfortably on a 16 GB consumer card. Every QuantaCloud GPU has at least 48 GB, so on an RTX A6000 the extra memory does not decide whether Z-Image runs. It buys large batches, a second model loaded beside it, and room to train a LoRA.

The Z-Image models that exist#

The family has four names and two sets of weights. Tongyi's repository lists Turbo, Base, Omni-Base and Edit, and on 2026-11-12 its Hugging Face organisation held only the first two. The Edit and Omni-Base rows in Tongyi's own table still read "To be released", and its repository has had no commit since 2026-02-09.

Turbo and Base share one architecture: a single-stream diffusion transformer of 6.15B parameters, a Qwen3 4B text encoder and the FLUX.1 VAE. Tongyi highlights photorealism and English and Chinese text rendering for Turbo. Apache-2.0 means you may use the model and its images commercially, fine-tune it and redistribute it with the licence notice. For image editing today, use a model that has open weights, such as Qwen-Image-Edit-2511, and open-source image generation models compares Z-Image with FLUX.2, Qwen-Image and the rest.

The files and how much memory they take#

The files decide the setup, and they are small. These are the ones ComfyUI's own templates load, from Comfy-Org's repositories:

At 16-bit, Turbo's set is 20.69 GB, which is 19.27 GiB, under half of the 41.39 GiB I budget on a 48 GB card with ECC on (our calculation: 0.92 of the 44.99 GiB the card reports). The Int8 set is 12.17 GB. A 16 GB card can still run the 16-bit set because the text encoder only runs once per prompt, so ComfyUI can move it off the GPU before the 12.31 GB diffusion model samples. Two other figures are worth knowing. DiffSynth-Studio, the training and inference toolkit from the ModelScope project, says Turbo runs in 8 GB with CPU offload, and warns that FP8 quantization causes noticeable quality loss on Turbo, so it recommends offloading instead. Tongyi's README also points to stable-diffusion.cpp for cards with as little as 4 GB.

That warning shapes the file choice on QuantaCloud. On a 48 GB card there is no reason to quantize Turbo: load the 16-bit file. The INT8 file runs natively on every NVIDIA GPU in ComfyUI's code, so it is the one to try only if you need the memory for something else.

What a 48 GB card is for#

The honest answer is that Z-Image does not need it, so the question is what you do with the other 22 GiB.

The card I start on is the RTX A6000. The RTX 6000 Ada, L40 and L40S have the same 48 GB and FP8 compute, which Turbo at 16-bit does not use. ComfyUI GPU requirements compares Z-Image with the larger image and video models.

Launch ComfyUI and download the files#

The quickest route is QuantaCloud's ComfyUI template on an RTX A6000. Launch it, wait for Running, and connect over SSH as ubuntu. Running ComfyUI on a cloud GPU walks through the template and the install-it-yourself route.

Z-Image needs a ComfyUI recent enough for its templates: ComfyUI's template index gives the Turbo templates a minimum of 0.11.0 and the Base templates 0.23.0, and ComfyUI itself was at v0.45 on 2026-11-12. The version inside QuantaCloud's template is not published yet, so check it first:

curl -s http://127.0.0.1:8188/system_stats | python3 -c 'import json, sys; print(json.load(sys.stdin)["system"]["comfyui_version"])'

On the template, ComfyUI runs in a Docker container. These lines find the container by its published port and ask the running ComfyUI where its models folder is. The /internal route belongs to ComfyUI's own frontend and can change between releases, so check the path it prints:

C=$(sudo docker ps -q --filter publish=8188)
MODELS=$(curl -s http://127.0.0.1:8188/internal/folder_paths | python3 -c 'import json, os, sys; print(os.path.dirname(json.load(sys.stdin)["checkpoints"][0]))')
echo "$MODELS"

Save the file list as models.txt, keeping the lines you want. The first word of each line is the folder under models. None of these repositories is gated, so no token is needed:

# Shared by Turbo and Base: 8.38 GB
text_encoders    https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/text_encoders/qwen_3_4b.safetensors
vae              https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/vae/ae.safetensors

# Z-Image-Turbo at 16-bit, Apache-2.0: 20.69 GB with the two files above
diffusion_models https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/diffusion_models/z_image_turbo_bf16.safetensors

# Z-Image Base at 16-bit, for fine-tuning and negative prompts
# diffusion_models https://huggingface.co/Comfy-Org/Z-Image/resolve/main/split_files/diffusion_models/z_image_bf16.safetensors

# Union ControlNet for Turbo, 3.10 GB
# model_patches    https://huggingface.co/alibaba-pai/Z-Image-Turbo-Fun-Controlnet-Union/resolve/main/Z-Image-Turbo-Fun-Controlnet-Union.safetensors

Then save the download script as get-models.sh. It skips files that are already there:

#!/usr/bin/env bash
# Usage: MODELS=/path/to/ComfyUI/models bash get-models.sh models.txt
set -euo pipefail
MODELS="${MODELS:-$HOME/comfy/ComfyUI/models}"
AUTH=()
if [ -n "${HF_TOKEN:-}" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi

while read -r folder url; do
  case "$folder" in ""|\#*) continue ;; esac
  dest="$MODELS/$folder/$(basename "$url")"
  if [ -s "$dest" ]; then echo "already there: $dest"; continue; fi
  mkdir -p "$MODELS/$folder"
  echo "downloading $dest"
  curl -fL --retry 3 "${AUTH[@]}" -o "$dest.part" "$url"
  mv "$dest.part" "$dest"
done < "${1:-models.txt}"

Run it inside the template's container, or directly on your own install:

sudo docker cp get-models.sh "$C":/tmp/ && sudo docker cp models.txt "$C":/tmp/
sudo docker exec -e MODELS="$MODELS" "$C" bash /tmp/get-models.sh /tmp/models.txt

# on your own install instead:
MODELS=~/comfy/ComfyUI/models bash get-models.sh models.txt

You will run this on every launch. Stopping a QuantaCloud instance deletes it and its disk, and there are no volumes to keep models between sessions, so keep models.txt with your workflows. Loading models on a new ComfyUI instance covers pinned downloads and gated files.

Load the template and the settings that matter#

The easiest workflow is the one ComfyUI ships. Press r so the loaders see the new files, open the Templates icon in the sidebar and search for Z-Image. The table shows the defaults in ComfyUI's workflow templates on 2026-11-12, next to Tongyi's own guidance.

Two details save a wrong start. Keep CFG at 1 for Turbo: Tongyi's table lists no CFG for Turbo and its own example sets guidance to 0, and any CFG above 1 makes ComfyUI run a second, unconditional pass on every step. And write long, specific prompts: Tongyi's own examples are full paragraphs of description. Queue with Ctrl+Enter, and the images land in ComfyUI's output folder.

LoRAs for Z-Image Turbo#

The LoRA I would train is one on Z-Image Base, because Tongyi built it for fine-tuning and its model card calls it a good base for LoRA training. Training directly on Turbo is the trap. The author of AI Toolkit explains on the model card of his Turbo training adapter that "when you train directly on a step distilled model, the distillation breaks down very quickly". His adapter slows that down, and it "will work great for shorter runs such as styles, concepts, and characters", while a long run still breaks Turbo's 8-step speed. DiffSynth-Studio ships LoRA training scripts for both Turbo and Base.

To use a LoRA in ComfyUI, put the file in models/loras, press r, and add a Load LoRA node between Load Diffusion Model and the sampler. Check which of the two models a LoRA was trained on before you load it, because Turbo and Base are different weights.

ControlNet for Z-Image Turbo#

The ControlNets for Z-Image Turbo come from the alibaba-pai organisation on Hugging Face, and ComfyUI runs them with its own nodes. The first union model, Z-Image-Turbo-Fun-Controlnet-Union.safetensors at 3.10 GB, takes Canny, HED, depth, pose and MLSD maps, and it goes in models/model_patches, not models/controlnet. ComfyUI's Z-Image-Turbo Fun Union ControlNet template loads it through a Model Patch Loader node and feeds a Canny map from your input image.

All of them are Apache-2.0. Start with the file the template expects, then try a 2.1 8-step file if the control is too weak. Skip the plain 2.0 and 2.1 files: their model card says they lose Turbo's acceleration and need more steps.

GGUF files for Z-Image#

On a 48 GB card I would not use GGUF for Z-Image. The Q8_0 file of Turbo is 7.22 GB and the Q4_K_M file 3.85 GB, against 12.31 GB for the 16-bit file that already fits several times over. GGUF files also need the ComfyUI-GGUF custom node, and they make sense on small consumer cards, not here. GGUF models in ComfyUI covers when a quant earns its place.

Save your images before you stop#

Copy your images off the instance before you press Stop, because Stop deletes the disk with every model and output on it. On the template, copy them out of the container first, in the same session where you set C and MODELS:

COMFY=$(dirname "$MODELS")
sudo docker cp "$C:$COMFY/output" ~/comfy-output
sudo chown -R ubuntu: ~/comfy-output

Then pull the folder to your own machine with rsync -avP ubuntu@<instance-ip>:comfy-output/ ./comfy-output/. Moving files to and from a GPU server covers the other ways, and the ComfyUI API from Python queues the same workflow from a script when you want hundreds of images.

Z-Image questions#

Is Z-Image Turbo free for commercial use?

Yes. Z-Image-Turbo and Z-Image are Apache-2.0 on Tongyi's repositories, and so are Comfy-Org's repackaged files and PAI's ControlNets. You may use the images and the model commercially. Keep the licence notice if you redistribute the weights.

How much VRAM does Z-Image Turbo need?

Tongyi says it fits comfortably on a 16 GB card, and DiffSynth-Studio runs it in 8 GB with CPU offload. ComfyUI's full-precision files come to 20.69 GB, under half of a 48 GB card's budget, so on any QuantaCloud GPU it stays in memory with room to spare.

Has Z-Image-Edit been released?

No. Tongyi's repository listed Z-Image-Edit and Z-Image-Omni-Base as "To be released" on 2026-11-12, and no weights for either were on Hugging Face. Only Turbo and Base are open.

What is the difference between Z-Image and Z-Image Turbo?

Turbo is the distilled model: 8 steps, no CFG, and visual quality rated Very High against High for Base in Tongyi's own table. Z-Image is the undistilled base: 28 to 50 steps, full CFG with negative prompts, more variety between seeds, and the one to fine-tune.

My decision rule for Z-Image: Turbo at 16-bit on an RTX A6000 for commercial work and high volume, Base when you need negative prompts or want to train a LoRA, and a bigger card only when another model has to share the GPU. Check the template's ComfyUI version before you download, and copy your images off before you stop. To upscale what Z-Image makes, SeedVR2 in ComfyUI handles single images as well as video. The ComfyUI page lists every GPU with the template and its live price.