Z-Image 5.0 EmberFrame Split-Sigma Workflow Guide

First of all, a quick thank you again to the people behind ComfyUI, CivitAI, and all of the creators making nodes, checkpoints, LoRAs, workflows, tools, and helper scripts, then sharing them for everyone else to use. Without that community, this kind of workflow would not be possible, and it definitely would not be anywhere near as fun to build.

This is the 5.0 EmberFrame update to my Z-Image Dual-Stage workflow. It is still very much the same basic idea: use ZiB for the first image pass, then use ZiT as the refiner. The difference with 5.0 is mostly cleanup, usability, and making the public release line up properly, but I also want to be clearer about how the dual-stage part is actually working.

So this is not a huge new experimental release. It is a small, practical update. The workflow is cleaner, the helper nodes now live on GitHub, and the version jump to 5.0 fixes a mismatch between my local files, the GitHub repo, and the CivitAI version naming.

Older 4.0 and 4.6 versions may still be available on this page for reference, but 5.0 is the version I recommend using now. It is the one I expect to build on going forward.

The short version is this

· You can still use the workflow very simply by writing a normal prompt.

· ZiB / Base handles the first composition pass.

· ZiT / Turbo handles the lower-sigma refinement pass.

· This is a split-sigma workflow, not just a normal two-KSampler chain.

· The main controls are gathered into the Global subgraph.

· The Prompt / Prompt Builder can be used as a plain prompt box or as a wildcard prompt system.

· Prompt enhancement is still available using Gemma4.

· Image-to-image, ControlNets, post-processing, and upscaling are still optional.

· The EmberFrame helper nodes are now in a public GitHub node pack instead of being treated as loose local extras.

What this workflow does

This workflow includes:

· Text-to-image generation

· Image-to-image

· A dual-stage ZiB to ZiT generation path

· Built-in ControlNet sections

· A Prompt / Prompt Builder subgraph

· Sequential and random wildcard prompt tools

· Prompt enhancement using Gemma4

· Prompt enhancement from a loaded image

· Optional LG Noise Injection

· Optional post-processing

· Optional upscaling with SeedVR2 and Ultimate SD Upscale

· CivitAI-friendly image saving and metadata

Important first step: custom nodes required

There are still a few custom node packs required. The easiest route is to install what you can through ComfyUI Manager. For the EmberFrame helper nodes, use the GitHub repo directly if it has not appeared in your Manager list yet.

· EmberFrame Nodes: https://github.com/emberframe/emberframe-nodes - required for the new helper nodes

· rgthree-comfy: https://github.com/rgthree/rgthree-comfy

· ComfyUI-Image-Saver: https://github.com/alexopus/ComfyUI-Image-Saver

· ComfyUI-Impact-Pack: https://github.com/ltdrdata/ComfyUI-Impact-Pack

· ComfyUI-LG_SamplingUtils: https://github.com/LAOGOU-666/ComfyUI-LG_SamplingUtils

· ComfyUI_essentials: https://github.com/cubiq/ComfyUI_essentials

· ComfyUI-Easy-Use: https://github.com/yolain/ComfyUI-Easy-Use

· ComfyUI-KJNodes: https://github.com/kijai/ComfyUI-KJNodes

· RES4LYF: https://github.com/ClownsharkBatwing/RES4LYF

· ComfyUI ControlNet Aux: https://github.com/Fannovel16/comfyui_controlnet_aux

· ComfyUI-DepthAnythingV3: https://github.com/PozzettiAndrea/ComfyUI-DepthAnythingV3

· ComfyUI-SeedVR2_VideoUpscaler: https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler

· ComfyUI-Unload-Model: https://github.com/SeanScripts/ComfyUI-Unload-Model

· ComfyUI_UltimateSDUpscale: https://github.com/ssitu/ComfyUI_UltimateSDUpscale

· WAS Node Suite - Revised: https://github.com/ltdrdata/was-node-suite-comfyui

· comfyui-vrgamedevgirl: https://github.com/vrgamegirl19/comfyui-vrgamedevgirl

For a manual install, custom nodes normally go here:

ComfyUI/custom_nodes/

For a Windows portable install, that is usually:

ComfyUI_windows_portable/ComfyUI/custom_nodes/

After installing or updating node packs, restart ComfyUI before loading the workflow.

Model setup

You will still need to point the workflow at your own ZiB and ZiT model files. The Global subgraph is the first place to check after loading the workflow.

· Base Model: your Z-Image Base / ZiB model

· Turbo Model: your Z-Image Turbo / ZiT model

· CLIP/text encoder and VAE: set these to the files used by your local Z-Image setup

· Gemma4 text encoder: only needed if you use the Prompt Enhancer

