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…
