Image models like this start from noise and clean it up in passes, called steps. Tongyi-MAI's Z-Image-Turbo needs eight. NitroFusion2 is distilled from it: a student network trained to land on the teacher's result in one or two. Dar-Yen Chen and Yi-Zhe Song (SketchX, University of Surrey) built it and released it under Apache-2.0. We served it as an API on one RTX 4090 on our cloud. At 1024 x 1024, one step took 0.78 to 0.82 seconds of GPU time, two steps 1.32 to 1.33.
Speed came for free. A few settings and one testing habit did not. Every table, the memory ladder and the setup commands are in the full NitroFusion2 write-up on inferencekey.com.
Budget memory for the text encoder, not the model file
The transformer (the main network that draws) ships as a 12.3 GB file, which seems to suit a 16 GB card. It does not. The text encoder, the Z-Image-Turbo component that turns your prompt into numbers, takes about 8 GB by itself. With the full file, peak use was about 23 GB. All on the GPU means a 24 GB card.
The authors also publish GGUF files from 2.0 GB to 7.2 GB: quantized copies that store each weight in fewer bits. Under a 16 GB cap, the 7.2 GB file died with out of memory on its first image. The 5 GB file fits beside the text encoder. On a physical 16 GB card, an RTX 2000 Ada that draws 70 watts, it stayed fully on the card at about 4.0 seconds per image at one step, 7.3 at two. At 8 GB the text encoder alone fills the budget. We did not test a smaller text encoder.
Pick the memory mode yourself on a 16 GB card
The example's memory mode defaults to auto, which keeps the pipeline on the GPU only when at least 23 GiB are free. Below that it switches to offloading: parts of the model wait in system RAM and move to the GPU when needed (the authors' script does the same). With the full file under a 16 GB cap, that cost 14 to 19 seconds per image. On a 16 GB card, auto never takes the 4-second path, so name it:
NF2_TRANSFORMER=nf2-Q4_K_M.gguf
NF2_MEMORY_MODE=gpu
The offloaded images came out the same, only slower, so only your timings show it.
Steps 1 to 4, guidance 0, or you get an error
NitroFusion2 takes 1 to 4 steps. Guidance (how hard sampling pulls toward the prompt) stays at 0. Our dashboard's image tester opens at 20 steps and guidance 4.5, and gets a 400. With 1 or 2 steps and guidance 0, the one-step poster arrived in about 1.1 seconds. The SDK example's README says so; the tester's defaults have not changed.
For two steps the authors suggest a 0.38 GB add-on. It makes the first step half Z-Image-Turbo; the student finishes alone.
Measure GPU time and round trip separately
GPU time is only the drawing. The round trip adds the request, PNG encoding and the network, and at one step it nearly doubles the time.
| Steps | GPU time | Round trip through the API |
|---|---|---|
| 1 | 0.78 to 0.82 s | 1.45 to 1.50 s |
| 2 | 1.32 to 1.33 s | 1.95 to 2.00 s |
| 4 | 2.42 s | 3.08 s |
Through the API, that is about 40 images a minute at one step and about 30 at two. Log both numbers while you tune. Requests ran one at a time: no batching (several prompts in one GPU pass), no concurrency, no eight-step baseline. Our 4090 was a 48 GB card, capped to act like the usual 24 GB one.
Do not trust one seed across GPUs
The seed is the random starting point of an image. With the authors' cat-and-sign prompt and seed 42, the 4090 wrote "HELLO WORd" at one step and "Hello World" at two.
On the 16 GB card, that seed at one step spelled "HELLO WORLD" correctly. A fixed seed does not reproduce a picture on another card, so one seed per prompt is a smoke test, not a quality score.
Short, big lettering usually survived one step: the Lisbon tram poster spelled "LISBOA" and "Tram 28 - every 12 minutes" correctly at one and two steps and on the 16 GB card. Small lettering did not: the cafe menu wanted "SOURDOUGH 4.50", and at one, two and four steps the 4090 wrote "SOURDOAGH". The paper admits "a substantial gap" on text rendering. In its long-text test, one step scores 43 out of 100, two steps 76, and eight-step Z-Image-Turbo 92. Those are the authors' figures; we did not reproduce them.
So text, not speed, decides. One step for previews, two for short headlines you check by eye. For menus, labels and prices, overlay real text afterwards, or switch to eight-step Z-Image-Turbo.
Credits and where to go next
NitroFusion2, its paper and code are by Dar-Yen Chen and Yi-Zhe Song (paper on arXiv, code on GitHub, weights and GGUF copies on Hugging Face). It builds on NitroFusion by Dar-Yen Chen, Hmrishav Bandyopadhyay, Kai Zou and Yi-Zhe Song. The base model and text encoder are Tongyi-MAI's Z-Image-Turbo. The diffusers maintainers wrote ZImagePipeline. PedroMarinhoDev made community ComfyUI builds (untested by us), and AI Search's news video is where we found the model. We wrote the custom backend, deployed it, and ran the timings and memory tests. The NitroFusion2 deployment notes with the memory ladder and per-request measurements also cover the request fields and startup time.
To run it on your own card, start from the NitroFusion2 article on inferencekey.com and its SDK example.

Top comments (0)