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.
Description
Z-Image 4.6 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 updated 4.6 version of my Z-Image Dual-Stage workflow. It is still very much a living workflow. I will keep changing things, simplifying things, and trying to make the layout easier to understand over time, so please treat this as a practical guide rather than a polished technical manual.
The biggest change in 4.6 is the prompt system. The old Wildcard / Prompt Enhancement section has been removed, and the old Auto Prompt from Image section has also been removed. They have been replaced with a new Prompt / Prompt Builder subgraph, a new Prompt From Image loader, and a Gemma4-based Prompt Enhancer subgraph.
The short version is this:
- You can still use the workflow very simply by writing a normal prompt.
- You can open the Prompt / Prompt Builder subgraph and enable wildcard builder nodes if you want automated prompt variation.
- You can load an image into Prompt From Image if you want Gemma4 to enhance from an image.
- The Prompt Enhancer can improve either the basic text prompt or the image-guided prompt.
- The Image Saver now saves the seed used, as well as the other generation metadata.
What this workflow does
At its core, this workflow still combines Z-Image Base and Z-Image Turbo. Base handles the initial composition and structure, and Turbo is used to refine the result.
This workflow includes:
- Text-to-image generation
- Image-to-image
- Built-in ControlNets
- A new Prompt / Prompt Builder subgraph
- Sequential and random wildcard prompt tools
- Prompt enhancement using Gemma4
- Prompt enhancement from a loaded image
- Optional post-processing
- Optional upscaling with SeedVR2 and Ultimate SD Upscale
- CivitAI-friendly metadata saving
- Saved image data that includes checkpoints, LoRAs, prompt information, dimensions, sampler data, and now the seed used
Important first step: custom nodes required
There are more custom nodes in 4.6 than there were in the 4.0 workflow.
Some custom node packs still need to be installed through ComfyUI Manager or manually cloned into your ComfyUI/custom_nodes/ folder:
- 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
These custom nodes are included with the workflow package, so they should be inside the zip file and do not need a separate download:
- ComfyUI-SequentialWildcardPrompt
- ComfyUI-WildcardPromptAssembler
- ComfyUI-WildcardPromptToolkit
- mp_aspect_res_selector
Place the included custom node folders into:
ComfyUI/custom_nodes/
For a Windows portable install, that is usually:
ComfyUI_windows_portable/ComfyUI/custom_nodes/
After installing or copying the custom node folders, restart ComfyUI or refresh the node list.
Also, the Film Grain and Sharpen nodes in this workflow are provided by comfyui-vrgamedevgirl, so if those nodes are missing, that is the pack to check first.
Main workflow overview
The main workflow overview has changed slightly in 4.6. The big visible change is that the old prompt-related sections have been replaced by the new Prompt From Image loader, the new Prompt / Prompt Builder node, and the Gemma4 Prompt Enhancer node.
The workflow is still laid out so that the main controls are accessible from the front page:
- 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 upscaling sections
For normal use, you can start from the main workflow page. You do not need to dive into every subgraph straight away. I would strongly recommend running a simple text-to-image test first, then enabling the extra sections one at a time.
1. Global subgraph
The Global subgraph is still the heart of the workflow. This is where the main Z-Image Base and Z-Image Turbo models are loaded, and where the diffusion settings, aspect ratio, dimensions, seed handling, scheduler, VAE, and latent setup all come together.
In simple terms:
- ZiB / Base handles the first composition pass.
- ZiT / Turbo handles the refinement pass.
- The mp_aspect_res_selector node controls aspect ratio, orientation, megapixels, and aligned output dimensions.
- The seed generator now feeds the Image Saver properly, so the saved file records the seed that was actually used.
- The workflow is set up to create a strong base image, then push it through a refined second stage.
The aspect selector is still one of the most useful quality-of-life parts of the workflow. You can choose an aspect ratio, portrait or landscape orientation, a target megapixel value, and the node works out sensible dimensions for you.
By default, I usually work at around 2 megapixels for normal generation. That gives a good balance between quality and speed, and it leaves the optional upscaling paths available if you want to push the image further later.
The Global section also includes the VAE switch, tiled VAE decode, sampler, scheduler, split sigmas, sigma resampling, and cache/VRAM cleanup nodes. The default values are the ones that have worked best for me so far, but this is absolutely a place where people who like to tinker can experiment.
One small but important 4.6 change: image saving now includes the seed used. In older versions, the saved metadata was useful, but the seed handling was not as complete as I wanted. This version is much better for going back through older generations and understanding exactly how an image was made.
2. Prompt and negative prompt
The standard positive prompt flow is now handled through the Prompt / Prompt Builder section.
For simple use, just type your prompt into the main Prompt / Prompt Builder prompt field and run the workflow. You do not have to enable the wildcard builder nodes. If you want a normal, controlled prompt workflow, keep it simple and use it like a regular prompt box.
The negative prompt is still handled separately in the red Negative Prompt node. I have included a standard negative prompt note in the workflow as a starting point, but you should adjust it to suit your own style and subject matter.
3. Prompt / Prompt Builder subgraph
This is one of the biggest changes in 4.6.
The Prompt / Prompt Builder subgraph can be used in two ways:
- As a simple prompt box
- As a wildcard prompt builder
If you only want to write one prompt manually, you can ignore most of the inside of the subgraph, just make sure the 6 wildcard rule builder nodes are bypassed. Type the prompt in via the main graph, run the workflow, and carry on as normal.
If you want the workflow to build prompts for you, enter the subgraph and enable the Wildcard Rule Builder nodes you want to use. The included example is set up around character, outfit, pose, wings, framing, and camera angle style wildcard files, but the same system can be used for your own subjects, styles, locations, lighting, camera terms, character details, or anything else that works well as a line-by-line wildcard list.
The prompt builder is made from three main parts:
- Wildcard Rule Builder nodes
- Wildcard Config Combiner
- Wildcard Prompt Assembler
Wildcard Rule Builder nodes
Each Wildcard Rule Builder node controls one wildcard source.
The important fields are:
- token_name
- wildcard_file
- mode
- start_line_number
- repeat_each_line
token_name is the name of that wildcard rule. In the included setup, the example token names include prompt, outfit, pose, wings, framing, and camera_angle.
Write a base prompt, that uses the token_names, so as an example;
{girl} is wearing {outfit} in {location}
Where girl, outfit and location are all the token names you have assigned to your wildcards.
wildcard_file is the text file the node reads from. Each line in the selected file is treated as an available option.
mode controls how the wildcard moves across workflow executions. In the included workflow, some nodes are set to next, and others are set to randomize.
next is useful when you want to step through a wildcard file in order. For example, you might want to move through a base prompt list one line at a time.
randomize is useful when you want variety. For example, poses, framing, camera angles, lighting ideas, locations, or style details can work well when they are randomly selected.
start_line_number is the starting line in the wildcard file. It is 1-based, so line 1 means the first line in the file.
repeat_each_line controls how many executions the workflow stays on one line before changing. If this is set to 1, it can change every run. If it is set higher, the same line will be repeated for several generations before moving on.
The Rule Builder also has a rule_preview output. This is useful for checking what the rule is doing before you rely on it for a larger batch.
Wildcard Config Combiner
The Wildcard Config Combiner collects the enabled Rule Builder outputs into one combined wildcard configuration.
In this workflow, it has six rule inputs:
- rule_1
- rule_2
- rule_3
- rule_4
- rule_5
- rule_6
You do not need to use all six. If you only want one or two wildcard sources, enable only those. If you want a more complex prompt recipe, enable more of them.
Wildcard Prompt Assembler
The Wildcard Prompt Assembler is where the final prompt is assembled.
It takes the wildcard configuration from the combiner, combines it with the prompt text, resolves the selected wildcard values, and outputs the finished prompt.
The important outputs are:
- prompt_out
- preview_text
- selected_values
- resolved_token_count
prompt_out is the final prompt that leaves the Prompt / Prompt Builder subgraph.
preview_text is the one to watch while testing, because it shows the run counter, the original prompt, the resolved values, and the final prompt.
selected_values is useful if you want to see exactly which wildcard values were chosen.
resolved_token_count is useful for checking whether the assembler actually found and resolved wildcard tokens.
The assembler also includes a run_counter. This matters for sequential wildcard behaviour. If the counter is set to increment after generation, the sequential rules can move forward each run. If you reset or change the counter, the sequence position changes as well.
Example wildcard setup in this workflow
The included 4.6 example uses these wildcard sources:
- prompt from a baseline prompt wildcard file, set to next
- outfit from a lingerie wildcard file, set to next
- pose from a pose wildcard file, set to randomize
- wings from a succubus wings/horns/tail wildcard file, set to randomize
- framing from a framing wildcard file, set to randomize
- camera_angle from a camera angle wildcard file, set to randomize
That is only an example. The real value of the system is that you can swap the wildcard files and token names for your own setup.
A good way to test it is:
1. Enable one Rule Builder node.
2. Run the workflow once.
3. Check the preview text.
4. Enable a second Rule Builder node.
5. Check the preview again.
6. Build up from there.
That way, if the prompt does something unexpected, you know which wildcard rule caused it.
4. Prompt From Image and Prompt Enhancer
The old Auto Prompt from Image section has been removed and replaced.
In 4.6, Prompt From Image is now a loader that works together with the Prompt Enhancer subgraph. This is important: the image loader on its own is not really the full feature. It is meant to feed the Prompt Enhancer.
The Prompt Enhancer uses Gemma4 with a prompt enhancing command I wrote. When enabled, it can enhance either:
- The basic prompt coming from the Prompt / Prompt Builder subgraph
- The loaded image from the Prompt From Image node, if an image is loaded and the enhancer is being used with that image input
So the flow is basically:
1. Write a simple prompt or build one with the Prompt Builder.
2. Or, Optionally load an image into Prompt From Image.
3. Let Gemma4 enhance the prompt or image-guided idea.
4. Send the enhanced prompt onward to the positive prompt conditioning.
If you do not load an image, Gemma4 works from the text prompt. If you do load an image, it can use the image as part of the prompt enhancement process. If you are prompting from an image, leave the text prompt blank.
The Prompt Enhancer subgraph includes:
- A Gemma4 CLIP loader
- The TextGenerate node
- The main enhancement prompt
- Preview output for the enhanced prompt
- Markdown notes with example enhancement commands
- A model storage note for the Gemma4 text encoder
The required Gemma4 text encoder is:
gemma4_e4b_it_fp8_scaled.safetensors
It should be placed here:
ComfyUI/models/text_encoders/gemma4_e4b_it_fp8_scaled.safetensors
The workflow note also links to:
- https://huggingface.co/Comfy-Org/gemma-4/tree/main/text_encoders
For the CLIP loader inside the Prompt Enhancer subgraph, the settings should be:
- type: stable_diffusion
- device: default
The enhancement prompt is currently written to produce a structured cinematic Z-Image prompt with labelled sections:
- CONCEPT & MEDIUM
- SUBJECT DESCRIPTION
- ACTION & INTERACTION
- APPAREL
- ENVIRONMENT & FOREGROUND
- BACKGROUND & LIGHTING
This is designed to take a simple idea and turn it into something more detailed and usable by the image model.
I have also included extra example prompt-enhancement commands in the workflow as markdown notes, so you can copy, edit, or replace them if you want to experiment with different enhancement styles.
5. LoRAs
The workflow still includes two Power LoRA Loaders in the main workflow:
- One for Z-Image Base
- One for Z-Image Turbo
These sit above the main prompt area. Add your LoRAs there exactly as you normally would, and set the strengths to taste.
If you like mixing style LoRAs and character LoRAs between stages, this setup makes that much easier.
The workflow is also set up so the LoRAs used in the generation are carried through into the saved image metadata, alongside the checkpoint information and the prompt data.
6. Image-to-Image subgraph
The Image-to-Image section is still there for img2img.
Important:
- When using img2img, go to the Latent Switch node underneath the main prompt area.
- Select input 1 for img2img.
- Input 2 is the empty latent path.
- When using img2img, reduce the denoise value in the Global subgraph.
As a starting point, I usually recommend trying denoise around 0.8, then adjusting from there.
Lower denoise values preserve more of the source image. Higher denoise values allow the model to reinterpret the source image more aggressively.
One useful workflow is to load the same reference image into Image 2 Image and Prompt From Image, then let the Prompt Enhancer create a better prompt from the image while img2img carries the structure through the diffusion process.
7. My anime-to-realistic method
This is still one of the things I enjoy using the workflow for.
The new 4.6 method is:
1. Load the anime image into the Image 2 Image subgraph.
2. Set the Latent Switch to input 1.
3. Load the same image into Prompt From Image.
4. Enable/use the Prompt Enhancer.
5. Let Gemma4 create an enhanced prompt from the image.
6. Remove or edit any wording that pushes the result back toward anime, illustration, cel shading, or cartoon styling.
7. Add a realism instruction if needed, such as:
Create an incredibly lifelike cinematic style realistic image that is indistinguishable from reality:
8. Run again and refine with denoise, ControlNet, prompt wording, and enhancement settings.
If the structure drifts too much, enable the ControlNet subgraph and start with Depth Anything.
8. ControlNet subgraph
The ControlNet section is still optional, but it can be very useful when you want to preserve structure.
Once the subgraph is enabled, enter it and turn on the groups you want to use.
For anime-to-realistic conversions, I would usually start with:
- Loader, which needs to be active every time
- Depth Anything, usually my first choice
The built-in options include:
- Depth Anything V3
- Depth Anything V2
- Canny
- OpenPose
A good simple test is to use the same source image in img2img and ControlNet together, then let Depth Anything help hold the structure while Z-Image pushes the image toward the new style.
9. Post Processing subgraph
The post-processing section is still enabled with settings that have worked well for me:
- A little sharpen
- A little film grain
They are there to add a bit of bite and texture to the final image, but definitely try turning them off or adjusting them to suit your own taste.
Some images benefit from them. Some images look better without them.
10. Upscaling options
There are still two optional upscaling paths.
SeedVR2 Upscale
SeedVR2 is the first optional upscale path. It includes its own post-processing as well.
I do not use it on every image, because I am usually happy generating at around 2MP, but it is there if you want to push detail further.
If you enable it, just be aware that it is doing real work and can take a while.
Ultimate SD Upscale
Ultimate SD Upscale is the second optional upscale option.
Again, it is optional. Again, it is worth experimenting with.
If you enable both upscalers, the output from SeedVR2 feeds into Ultimate SD Upscale. This can produce very large final results, but it can also mean leaving your PC running for a long time on one image.
11. Image saving and metadata
The Image Saver setup is one of the things I care about most in this workflow.
The saved image data is designed to preserve useful generation information rather than just outputting a plain image file.
In 4.6, the saved metadata is set up to include:
- Checkpoints used
- LoRAs used
- Prompt-related information
- Image dimensions
- Sampler and scheduler information
- The seed used
That last one is the important update. The Global subgraph now sends the seed through so the Image Saver can save the seed used by the generation.
This makes the workflow more useful if you like going back through older images and working out exactly how they were made. It also makes posting to CivitAI easier, because the generation data is more complete.
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. Copy the included custom node folders into ComfyUI/custom_nodes/.
3. Add the Gemma4 text encoder to ComfyUI/models/text_encoders/ if you want to use Prompt Enhancer.
4. Restart ComfyUI.
5. Load the workflow.
6. Load your ZiB and ZiT checkpoints.
7. Add any LoRAs you want.
8. Set your aspect ratio, orientation, and megapixels in the Global subgraph.
9. Write a simple prompt in Prompt / Prompt Builder.
10. Write or adjust your negative prompt.
11. 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
That way, if something breaks, you will have a much better idea of which section caused it.
A few final notes
There are a lot of moving parts in this workflow. I know that.
The goal of 4.6 was to make the prompting side more flexible while still keeping the simple prompt workflow available. You do not need to use the wildcard builder or prompt enhancer every time. They are there when you want more automation, more variation, or a stronger starting prompt from an image.
If you find an obvious bug or something confusing in the layout, please let me know and I will try to fix it when I can.
More improvements and simplifications will come over time. This is still a living workflow rather than a finished polished product.
Most importantly: please enjoy it. I hope it helps you make cool things.
If you use it...
If you make something with this workflow, please consider submitting your creations through the workflow page using the Add Post button.
That helps show other people that the resource is being used, and it lets me see what you have made, which genuinely motivates me to keep improving and sharing more workflows.
Thanks for checking it out, and happy generating.