Juggernaut Z on RTX 4060 Ti 16GB: Cinematic Photoreal Fine-Tune of Z-Image Base

What You'll Build

A local install of Juggernaut Z V1 — Team Juggernaut / KandooAI's photoreal fine-tune of Tongyi-MAI's Z-Image Base, released through RunDiffusion. The recipe covers two paths: a Python script via HuggingFace diffusers, and a ComfyUI workflow using the official RunDiffusion node graph. Juggernaut Z is tuned for stronger lighting, sharper focus, refined skin texture, and a more cinematic atmosphere than the upstream Base.

Hardware data: RTX 4060 Ti 16GB · BF16 / FP8 / GGUF variants available · See benchmark data

⚠️ License: CC BY-NC 4.0 (non-commercial). Per the HF model card, Juggernaut Z is licensed for non-commercial use only. Commercial licensing is via juggernaut@rundiffusion.com. The Civitai release page lists Apache 2.0 in error — the HF canonical card is the source of truth.

Not Z-Image Turbo. Juggernaut Z is built on Z-Image Base (not the distilled Turbo). That means a different step/CFG profile — Juggernaut Z's default is 35 steps at guidance scale 6 per the HF model card, not the 8-NFE / CFG 0.0 pattern of the Z-Image-Turbo on RTX 4060 Ti 16GB recipe. Use the settings below.

Requirements

Component	Minimum	Tested
GPU	16GB VRAM consumer card (bf16/fp16); ~8GB with FP8 or GGUF Q4–Q5	RTX 4060 Ti 16GB
RAM	16GB system RAM	—
Storage	~13GB for bf16 / fp16 weights; ~6GB for fp8; ~5GB for Q4_K_S GGUF	—
Software	Python 3.10+, PyTorch with CUDA + bf16 support, `diffusers` ≥ 0.37.1	ComfyUI with RES4LFY node / `diffusers` ≥ 0.37.1

The headline 16 GB tier is anchored on the BF16 weights themselves: the Juggernaut-Z-Image repo file listing ships the bf16 checkpoint at 12.3 GB on disk, leaving ~3 GB of headroom on a 16 GB card for the activations / VAE / latents. The same repo also ships an FP8 e4m3fn safetensors variant (6.15 GB) and GGUF quantizations (Q4_K_S 4.83 GB through Q8_0 7.34 GB) for tighter VRAM budgets. (As context, the upstream Tongyi-MAI Z-Image-Turbo model card describes Z-Image-Turbo as designed to "fit comfortably within 16G VRAM consumer devices" — Juggernaut Z is a fine-tune of Z-Image Base (not Turbo) but shares the Scalable Single-Stream DiT architecture per the Z-Image Base card, so the 16 GB tier framing applies to both.)

Unlike Blackwell-class cards (sm_120), the RTX 4060 Ti is Ada Lovelace sm_89 — the default pip install torch already ships full sm_89 kernel coverage for FlashAttention-2, xformers and the standard attention backends. No cu128-specific wheel selection is required.

Installation

Path A — HuggingFace diffusers (Python script)

Per the Juggernaut-Z-Image model card, Juggernaut Z loads through the standard DiffusionPipeline once diffusers is recent enough to know about ZImagePipeline:

pip install -U "diffusers>=0.37.1" transformers accelerate safetensors

Path B — ComfyUI (RunDiffusion workflow)

The official RunDiffusion ComfyUI guide ships a IMG-JuggernautZ-Txt2Img.json workflow that expects the RES4LFY custom node. Install order:

# 1. Open ComfyUI Manager → Custom Nodes Manager → install "RES4LFY", then restart ComfyUI.

# 2. Download a Juggernaut Z checkpoint to ComfyUI/models/checkpoints/
#    Pick ONE based on your VRAM budget. URLs from the official RunDiffusion repo:
#    https://huggingface.co/RunDiffusion/Juggernaut-Z-Image/tree/main

# bf16 (12.3 GB on disk — fits 16GB VRAM with room to spare):
wget -P ComfyUI/models/checkpoints/ \
  https://huggingface.co/RunDiffusion/Juggernaut-Z-Image/resolve/main/Juggernaut_Z_V1_by_RunDiffusion.safetensors

