iGEN ONE (RB9) — Workflow Guide

518 nodes · 45 groups · 25 component subgraphs · 3 rows (4 quadrants)

113 unique node types — 77% Eclipse nodes at the top-level
1,061 flattened nodes (subgraphs expanded) — 73% Eclipse nodes overall
Built with ComfyUI_Eclipse custom nodes
PuLID fix: PuLID Flux II, Raffle Fork: ComfyUI-Raffle, Res4lyf Fork: RES4LYF

What Is This?

iGEN ONE is a modular, all-in-one image generation and post-processing pipeline for ComfyUI. It supports a wide range of diffusion models — Flux, Stable Diffusion, HiDream, and more — and covers everything from initial image generation through face detailing, upscaling, and watermarking in a single workflow.

The key design principle is modularity: every feature lives in its own group that can be independently enabled or disabled by simply muting or bypassing it. You never need to reconnect anything — the pipeline automatically adapts to whatever groups are active.

The RB8 version is a large-scale, full-featured release containing the complete suite of image loaders, ControlNet processors, style transfer networks, detailers, upscalers, and advanced filter adjustments. It also flattens 14 component subgraphs directly onto the main canvas, exposing their internal controls and intermediate preview/stop nodes so you can inspect and verify each stage without digging into subgraph interiors.

How It Works — The Basics

4-Quadrant Layout

To make this massive workflow easy to navigate, the workspace is arranged as a 4-quadrant grid comprising three horizontal rows split into Left and Right halves:

Top-Left Quadrant (Row 1 & 2, Left): Configuration & Model Loading (Groups 0–9) and Image Inputs / Pre-processors (Groups 10–17).
Bottom-Left Quadrant (Row 3, Left): Prompting & Core Rendering (Groups 18–26). Includes prompt raffle, wildcard processors, initial rendering, and 2nd pass latent upscale.
Bottom-Right Quadrant (Row 3, Right): Post-Processing Stage 1 (Groups 27–32). Contains Flux2 Refine (3rd pass), BFS Face Swap, Flux2 Edit, Tile Upscale (4th pass), Upscale / Sharpen, and Detailer 1 (Face).
Top-Right Quadrant (Row 1 & 2, Right): Detailers & Finishing (Groups 33–44). Contains Detailers 2–6, SeedVR2 Upscale, Final Crop, Rescale Image, Image Adjustments, Watermarks, and Save Image.

S-Curve (Snake) Post-Processing Flow

The post-processing pipeline on the right half flows in an S-curve (snake) pattern moving upwards — so when you read across the bottom-right then back across the middle-right then back across the top-right, you are following the order images travel through the pipeline:

Row 3 (Bottom, Left→Right): Flux2 Refine → Flux2: Face Swap → Flux2 Edit → Tile Upscale (4th Pass) → Upscale / Sharpen → Detailer: 1 (Face)
Row 2 (Middle, Right→Left): Detailer: 2 (Eye) → Detailer: 3 (Mouth) → Detailer: 4 (Hand) → Detailer: 5 (Placeholder) → Detailer: 6 (Placeholder)
Row 1 (Top, Left→Right): SeedVR2 (Upscale) → Image Final Crop → Rescale Image → Image Adjustments → Create Watermark (Text) → Create Watermark (Logo) → Save Image

Toggling Features & Flattened Subgraphs

Each group has a Fast Mode Toggle panel — a small control panel that lets you mute or bypass individual sub-features within the group. To disable an entire group, you mute/bypass the group itself in the ComfyUI canvas.

To mute/activate an entire group: right-click the group header → "Set Group Nodes to Never" (mute all) or "Set Group Nodes to Always" (activate all).

In RB8, 14 subgraphs from previous versions have been flattened — their internal nodes are placed directly on the main canvas instead of being hidden inside a component box. This means you can see intermediate preview images, interact with Stop nodes, and adjust settings without ever opening a subgraph. Despite this expansion, the layout stays compact: all groups are standardized to a vertical height of 808px, keeping everything neatly aligned.