· ControlNet, SeedVR2, and upscale models: only needed if you use those optional sections

The cleaned example path style is:

Z-Image\Base\z_image_base_model.safetensors

Z-Image\Turbo\z_image_turbo_model.safetensors

Main workflow overview

The main graph is meant to be readable from left to right. The big pieces are deliberately grouped so you can start simple, then enable the extras only when you need them.

· Image Saver

· ZiB LoRA Loader

· ZiT LoRA Loader

· Prompt From Image

· Prompt / Prompt Builder

· Prompt Enhancer

· Negative Prompt

· Image 2 Image

· Latent Switch

· Global

· LG Noise Injection

· Post Processing

· Optional ControlNets

· Optional upscaling sections

A note on the split-sigma approach

This is the part that is easy to miss if you only look at the workflow from a distance. It can look like a standard double KSampler setup, where one model makes an image and a second model refines it afterward. That is close enough to understand the broad idea, but it is not quite what this graph is doing.

In this workflow, the scheduler creates the sigma schedule for the generation, then the workflow splits that schedule into two parts. The higher-sigma portion is used for the early, noisier part of the image formation, and the lower-sigma portion is used for the later refinement part. So instead of running two totally separate sampling jobs, the two Z-Image models are sharing one staged denoising plan.

Practically, I think of it like this: ZiB gets the first pass where the image is still loose and structural, then ZiT takes over when the latent is already partly formed and the remaining work is more about polish, detail, and coherence. The handoff is controlled by the sigma split rather than just by sending a finished image or finished latent into a second sampler.

In the Global subgraph, the chain is:

1. BasicScheduler creates the full sigma schedule.

2. SplitSigmas separates that schedule into high-sigma and low-sigma portions.

3. Sigmas Resample reshapes the first-stage sigma path used by the ZiB pass.

4. The first SamplerCustomAdvanced pass uses the ZiB model and the resampled high-sigma section.

5. The second SamplerCustomAdvanced pass uses the ZiT model and the low-sigma section, using the latent from the first pass.

I do not want to oversell the theory here. I am explaining it in practical workflow terms rather than pretending this is a finished technical paper. The important point for users is that the workflow is trying to let ZiB and ZiT do different parts of the same denoising journey, rather than simply stacking a generic refiner on top of a completed first result.

Why use this approach? In my testing, it gives a useful blend of the two models' strengths. ZiB tends to be the more inventive composition model, so I like letting it handle the early, looser part of the generation. ZiT tends to bring the cleaner finish, so I like letting it take over for the later, lower-sigma refinement work.

The main drawback is that you are still asking ComfyUI to work with two models instead of one. If your system can handle that, the tradeoff has been worth it for me: the workflow can run at a relatively low step count, not as low as a straight ZiT-only workflow, but usually not as high as I would expect from a ZiB-only setup either.

As always, I am standing on the shoulders of much smarter people here. This workflow is my practical way of wiring the pieces together, not a claim that this is the only correct way to use these models.

1. Global subgraph

Most of the controls I reach for first are in the Global subgraph. This is where you set the two model paths, sampler, scheduler, seed behavior, aspect ratio, orientation, megapixels, batch size, and the core generation values.

In simple terms:

· ZiB / Base handles the first composition pass.

· ZiT / Turbo handles the lower-sigma refinement pass.

· Split-sigma generation lets the two stages do different jobs inside one staged denoising path.

For a first run, I would keep the defaults close to the included setup and only change the model paths, aspect ratio, and orientation. Once you know it is running, then start playing with the rest.

2. Prompt and negative prompt

You can use the workflow with a normal prompt. You do not have to use wildcards, prompt enhancement, image prompting, or any of the extra toys on your first run. A plain positive prompt plus the included negative prompt is enough to test that everything is connected.

The negative prompt is deliberately fairly general. It is not magic, but it gives the workflow a useful starting bias against low-quality image problems, text, logos, watermarks, and obvious anatomy issues.

3. Prompt / Prompt Builder subgraph

The Prompt / Prompt Builder subgraph can be used in two ways: as a simple prompt box, or as a wildcard prompt builder. If you just want to type a prompt and run the workflow, use it like a normal prompt field. That is still completely valid.

The wildcard side is there for people who like building batches of related ideas without rewriting the whole prompt every time. The system is made from three main parts:

· Wildcard Rule Builder nodes

· Wildcard Config Combiner

· Wildcard Prompt Assembler

Each Rule Builder controls one source file and one token name. The Config Combiner gathers those rules together, and the Prompt Assembler turns the final resolved values into a usable prompt.

A basic token prompt might look like this:

{subject} in {location}, {lighting}, {camera_angle}