# fp8 e4m3fn (6.15 GB on disk — for ≤12 GB cards):
wget -P ComfyUI/models/checkpoints/ \
  https://huggingface.co/RunDiffusion/Juggernaut-Z-Image/resolve/main/Juggernaut_Z_V1_FP8_e4m3fn.safetensors

Load the IMG-JuggernautZ-Txt2Img.json workflow into ComfyUI by dragging the file onto the canvas (download from the RunDiffusion guide linked above).

Running

Path A — diffusers snippet

The inference snippet below is verbatim from the Juggernaut-Z-Image HF model card:

import torch
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "RunDiffusion/Juggernaut-Z-Image",
    torch_dtype=torch.bfloat16,
).to("cuda")

image = pipe(
    "a cinematic portrait, dramatic lighting",
    guidance_scale=6.0,
    num_inference_steps=35,
).images[0]
image.save("output.png")

The HF model card lists the default sampler settings as guidance_scale=6 (valid range 6–9) and num_inference_steps=35 (valid range 25–45).

Path B — ComfyUI

After loading the official workflow JSON, edit the prompt node and hit Queue Prompt. The Civitai release page for Juggernaut Z v1.0 documents an alternative two-pass setup that the model author tunes for sharpness:

First pass: sampler Res_2s, scheduler Beta, 22 steps, denoise 1.00
Second pass: sampler Res_2s, scheduler Normal, 3 steps, denoise 0.15
Recommended resolutions: 960×1440 (portrait) or 1440×960 (landscape) — the Civitai notes call out that 1024×1024 "will sometimes look too grainy/noisy" with this fine-tune

Results

Speed: No community benchmark on RTX 4060 Ti 16GB is published yet. When one lands, it will appear on /check/juggernaut-z/rtx-4060-ti-16gb. The RTX 4060 Ti 16GB has 288 GB/s of memory bandwidth (vs. 448 GB/s on the RTX 5060 Ti), so expect noticeably slower per-step times than the Blackwell-tier sibling card; the same 6B BF16 weights and step count apply. If you run it, please submit your numbers.
VRAM usage: The bf16 Juggernaut Z checkpoint is 12.3 GB on disk per the HF repo listing; the 4060 Ti's 16 GB absorbs the weights plus activations / VAE / latents with ~3 GB of headroom. (For context, the Tongyi-MAI Z-Image-Turbo card describes Z-Image-Turbo specifically as "fits comfortably within 16G VRAM consumer devices" — Juggernaut Z is built on Z-Image Base but shares the Scalable Single-Stream DiT architecture per the Z-Image Base card.) Live measurements: /check/juggernaut-z/rtx-4060-ti-16gb.
Quality notes: Per the HF card, Juggernaut Z is licensed CC BY-NC 4.0 (non-commercial; commercial licensing via juggernaut@rundiffusion.com). Tuned for "stronger lighting, sharper focus, more refined skin texture, and more cinematic atmosphere" relative to Z-Image Base.

For the full benchmark data, see /check/juggernaut-z/rtx-4060-ti-16gb.

Troubleshooting

ComfyUI errors out with a missing custom node

The official Juggernaut Z workflow requires the RES4LFY node; install it from ComfyUI Manager → Custom Nodes, then restart ComfyUI. Documented in the RunDiffusion ComfyUI guide.

`DiffusionPipeline` raises "Cannot find pipeline class ZImagePipeline"

ZImagePipeline ships in diffusers 0.37.1 and later. Upgrade with pip install -U "diffusers>=0.37.1" per the HF model card requirements. If your environment is pinned to an older release, install from main: pip install git+https://github.com/huggingface/diffusers.

1024×1024 outputs look noisy or grainy

The Juggernaut Z author flags this on the Civitai release notes: use 960×1440 / 1440×960 instead, or apply the documented two-pass schedule (22 steps Res_2s/Beta at denoise 1.00, then 3 steps Res_2s/Normal at denoise 0.15).

Tight on VRAM (≤ 12 GB card)

Download the FP8 e4m3fn safetensors (6.15 GB) or one of the GGUF Q4–Q5 quantizations (4.83–5.68 GB) from the HF repo instead of the bf16 build. GGUF requires a GGUF-aware loader node in ComfyUI.