When a group is muted or bypassed, downstream groups automatically skip it and pick up from the last active group. This works because of a priority-based fallback system: each group tries a list of possible input sources in order and uses the first one that's actually active.

You can enable any combination of groups and the pipeline will always find the right data path. There is no need to manually reconnect anything.

Data Routing

Instead of visible noodle connections between groups, iGEN ONE uses Set/Get nodes (Eclipse Version) — named value channels that work like wireless connections. A SetNode in one group publishes a value (like ref_image or model_init), and a GetNode in another group retrieves it by name. This keeps the visual layout clean and makes it easy to rearrange groups. Two additional variants handle the priority fallback logic: GetAllActive collects all currently active values published under a name (used to chain model sources), and GetFirst picks the first non-empty value from a list — this is what powers the automatic "last active group wins" behaviour throughout the pipeline.

Compatibility with KJNodes Set/Get nodes is one-way: Eclipse Get nodes can read values published by KJNodes Set nodes, but KJNodes Get nodes cannot read values published by Eclipse Set nodes. In practice this means you can use KJNodes Set nodes as a source and pick them up with Eclipse Get nodes, but not the other way around.

Left Half — Generation & Configuration

Model Loading & Configuration (Groups 0–9)

This section at the top-left houses all the settings and model loading pathways. It runs once at the start and feeds everything downstream.

0. Folder / Resolution

The configuration hub for the entire workflow. This is where you set:

Output folder — uses a date-based template (%Y-%m-%d) so your outputs automatically organize into day-stamped subfolders.
Image dimensions — default is 832×1248 (2:3 aspect ratio, optimal for Flux2 and Z-Image-Turbo).
Batch size — how many images to generate in a single run.
VRAM purge — whether to aggressively free GPU memory between operations (useful on tighter setups).

1. Model Loader (Main)

Loads your primary generation checkpoint using Eclipse's Smart Model Loader. This is the model that drives the Initial Render and 2nd-pass upscale. The default configuration loads Krea2_MoodyMix_v3, an external CLIP model (Qwen3vl_4b_fp8_scaled, krea2 type), and an external VAE. All of this is saved in a template so you can swap it in one click.

2. Model Patcher (Main)

A toolkit of optional model-level modifications you can stack on top of your checkpoint without changing the checkpoint itself. Each is independently toggleable, so you can experiment by turning them on one at a time:

Krea2T-Enhancer — A specialized attention patch that improves output quality with Krea2-family models (enabled by default).
ModelSamplingFlux — Adjusts the internal noise schedule for Flux-based models. Enable this if you're using a Flux checkpoint.
DynamicThresholdingFull — Prevents prompt adherence from degrading at high CFG values.
PAG (Perturbed Attention Guidance) — Amplifies fine detail by subtly disrupting self-attention during sampling.
SAG (Self-Attention Guidance) — A complementary technique that enhances feature contrast using attention maps.
DifferentialDiffusion — Allows masked selective denoising, so different areas of the image can be denoised at different strengths.
CFGZeroStar — An alternative CFG method that can improve quality at lower CFG values.
PatchSageAttention — Replaces standard attention with a memory-efficient implementation. Good for reducing VRAM usage.
TorchCompileModel — JIT-compiles the model for faster inference. There's a warmup cost on the first run, but subsequent runs are faster.
TeaCache — Caches token computations across steps to skip redundant work. Default threshold is 0.4.
UNetTemporalAttentionMultiply — Modifies temporal attention layers; primarily for video-aware models.

3. Model Loader (Detailer)

A dedicated checkpoint loader for all the detailer groups (Groups 32–37). By separating detailer models from the main generation model, you can run a lighter, faster model specifically tuned for inpainting and detail enhancement without affecting your primary generation pipeline. Default: darkBeast Blitz6 via the ZIT_DarkBeast_Blitz6 template.

4. Model Patcher (Detailer)

The same set of optional patches as Model Patcher (Main), but applied to the detailer model instead. All patches are bypassed by default — the detailer model typically doesn't need them, but they're here if you want to experiment.

5. PuLID (Flux)