A good way to test it is to enable one Rule Builder, run once, check the preview, then add another rule. Build it up slowly and it becomes much easier to see what each wildcard source is doing.

4. Prompt From Image and Prompt Enhancer

The Prompt Enhancer is still built around Gemma4. You can feed it a written idea, an image-guided idea, or a simple subject, then let it expand that into a more complete prompt structure.

The flow is basically:

6. Write a simple prompt or build one with the Prompt Builder.

7. Optionally load an image into Prompt From Image.

8. Let Gemma4 enhance the prompt or image-guided idea.

9. Send the enhanced text onward to the positive prompt conditioning.

The Prompt Enhancer subgraph includes a Gemma4 CLIP loader, the TextGenerate node, the main enhancement instruction, and preview output for the generated prompt. The required Gemma4 text encoder should be placed in your ComfyUI text encoder folder.

ComfyUI/models/text_encoders/gemma4_e4b_it_fp8_scaled.safetensors

5. LoRAs

The workflow still includes two LoRA loaders in the main graph: one for Z-Image Base and one for Z-Image Turbo. You can leave them empty for a first test. Once the base workflow is generating correctly, add LoRAs back in one at a time so it is obvious what changed.

6. Image-to-Image subgraph

The Image-to-Image section is still there for img2img. Load your source image, then use the Latent Switch to choose the image latent path instead of the empty latent path.

Important:

· Input 1 is the img2img path.

· Input 2 is the empty latent path.

· When using img2img, reduce the denoise value in the Global subgraph.

For anime-to-realistic conversion, I usually start by loading the same reference into Image 2 Image and Prompt From Image, then let the enhancer build a more descriptive prompt. After that, the useful work is mostly denoise, prompt wording, and deciding whether ControlNet is helping or getting in the way.

7. ControlNet subgraph

The ControlNet subgraph is optional. If you are doing a simple text-to-image test, leave it alone at first. Once the main workflow is behaving, you can enter the ControlNet subgraph and enable the groups you want to use.

The built-in options include:

· Depth Anything V3

· Depth Anything V2

· Canny

· OpenPose

For anime-to-realistic conversions, I usually try depth first. It gives the model structural guidance without forcing every line of the original image to survive.

8. Post Processing subgraph

The post-processing subgraph is intentionally simple. It adds a little sharpen and a little film grain. Some images benefit from that. Some images look better without it. Treat it as a finishing option, not a required part of the generation.

9. Upscaling options

There are still two optional upscaling paths. I would not turn either of them on for the very first test run. Make sure the base workflow works first, then add upscaling when you are happy with the generation path.

SeedVR2 Upscale

SeedVR2 can be a very nice final enlargement path, but it has its own model requirements and settings. Use it after the base image is already working.

Ultimate SD Upscale

Ultimate SD Upscale is the second optional upscale route. It is still useful when you want a more traditional tiled upscale pass with familiar controls.

10. Image saving and metadata

The Image Saver setup is one of the parts I care about most, because it makes the workflow easier to share, debug, and revisit later. The saved data is set up to include the important generation details where possible.

That includes:

· Checkpoints used

· LoRAs used

· Prompt-related information

· Image dimensions

· Sampler and scheduler information

· The seed used

Recommended starting workflow

If you are loading the workflow for the first time, I would suggest this order:

1. Install the required custom node packs.

2. Install or update EmberFrame Nodes from GitHub, or from ComfyUI Manager if it is already listed for you.

3. Restart ComfyUI.

4. Load the workflow.

5. Set your ZiB and ZiT model paths in the Global subgraph.

6. Set your CLIP/text encoder and VAE paths.

7. Leave LoRAs empty for the first test.

8. Set aspect ratio, orientation, and megapixels in the Global subgraph.

9. Write a simple prompt in Prompt / Prompt Builder.

10. Run a basic text-to-image test first.

After that, enable extras one at a time:

· Prompt Enhancer

· Prompt From Image

· Wildcard Prompt Builder nodes

· Img2Img

· ControlNets

· Post Processing

· SeedVR2 Upscale

· Ultimate SD Upscale

A few final notes

There are a lot of moving parts in this workflow. I know that. The best way to learn it is to start with the plain text-to-image path, then add one section at a time as you need it.

Version 5.0 is mainly about making that experience cleaner and easier to maintain. The workflow naming is now lined up, the helper nodes are on GitHub, and this should be a more sensible starting point for anyone downloading it fresh.

Most importantly: please enjoy it. I hope it helps you make cool things.

If you use it, remix it, break it, improve it, or make something interesting with it, I would genuinely love to see what you make.

Thanks for checking it out, and happy generating.

Files with SHA256: 0b50247ce1eb40c114e69972c9207a3f4a7fef73784a8d837074ba8af4bf3dda