Run Z-Image on a cloud GPU

The Z-Image-Turbo model is small enough for a 16 GB consumer card, so a rented 48 GB VM is more than it needs. Tongyi-MAI's card says it fits comfortably within 16G VRAM consumer devices, and its components come to about 20.5 GB in BF16 (calculated from the file sizes), which leaves about 24 GB on a 48 GB card (calculated). I would rent one when you do more than one thing at a time: batch generation, LoRA training, or an image model beside another model. Both published Z-Image models, Z-Image-Turbo and Z-Image, are Apache-2.0 according to their cards.

Which Z-Image models exist today

This table was checked against the Tongyi-MAI organization on Hugging Face and the official GitHub repository on 12 November 2026. All four models have about 6B parameters, and the README says they use a Scalable Single-Stream DiT.

The README was last updated on 9 February 2026, and the organization has no repository for Z-Image-Omni-Base or Z-Image-Edit, so there is no official Z-Image edit model to download today. The Diffusers Z-Image page does document ZImageImg2ImgPipeline and ZImageInpaintPipeline for Z-Image-Turbo, which start from an input image and a strength setting rather than an edit instruction. For instruction editing on the same template, the Qwen-Image page covers Qwen-Image-2.1, which edits natively, and the FLUX page covers FLUX.3 [klein].

Z-Image sizes and memory: 21 GB in BF16, 33 GB to download

The sizes are the summed safetensors files, where GB is 10^9 bytes. The Turbo repository is larger because its transformer is stored in FP32 and the card's code loads it as BF16. The left-over row is 92% of the card's memory minus the BF16 components, calculated, so it leaves out activations.

The documented figures are lower than the files suggest. The Turbo card says it fits comfortably within 16G VRAM consumer devices, and ComfyUI's Z-Image-Turbo tutorial says it renders in 8 steps on 16GB of VRAM. DiffSynth-Studio's Z-Image page says a minimum of 8GB of VRAM is required with CPU offload, and warns that FP8 quantization causes noticeable image quality degradation on Turbo. The README lists stable-diffusion.cpp running Z-Image on as little as 4GB of VRAM. The base Z-Image card gives no figure.

When a rented 48 GB GPU makes sense for Z-Image

DeployGPU's smallest VM has 48 GB, so a 16 GB card you already own is not a DeployGPU option, and for one image at a time it is enough. The reasons to rent are the ones where memory or time adds up.

Batch generation is the first. No source I checked publishes images per hour for a 48 GB card, so I cannot give a throughput figure. What the sizes show is room: after the 20.52 GB of BF16 components a 48 GB card has about 24 GB for activations, which a larger batch or a larger image uses. The official repository has batch_inference.py, which reads one prompt per line from the file named in the PROMPTS_FILE variable and saves PNGs, and Diffusers takes num_images_per_prompt.

LoRA training is the second. AI Toolkit's README lists Z-Image, Z-Image Turbo and Ostris's Z-Image De-Turbo as supported base models. The DiffSynth-Studio page says directly training the distilled Turbo quickly loses its acceleration, and offers differential LoRA training with an adapter such as ostris/zimage_turbo_training_adapter. None of the pages I checked publishes a training memory figure for Z-Image, so 48 GB is room to spare, not a documented requirement. The LoRA guide covers the AI Toolkit install on a plain GPU VM.

Sharing the card with another model is the third, and the sizes decide it. Z-Image-Turbo's 20.52 GB plus the 22.9 GB peak that the Wan 2.2 README table shows for TI2V-5B at 720P on one RTX 4090 with offloading on is 43.4 GB, inside a 48 GB card's 44.2 GB with almost nothing spare (calculated). Qwen-Image-2.1's 33.12 GB of files do not fit beside it.

The 48 GB page lists the cards in that class.

Z-Image in ComfyUI

ComfyUI's tutorials give the same three files for Z-Image-Turbo, from the Comfy-Org/Z-Image-Turbo repository, which is not gated and is marked Apache-2.0. The tutorials and that repository's README list workflows named Z-Image-Turbo: Text to Image, Z-Image-Turbo Int8: Text to Image and Z-Image: Text to Image, and the tutorials say to update ComfyUI if a template is missing, so check the version in the ComfyUI template first, as the models guide shows.

Together they are 20.69 GB (calculated). The same repository has z_image_turbo_int8_convrot.safetensors at 6.20 GB and qwen_3_4b_fp8_mixed.safetensors at 5.63 GB, and the Comfy-Org/Z-Image repository has z_image_bf16.safetensors at 12.31 GB for the base model. Models go under /workspace/runpod-slim/ComfyUI/models/ inside the container, and sudo docker exec deploygpu-workload ls /workspace/runpod-slim/ComfyUI/models confirms the layout. The block below opens a shell in the container and downloads from inside it:

sudo docker exec -it deploygpu-workload bash
cd /workspace/runpod-slim/ComfyUI/models
curl -L --fail -o diffusion_models/z_image_turbo_bf16.safetensors \
  https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/diffusion_models/z_image_turbo_bf16.safetensors
curl -L --fail -o text_encoders/qwen_3_4b.safetensors \
  https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/text_encoders/qwen_3_4b.safetensors
curl -L --fail -o vae/ae.safetensors \
  https://huggingface.co/Comfy-Org/Z-Image-Turbo/resolve/main/split_files/vae/ae.safetensors

Stopping the instance deletes the disk and these files, which is only 20.69 GB to fetch again.

Z-Image with Diffusers

The cards install Diffusers from source with pip install git+https://github.com/huggingface/diffusers. This is the Z-Image-Turbo card's code with a shorter prompt:

import torch
from diffusers import ZImagePipeline

pipe = ZImagePipeline.from_pretrained(
    "Tongyi-MAI/Z-Image-Turbo",
    torch_dtype=torch.bfloat16,
    low_cpu_mem_usage=False,
)
pipe.to("cuda")

image = pipe(
    prompt="A red fox in a snowy forest at dawn, photorealistic",
    height=1024,
    width=1024,
    num_inference_steps=9,  # This actually results in 8 DiT forwards
    guidance_scale=0.0,     # Guidance should be 0 for the Turbo models
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]

image.save("example.png")

For Z-Image, the README recommends 512 by 512 to 2048 by 2048 pixels in total area, a guidance scale of 3.0 to 5.0, 28 to 50 steps, negative prompts, and cfg_normalization set to False for general stylism or True for realism. Its example loads Tongyi-MAI/Z-Image and calls the pipeline with negative_prompt, height=1280, width=720, cfg_normalization=False, num_inference_steps=50 and guidance_scale=4.

The Z-Image license

The cards for Z-Image-Turbo and Z-Image both declare apache-2.0 in their metadata, and neither Hugging Face repository has a LICENSE file. The GitHub repository's LICENSE file is the Apache License 2.0, and ComfyUI's repackaged repositories are marked apache-2.0 as well. The cards say nothing more about the license.