Identity preservation using PuLID. Load a reference photo of a face and PuLID encodes it using FaceNet/InsightFace, then guides the generation to maintain that person's facial features throughout the diffusion process — without modifying your prompt or checkpoint. This is the standard Flux implementation.

6. PuLID (Flux: Nunchaku)

The same identity preservation as PuLID (Flux), but optimized for Nunchaku-quantized Flux models. If you're running a quantized model to reduce VRAM usage, use this group instead of PuLID (Flux).

7. Flux Redux

Style transfer using Flux Redux. Load one or two reference images and the workflow encodes their visual style using CLIP Vision, then blends that style signal into your generation. Unlike img2img, Redux influences the aesthetic without constraining the composition — your prompt still drives the structure.

8. Preprocessor

Prepares a reference image for use with ControlNet or depth-based img2img pathways. It scales the image to a safe resolution (target 1.68M pixels) to avoid out-of-memory errors, then runs the Zoe DepthAnything preprocessor to extract a depth map. You only need this group active when using ControlNet, the i2i (Flux Preproc) toggle in Initial Render, or the i2i (DiffSynth: Qwen Lora) toggle.

9. ControlNet

Structural conditioning — guides where objects and shapes appear in the generated image without needing to describe them in text. Supports:

Standard ControlNet union-promax — General-purpose structural conditioning (strength 0.75).
DiffSynth Qwen/ZIT ControlNet — Alternative ControlNet using the Z-Image-Turbo model (strength 0.65).

Image Sources & Pre-processors (Groups 10–17)

The workflow offers three ways to get a starting image. Only one should be active at a time — the pipeline automatically picks whichever source is enabled. A loaded image can serve two purposes: as a visual reference for img2img generation, or simply as input for the Image to Prompt group to generate a text description.

You can also load an image and skip the Initial Render entirely — disable the Initial Render switch in the Initial Render Group, and the loaded image goes straight to post-processing. This lets you bring in images from anywhere (other workflows, other tools, photographs) and run them through the full detailer/upscale pipeline.

10. Image Load

Loads a single image from disk. This is the simplest option — pick a file and go. It also extracts any embedded generation metadata (model name, prompt, sampler, seed) from the image, and a Show Text [Stop] node labeled Metadata Preview pauses the workflow so you can read it before proceeding. Useful for "remix" workflows where you want to regenerate with the same settings that produced the original.

11. Image Load from Folder

Batch processing mode — loads images one by one from a folder. Like Image Load, it exposes the extracted metadata and a Stop for review.

Set the index to -4 for shuffle mode (random order, no repeats). The optional seed_input slot controls when special modes advance — connect a seed and keep it fixed to freeze the selection while you tweak other settings. Change the seed value to advance to the next image.

12. Image Load from Folder / Video

Native video support and interactive frame selection. It can decode PyAV video frames or load sequential image files from a folder. After loading, the Image Selector node shows a visual grid so you can click exactly which frames or images you want to process before the workflow continues.

After selecting a source, the image can pass through several optional processing steps:

13. Remove Background

Removes the background using BiRefNet, isolating the subject on transparency. Useful when the background would interfere with generation or when you want to focus the generation on the subject only.

14. Image Crop (Auto)

Automatic subject-aware cropping using SegmentAnything (SAM) to detect the main subject and crop tightly around it. Good when you want to zoom in on a subject without manually defining a bounding box.

15. Image Crop (Custom)

Manual bounding-box cropping with pixel-level controls. For when auto-crop doesn't frame things the way you want, or when you need to crop a specific region precisely.

16. Resize Image

Resizes your input image to specific dimensions. A Preview Image (DOM) [Stop] node labeled Preview lets you verify the scale looks right before the image enters the rendering pipeline.

17. Image to Prompt

Uses the Qwen3.5 9B vision model to analyze your reference image and generate a detailed text description of it. That description can then feed directly into the Prompt group as one of your prompt sources — so you can start from a visual reference without needing to describe it manually. The default setup runs Qwen3.5 via Ollama (Docker) (huihui_ai-qwen3.5-abliterated-9b-Claude-Ollama) — Ollama handles model serving locally so you don't need to manage GPU memory for it manually. A Show Text [Stop] node exposes the generated description and pauses so you can review or edit it before generation.

