CMKFamilyBranchGateZImage

Z-Image Turbo deserves the fuss. A 6B flow-matching model that runs 8 steps at CFG 1 and produces a 1024×1024 in seconds on a mid-range card was the first thing in years that felt like a genuine SDXL successor for consumer hardware - a good chunk of the community's reaction threads read like people falling back in love with the hobby. It's also a completely different architecture from SDXL, which is why CMK Flow will not let the two share a graph casually.

What it is

The Z-Image twin of the SDXL branch gate. Same job, different family: it reads PROCESS (CMK_PROCESS_Z_IMAGE), and if the process says the family isn't active it returns an ExecutionBlocker on all three outputs and nothing upstream runs - no checkpoint load, no sampling, no VAE work. If the branch is live, it validates model_family against z_image_turbo and raises on a mismatch, then forwards MODEL, IMAGE and LOG one at a time so ComfyUI's lazy resolution doesn't deadlock at the subgraph boundary.

The three outputs are MODEL (CMK_MODEL_PIPE), IMAGE, LOG (CMK_LOG_PIPE); the three inputs are the same types plus PROCESS. All optional, all lazy.

Why Z-Image specifically needs its own path

Because nothing about it is interchangeable with SDXL. SDXL is DDPM-style and wants CFG 4–7, 20–30 steps and a scheduler doing real work. Z-Image Turbo is guidance-distilled flow matching: CFG 1 is correct, not a low setting, and the model wants a timestep shift around 7 instead of the default 3. Turning CFG up on it doesn't increase prompt adherence, it applies the guidance twice and burns the image at double the render time. It also uses the Flux 1 VAE, not SDXL's.

That's a lot of ways to get a quietly wrong image. CMK's answer is architectural rather than advisory: separate generation paths with their own loaders, samplers and gates, sharing only a family-neutral PostProcess zone downstream. The gate is the door. And because the model is a different family with a different process type, a mismatched wire produces a loud error instead of a mixed-family picture nobody can explain.

The interesting design pressure

Turbo's weakness is seed diversity - the same prompt across seeds gave people near-identical images, and that's a direct consequence of distillation. Base fixed it at the cost of speed. Which is the argument for the flow's hybrid path, where SDXL lays down the composition and Z-Image finishes: you get SDXL's variety plus a fast, high-quality finish pass. Hybrid is a third family in CMK's architecture, kept technically separate during generation and merged at the boundary, and it ends up needing this gate's sibling nodes as well.

Worth knowing if you came here from a hybrid workflow: the SDXL→ZIT handoff is gated by its own bridge node, which reads the PROCESS ZIT signal and only resolves the SDXL side when hybrid_mode is set.

When you'd actually deal with it

Normally never. It's placed in the reference workflows and works by being ignored.

You'll meet it when an inactive Z-Image branch is loading a checkpoint it shouldn't - check that PROCESS is connected to the same process pipe the live branch uses. Or when you're copying the pattern into a flow of your own with parallel families; then the shape to copy is "cheap signal in, expensive branches lazy behind it, one output resolved at a time".

Or when you're reading a log and want to confirm which family actually ran. The gate is where that answer lives.

Install

Manager: search CMK Flow, install the CMKFlow entry, restart. Manual, from your ComfyUI root:

git clone https://github.com/CMKFlow/cmk_nodes.git custom_nodes/cmk_nodes
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py

The gate itself runs nothing, so no weights are needed for it. The Z-Image branch it protects does - the pack's Z-Image loader, sampler and optional ControlNet modules expect their own files, and several of those are multi-gigabyte, which is why the resource check confirms each one individually:

python3 custom_nodes/cmk_nodes/scripts/check_cmk_resources.py --models-root "/path/to/ComfyUI-Shared"

As everywhere in this pack, ComfyUI's Nodes 2.0 / Vue setting should be on - CMK warns at startup if it isn't.

The gotcha, again

Blocked is not empty. An ExecutionBlocker stops the output resolving rather than returning a placeholder, so whatever consumes the gate has to ask for branches in a deliberate order and pick the live one - which is exactly what CMK's Combined PostProcess Boundary does, probing ZIT first. If you write your own merge and get the order wrong, the symptom is a hang, not an error message.