Model swap: The backend is determined by the model name suffix in the Smart LM Loader's model list — names ending in -Ollama use Ollama, -GGUF use llama.cpp, -VLM use the VLM backend. Models without any suffix are native HuggingFace Transformers models — just select one from the list to use it instead. If the selected model isn't found locally, it is automatically downloaded from Ollama Rigistry / HuggingFace on first use.

The image source chain has a built-in priority system: it checks from the last processing step backward (resize → crop_custom → crop_auto → rembg → video_folder → folder → load) and uses the first active result. So you can stack processing steps and the last one wins.

Prompt Construction & Core Rendering (Groups 18–26)

This section at the bottom-left builds your prompts and executes the initial rendering passes.

18. Raffle (Forked Version)

Random prompt generation from a curated tag system. Raffle builds prompts by randomly selecting tags from categories (subject, pose, clothing, setting, etc.) with seed-controlled reproducibility — the same seed always produces the same combination. Includes a Negative Prompt (Output Filter) field to screen out unwanted tags from the raffle output. A Show Text [Stop] node lets you review what was drawn before generation.

19. Read Prompt from Files

Loads prompts from external text files, letting you maintain a library of saved prompts and cycle through them. A text substitution node lets you do find-and-replace on loaded prompts, and a Show Text [Stop] node shows you which prompt was loaded before proceeding.

Set the index to -4 for shuffle mode. Connect a seed to the seed_input slot and keep it fixed to freeze the prompt selection — change the seed value to advance to the next prompt in the file.

20. Prompt

The central prompt assembly hub. This is where all prompt sources come together into the final positive and negative prompts. You can use any combination of inputs — just the manual text field, manual + raffle, image-to-prompt + files, or any other mix:

Wildcard Processor — Template-based prompting with __wildcard__ placeholders that get randomly resolved from your wildcard files.
Smart Prompt v2: Subject — A structured builder with dropdowns for gender, age, hair, clothing, pose, etc.
Smart Prompt v2: Settings — An scene builder with dropdowns for angles, lighting, style, location, time of day, weather, etc.
Metadata from Load Image — When enabled, merges the positive and negative prompts extracted from the loaded image's embedded metadata (from Image Load or Image Load from Folder) directly into the prompt assembly. Useful for re-generating or remixing an image using the exact prompts that originally produced it, without having to copy and paste anything manually.
Join nodes — Combines all active inputs (manual text, raffle output, Image-to-Prompt result, file prompts, metadata prompts) into one string.
String DeDuplicate — Automatically removes duplicate tags or phrases from the combined negative prompt.
Prefix / Suffix — Optional quality tags (like "masterpiece, 8K") added before or after your prompt.

21. Prompt Styler

Wraps your positive prompt in a pre-built style template. Set to natural_language / photo-hdr by default. A Show Text [Stop] node shows the styled prompt before generation so you can verify the result before committing.

22. Prompt Edit

AI-powered prompt rewriting using the Qwen3.5 4B model. It takes your assembled prompt and creatively rewrites it while preserving the core meaning — useful for generating variations or improving prompt quality without manual editing. A Show Text [Stop] node shows you the rewritten result.

Model swap: The backend is determined by the model name suffix in the Smart LM Loader's model list — names ending in -Ollama use Ollama, -GGUF use llama.cpp, -VLM use the VLM backend. Models without any suffix are native HuggingFace Transformers models — just select one from the list to use it instead. If the selected model isn't found locally, it is automatically downloaded from Ollama Rigistry / HuggingFace on first use.

23. Save Prompts

Saves the final assembled prompt to a text file for later reference. A Show Text [Stop] node shows you what was saved.

24. Initial Render

The core generation step — where your prompt and model settings become an actual image. This is the primary sampling pass (txt2img or img2img). You control it through individual sub-feature toggles:

Initial Render — The main sampling pass. Disable this switch to skip generation and feed a loaded image directly into post-processing.
Noise Injection — Injects additional noise patterns into the latent before sampling (strength 0.45). Can add texture and break up uniformity.
Detail Daemon — Micro-detail enhancement applied during the sampling steps for sharper fine details.
Flux Guidance — CFG control specifically tuned for Flux models. Enable when using a Flux checkpoint.
i2i (Denoise) — Standard img2img: encode a reference image to latent and denoise it. Denoise strength 0.3–0.7 is typical.
i2i (Flux Lora + Preproc) — Flux ControlNet LoRA pathway using the preprocessed depth map from Preprocessor. Requires the Preprocessor group active.
i2i (Qwen Lora + Preproc) — Qwen LoRA variant pathway. Requires the Preprocessor group active.
Negative Prompt — Enable/disable negative conditioning.

After sampling, an Image Selector node lets you interactively pick which of the generated frames to carry forward. This is useful when batch_size > 1 in the Group Folder / Resolution, or when multiple images or video frames were selected in Image Load from Folder / Video — in those cases the pipeline produces several images and you choose which one continues into post-processing. If you are generating a single image, you can bypass this node manually.

25. Upscale (2ND Pass)

A second sampling pass that takes the initial render's latent output, upscales it 1.25× in latent space, and runs another round of diffusion. This adds detail that wasn't achievable at the original resolution. Offers two samplers: a standard KSampler for speed, or the ClownShark Sampler (from RES4LYF) for more aggressive detail enhancement.

26. Initial Render (Preview)

A checkpoint between generation and post-processing. It shows you the output of the initial render / 2nd-pass upscale and gives you the option to save it before continuing. Includes an Image Comparer (After / Before) and a Preview Image (DOM) [Stop] so you can inspect the result and decide whether to proceed into the full post-processing pipeline.

Right Half — Post-Processing & Detailing

Post-Processing Stage 1 (Groups 27–32)

This section at the bottom-right handles primary image modifications, face detailing, and upscale passes. Remember: the post-processing groups flow right across the bottom row, not top-to-bottom.

27. Flux2 Refine (3RD Pass)

A third refinement pass using a dedicated Flux2 checkpoint (Flux2_Kleinova_v3 by default). Low denoise keeps changes subtle — it improves texture quality and softens artifacts from the initial render without significantly altering the composition. An Image Comparer (After / Before) shows you exactly what changed.

28. Flux2: Face Swap

Diffusion-based face replacement using a two-pass BFS (Best Face Swap) architecture — no third-party face swap package needed, built entirely from Eclipse and core ComfyUI nodes. Here's how it works:

Smart Detection locates the face in the image using the Anzhc face segmentation model.
The face region is cropped out and encoded to latent space.
BFS 1st pass re-generates the face using a dedicated Flux2 checkpoint (Flux2_Klein_DarkBeastBFS) with full denoise, producing a fresh face that matches the style and lighting of the scene.
BFS 2nd pass refines the result with a second sampling pass for seamless blending back into the original image.

Because it uses actual diffusion sampling rather than a face swap model, the results naturally respect the art style and lighting of your image. A Preview Image (DOM) [Stop] node shows the cropped face detection so you can verify it found the right region before committing.

29. Flux2 Edit

A dedicated image-to-image editing pass for Flux2. Unlike the refiner (which applies low denoise globally), this is a full editing pass intended for targeted changes. It uses its own Smart Model Loader (Edit) and includes a Color Match operation to blend the edit result back without introducing color drift. An Image Comparer shows you what changed.

30. Tile Upscale (4th Pass)

A fourth, tile-based upscaling pass (new in RB8). Instead of upscaling the whole image at once, it splits it into overlapping tiles, runs each tile through a dedicated upscale model, then seamlessly stitches them back together. This allows very high-resolution upscaling without running out of VRAM. An Image Comparer (After / Before) highlights the improvement, and a Stop node lets you review before continuing.

Model priority: This group has its own dedicated model loader. If that loader is bypassed, it falls back to Model Loader (Detailer). If Model Loader (Detailer) is also muted or bypassed, it falls back to Model Loader (Main).

31. Upscale / Sharpen

The primary resolution enhancement stage. Combines model loading, tiled model upscaling, resizing, and sharpening into one atomic operation:

Model-based Upscaling: Runs tiled inference through a neural upscale model (e.g. 4x AnimeSharp) and automatically scales the output to exactly your target size — no manual math needed.
Bypass Mode: Set model_name to None and it skips the neural model entirely, doing a clean standard resize instead.
Smart Sharpening: An optional bilateral-filter-based sharpening pass that enhances edges without introducing halos.

32. Detailer: 1 (Face)

The first of six detailer groups. Detailers work by detecting a specific region, creating a precise mask, then inpainting just that region at low denoise to enhance detail without affecting the rest of the image. This group targets faces:

Detects the face using the Florence-2 model.
Creates a clean mask with SAM2.1 + VITMatte for precise edge handling.
Inpaints the face region at low denoise using the darkBeast Blitz6 model loaded in Model Loader (Detailer).
An Image Comparer lets you review the before/after, and a Stop node pauses here for verification.

Post-Processing Stage 2 (Groups 33–37)

Located in the middle-right row, this stage focuses on eyes, mouth, and hands. All five groups share an identical architecture to Detailer: 1 (Face) — they detect, mask, inpaint, and compare. They run sequentially, each picking up the output of the previous one automatically.

33. Detailer: 2 (Eye)

Enhances eye detail and clarity. Eyes are small and easy to lose in the initial render — this pass brings back the fine iris and catchlight detail.

34. Detailer: 3 (Mouth)

Enhances mouth and teeth detail. Teeth in particular often come out blurry or melted in initial renders; this pass corrects that.

35. - 37. Detailer: 4 to 6 (Hand / Placeholder)

First-pass hand detailing. Hands are notoriously difficult for diffusion models — this pass detects and inpaints them at higher denoise to reconstruct correct anatomy.

Model priority: Each detailer group has its own model loader that can be individually bypassed. If a detailer's own loader is bypassed, it falls back to the centralized Model Loader (Detailer). If Model Loader (Detailer) is also muted or bypassed, it falls back to Model Loader (Main). Step count is inherited from whichever model loader is active, not hardcoded.

Detection model: For standard regions like face, eye, mouth, and hand, Florence2-large-ft is the recommended detection model — it gives the best accuracy out of the box. For sensitive or private body parts, Florence2-large-ft is not suitable (it won't detect them). In those cases, switch to either an abliterated model like claude-opus from huihui (a fine-tuned version with content restrictions removed) or a YOLO model with specific training for the target region. Both can be selected in the Smart Detection node inside the detailer group.

Post-Processing Stage 3 & Publishing (Groups 38–44)

Located in the top-right row, this stage completes the upscaling, filtering, and watermarks before final save.

38. SeedVR2 (Upscale)

AI-powered upscaling using the SeedVR2 7B DiT diffusion model — a video upscaler repurposed for single images. Because it uses a full diffusion model rather than a classic upscale network, it can hallucinate plausible high-frequency detail rather than just interpolating existing pixels. Bypassed by default due to its high VRAM cost.

39. Image Final Crop

Tiled upscaling processes (like Tile Upscale or SeedVR2) often produce thin border artifacts along the edges — blurry strips or seam lines where the tiling stitching didn't blend perfectly. This group is primarily there to trim those away. It also serves as a general reframing pass if you want to adjust the composition after upscaling. Exposes an Inset & Crop control to set how many pixels to cut from each edge, an Image Resize to bring the result back to your target dimensions, an Image Comparer for before/after comparison, and a Preview Image (DOM) [Stop] to verify before continuing.

40. Rescale Image

Final size and color adjustment, applied in order:

Color Match (wavelet, strength 0.3) — Matches the color palette back to the original reference image, undoing any color drift introduced by upscaling and detailing.
Image Rescale — Bicubic 1.25× rescale with supersample enabled, which renders at a higher internal resolution then downscales for cleaner, anti-aliased results.
Image Soften — A slight edge blur to remove rescaling artifacts.
Image Smart Sharpen — A final sharpening pass to restore edge clarity after softening.

A Fast Mode Toggle lets you bypass the nodes in this group entirely, and a Preview Image (DOM) [Stop] shows the final result.

41. Image Adjustments

Advanced post-render color and tone control (new in RB8). Use this to fine-tune the final look without going back to regenerate:

Contrast, Brightness, Saturation — Global tonal adjustments.
Shadows & Highlights — Recover crushed darks or blown highlights.
Color Temperature — Shift the white balance warm or cool.

An Image Comparer shows you exactly how your adjustments changed the image, and a Preview Image (DOM) [Stop] gives you a live review before saving.

42. Create Watermark (Text)

Overlays a text watermark on the finished image. Default text is "WF (iGEN-ONE-RB8)" and "© Eclipse". Gives full control over font, size, color (default: cyan→blue gradient), opacity, drop shadow, and outer glow. Useful for publishing or crediting your workflow.

43. Create Watermark (Logo)

Overlays a custom logo image instead of (or in addition to) text. Loads a logo file, optionally desaturates it to match your image's tone, then blends it in with configurable position, opacity, drop shadow, and outer glow. A Preview Image (DOM) [Stop] lets you verify the result before saving.

44. Save Image

The final output node. It doesn't just save whatever arrived last — it actively checks all possible sources through a priority chain, from the most post-processed output back to the raw input, and saves whichever is the last active one:

watermark_logo (img_out_cr2) → watermark_text (img_out_cr1) → image_adjustments (img_out_filter) → rescale (img_out_rescale) → final_crop (img_out_crop) → seedvr2 (img_out_svr2) → Detailer 6 (hand) → Detailer 5 (hand) → Detailer 4 (hand) → Detailer 3 (mouth) → Detailer 2 (eye) → Detailer 1 (face) → upscale (img_out_upscale) → tile_upscale (img_out_tileup) → edit (img_out_edit) → bfs (img_out_bfs) → refiner (img_out_refiner) → initial_render (img_out_init) → loaded_reference (ref_image)

This means you can enable or disable any combination of groups and Save Image will always find the right output automatically — no rewiring needed. The image is saved with full embedded metadata: workflow JSON, generation data (all models, VAEs, LoRAs, prompts, dimensions, sampler settings).

Two groups should always be kept active: Save Image (obviously — this is your output) and Initial Render (Preview). The latter is not just a preview checkpoint — it also sets the reference image that all post-processing groups in the right half read from. If it is muted, post-processing groups won't have a source image to work with. Everything else is optional.

Quick Start Guide

Simplest Setup — Text to Image

Make sure the image input groups are bypassed (Image Load, Image Load from Folder, Image Load from Folder / Video).
In the Prompt group, type your prompt in the Wildcard Processor text field and your negative prompt in the Negative Prompt field.
In the Folder / Resolution group, set your desired image dimensions.
Make sure Model Loader (Main) is active with your preferred checkpoint.
Make sure Initial Render and Save Image are active.
Bypass everything else you don't need.
Queue the prompt.

Image to Image

Enable Image Load and select your source image.
Enable the Resize Image group so your image is resized to match the dimensions set in Folder / Resolution — this avoids issues with oversized images.
In the Initial Render group, enable the i2i (Denoise) toggle and set your denoise strength (0.3–0.7 is typical).
Queue the prompt.

Post-Process an Existing Image (Skip Render)

You can load any image and send it straight to the post-processing pipeline — bypassing the initial generation step entirely:

Enable Image Load (or folder loaders) and select your source image.
Disable the Initial Render switch in the Initial Render group to skip the sampling pass.
- Stop Toggle Requirement: You must switch off the Stop toggle inside the Initial Render group. If left enabled, the workflow will throw an error because the node will not receive an image input.
- Upscale (2ND Pass) Interaction: If Upscale (2ND Pass) remains active, the workflow will feed the loaded image directly into that second sampling pass instead of going straight to post-processing. Turn off both Initial Render and Upscale (2ND Pass) if you want to bypass all sampler passes entirely.
Enable whichever post-processing groups you want (Flux2 Refine, Flux2: Face Swap, detailers, Upscale / Sharpen, Tile Upscale (4th Pass), etc.).
Queue the workflow — the pipeline picks up your loaded image and runs it through the active post-processing chain.

This is one of the most useful features of the workflow. You can bring in any image — from a different workflow, a different tool, or even a photograph — and run it through the full detailing, upscaling, and watermarking pipeline without generating anything.

Adding Post-Processing to an Existing Run

Generate your base image first (Initial Render + Save Image active).
Enable the post-processing groups you want (Flux2 Refine, Upscale / Sharpen, detailers, etc.).
Re-queue — the pipeline chains them all automatically.

Using Detailers

Enable any detailer groups you want (Detailer: 1 through Detailer: 6).
Each detailer auto-detects its target region — no manual masking needed.
Check the Image Comparer in each group to verify the result.
Adjust denoise strength if the changes are too subtle or too aggressive.

Troubleshooting

The workflow stops halfway through

Almost every functional group in iGEN ONE has a Stop option. If the workflow stops unexpectedly, check the Stop toggles in these groups:

Image loader groups (Image Load, Image Load from Folder, Image Load from Folder / Video)
Image pre-processing groups (Remove Background, Image Crop Auto, Image Crop Custom, Resize Image, Image to Prompt)
Prompt groups (Raffle, Read Prompt from Files, Prompt Styler, Prompt Edit, Save Prompts)
Initial Render and Initial Render (Preview)
Post-processing groups (Flux2 Refine, Flux2: Face Swap, Flux2 Edit, Tile Upscale (4th Pass))
Each detailer (Detailer 1 through 6)
Image Adjustments
Watermark groups (Create Watermark (Text), Create Watermark (Logo))

Disable the Stop toggle in any group where you want execution to continue through to the end.

If you queue the workflow and it seems to finish too early — before reaching Save Image — a Stop toggle is almost always the reason. Check the last group that produced output and disable its Stop switch.

Toggles reset when activating a group

When you change a group's state (mute → active or bypass → active), all toggles in that group reset to their defaults — which means all enabled. This can turn on sub-features you didn't expect, including the Stop toggle. After activating a group, always review its toggle panel and disable anything you don't need.

This is the most common source of confusion. If something behaves differently after you re-activate a group, check its toggles — they've all been reset to enabled.

Custom Node Packages Used

Primary (author's own):

ComfyUI_Eclipse — The backbone of this workflow. Provides loaders, pipes, Set/Get routing, Mode Bridges, Mute/Bypass Repeaters, Smart Prompt, Smart Folder, Smart Detection, Smart LM Loader, Smart Sampler Settings, Save Images, Image Comparer, and many more.
RES4LYF — ClownShark Sampler (advanced sampling with detail boost) — fork of ClownsharkBatwing/RES4LYF.
ComfyUI_PuLID_Flux_ll — Commercial-friendly, memory-optimized face similarity conditioning using FaceNet/InsightFace — fork of lldacing/ComfyUI_PuLID_Flux_ll.
ComfyUI-Raffle — Random prompt generation from tag categories — fork of rainlizard/ComfyUI-Raffle.

Third-party:

pysssss Custom-Scripts — ShowText for prompt preview display.
KJNodes — Image resize, PatchSageAttention.
SeedVR2 VideoUpscaler — AI-powered upscaling.
Nunchaku — Quantized model support and PuLID integration.
Impact Pack — SEGSPreview for detailer visualization.
LayerStyle — Drop shadow, outer glow, SAM2Ultra, MaskGrow, ImageAutoCrop, and more.
LayerStyle Advance — Extended LayerStyle nodes (SAM2 Ultra V2, VITMatte).
Advanced ControlNet — ACN_AdvancedControlNetApply_v2.
BiRefNet — Background removal.
VHS (VideoHelperSuite) — Video frame loading.

If you made it this far — you're a legend. Now go generate something beautiful. 🌒

Files with SHA256: 63d93f095290a0d92a5103a296f3ca3d7d597d09f0e69e692f6e08ceb452ca59