iGEN ONE (RB5) — Workflow Guide

494 nodes · 43 groups · 38 component subgraphs · 3 rows (4 quadrants)

114 unique node types — 74% Eclipse nodes at the top-level
1,067 flattened nodes (subgraphs expanded) — 70% Eclipse nodes overall
Built with ComfyUI_Eclipse custom nodes
PuLID fix: PuLID Flux II

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 RB5 version is a large-scale, full-featured release containing the complete suite of image loaders, ControlNet processors, style transfer networks, detailers, and upscalers.

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–31). Contains Flux2 Refine (3rd pass), BFS Face Swap, Flux2 Edit, Upscale Image, and Detailer 1 (Face).
Top-Right Quadrant (Row 1 & 2, Right): Detailers & Finishing (Groups 32–42). Contains Detailer 2 (Eye), Detailer 3 (Mouth), Detailer 4 (Hand 1), Detailer 5 (Hand 2), Detailer 6 (Hand 3), SeedVR2 Upscale, Final Crop, Rescale, Watermarks, and Save Image.

S-Curve (Snake) Post-Processing Flow

While the left half is arranged by function, the post-processing pipeline on the right half flows in an S-curve (snake) pattern moving upwards:

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

Toggling Features & Embedded Subgraph Stops

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.

Embedded Subgraph Stops: Almost every functional group (including loader metadata previews, crops, prompt steps, samplers, detailers, and watermarks) features an embedded Stop (Result Review) or Stop (Detection Review) node built directly inside its subgraphs.
Canvas Space Optimization: By embedding these Stop checkpoints inside the subgraphs rather than keeping them as loose nodes on the top level, the workflow drastically reduces the number of individual Fast Mode Toggle widgets needed in the main workspace. This cleans up group interfaces and reduces the vertical height of every group by 15.6% (shrinking from 958px in RB4 to 808px in RB5), saving significant canvas space and making the overall layout much cleaner and more compact.
Intermediate Reviews: When enabled via the toggle panels, these embedded Stops pause ComfyUI's execution and display intermediate previews (using Show Text or Preview Image (DOM) nodes) so you can visually verify the output of that specific step.

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).

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 — 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.

Left Half — Generation & Configuration

Model Loading & Configuration (Groups 0–9)

This section at the top-left houses the settings and model loading pathways.

0. Folder / Size

The configuration hub for the workflow. Sets:

Output folder structure (with date-based subfolders).
Image dimensions — default is 896×1152 (3:4 aspect ratio, good for portraits).
Batch size — how many images to generate per run.
Latent type — SD3/Flux/Wan/HunyuanVideo.
VRAM purge behavior.

1. Model Loader (Main)

Loads the main checkpoint using Eclipse's Smart Model Loader. The default configuration loads darkBeast v9 (darkBeast) via the ZIT_DarkBeast_v9 template in UNet mode with default weight dtype. Uses an external CLIP model (Qwen3-4b-Z-Image-Turbo-AbliteratedV1.safetensors of type lumina2) and an external VAE (flux_vae.safetensors). The Smart Model Loader handles all the complexity of model configuration in one node.

Template-Based Downloads & Validation: Eclipse's shipped templates come pre-populated with AIR (Civitai Uniform Model Identifier) metadata and expected SHA256 hashes.
Missing File / Download Behavior: If a template is loaded but the model file is not found in your local ComfyUI models folder, the loader displays an interactive Download button in the UI. If a CivitAI API Key is configured in Eclipse, clicking this button automatically resolves, fetches, and saves the correct model version directly into the appropriate folder.
Integrity Verification (verify_file): Allows you to control file hashing:
- off: No integrity checks (default).
- sidecar: Calculates the model's SHA256 once and saves it as a .sha256 sidecar file to speed up future loading steps.
- verify: Calculates the model's hash and actively validates it against the expected SHA256/AIR in the template, warning you if there is any file corruption or mismatch.

2. Model Patcher (Main)

A collection of 11 optional model modifications, each independently toggleable via a Fast Muter panel:

ModelSamplingFlux — Flux-specific guidance parameters.
ModelSamplingAuraFlow — AuraFlow sampling override.
DynamicThresholdingFull — CFG thresholding for better prompt adherence.
PerturbedAttentionGuidance (PAG) — Self-attention manipulation for more detail.
SelfAttentionGuidance (SAG) — Feature map attention enhancement.
DifferentialDiffusion — Mask-based selective denoising.
CFGZeroStar — Alternative CFG guidance technique.
PatchSageAttention — Memory-efficient attention (reduces VRAM usage).
TorchCompileModel — JIT compilation for faster inference.
TeaCache — Token caching for speed improvement.
UNetTemporalAttentionMultiply — Temporal attention modification.

3. Model Loader (Detailer) & 4. Model Patcher (Detailer)

A centralized model routing system for all detailer groups on the right half. Rather than loading independent models inside each detailer subgraph, they all share this dedicated model loader and patcher, standardizing execution and preventing VRAM thrashing.

Model Loader (Detailer): Loads darkBeast Blitz6 (darkBeast Blitz6) via the ZIT_DarkBeast_Blitz6 template in UNet mode with default weight dtype. Uses an external CLIP model (huihui-qwen3-4b-abliterated-v2-q8_0.gguf of type lumina2) and an external VAE (flux_vae.safetensors).
Model Patcher (Detailer): Applies custom detailer performance and attention patches.

5. PuLID (Flux)

Identity preservation using PuLID. Load a reference face photo and PuLID will guide the generation to maintain that person's facial features in the output. Uses pulid_flux_v0.9.0 with a configurable strength weight.

6. PuLID (Flux: Nunchaku)

Same concept as PuLID Flux, but optimized for Nunchaku-quantized Flux models. Uses pulid_flux_v0.9.1 + EVA02_CLIP.

7. Flux Redux

Style transfer using Flux Redux. Load one or two style reference images and the workflow applies their visual style to your generation via CLIP Vision encoding and StyleModelApply. Supports blending two references at different strengths.

8. Preprocessor

Image preprocessing for ControlNet. Uses Zoe DepthAnything for depth map extraction. Only needed when the ControlNet group is active.

This group is also needed when using Flux ControlNet LoRAs (like depth) or the DiffSynth Qwen LoRA — their sub-feature toggles are i2i (Flux Preproc) and i2i (DiffSynth: Qwen Lora) in the Initial Render group. You must activate the Preprocessor group manually when using either of these.

9. ControlNet

Structural conditioning with four toggleable modes:

Standard ControlNet — xinsir union-promax (strength 0.75).
Union Type — Select specific control type (depth, canny, etc.).
Negative Zero — Zero-out negative conditioning.
DiffSynth Qwen/ZIT ControlNet — Alternative ControlNet using 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 (Group 17) to generate a text description.

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

10. Image Load

Loads a single image from disk and extracts any embedded generation metadata (model name, prompt, sampler, seed) to optionally override the workflow's settings. Contains an embedded Stop (Result Review) inside its Metadata Preview subgraph to reduce top-level toggle count.

11. Image Load from Folder

Batch processing mode. Loads images one by one from a folder, with controls for sorting (by name or date) and subfolder traversal. Contains an embedded Stop (Result Review) inside its Metadata Preview subgraph.

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 the same value to freeze the image selection while you tweak other settings. Change the seed value to advance to the next image.

12. Image Load from Folder / Video

Native video decoding and interactive frame selection.

Load Batch From Folder [Eclipse]: Decodes frames from a video file (using PyAV) or reads a folder of sequential frames, returning the entire sequence as a single batch. Supports directory recursion and multiple absolute paths (one folder/video per line).
Image Selector [Eclipse]: On first execution, this node displays a visual overlay of all loaded frames directly in the ComfyUI frontend and pauses processing. The user clicks to select frames (supporting Shift+click range selections, Ctrl+A to select all, and filter searches), then clicks "Confirm" to automatically re-queue the workflow and output the selected subset.

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. Contains an embedded Stop (Result Review) toggle in its subgraph.

14. Image Crop (Auto)

Automatic subject-aware cropping. Uses SegmentAnything (SAM) to detect the main subject, centers the crop, and resizes to target dimensions. Contains an embedded Stop (Result Review) toggle in its subgraph.

15. Image Crop (Custom)

Manual bounding-box cropping with pixel-level controls. Contains an embedded Stop (Result Review) toggle in its subgraph.

16. Resize Image

Simple resize to specific dimensions. Used when your input image doesn't match the target generation size. Contains an embedded Stop (Result Review) toggle in its preview subgraph.

17. Image to Prompt

Uses the Qwen 9B vision model (Q4_K_M quantization) to analyze your reference image and generate a detailed text description. Contains an embedded Stop (Result Review) toggle inside its Prompt Preview subgraph.

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

Random prompt generation from a curated tag system. Raffle builds prompts by randomly selecting tags from categories (subject, pose, clothing, etc.) with seed-controlled reproducibility — every seed produces the same combination. Includes a negative output filter. Contains an embedded Stop (Result Review) toggle in its Prompt Preview subgraph.

19. Read Prompt from Files

Reads prompts from external text files (one prompt per line). Uses seed-based indexing to select which prompt to use. Contains an embedded Stop (Result Review) toggle in its Prompt Preview subgraph.

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.

20. Prompt

The central prompt assembly hub. This is where all prompt sources come together into the final positive and negative prompts.

Wildcard Processor — Template-based prompting with __wildcard__ placeholders.
Smart Prompt v2 (Subject) — A structured subject builder with dropdowns for gender, age, hair, clothing, etc.
Smart Prompt v2 (Settings) — Environment builder with dropdowns for location, time of day, weather, etc.
Join nodes — Combines all active prompt inputs (from Image-to-Prompt, Raffle, file reader, manual text).
String DeDuplicate — Automatically removes duplicate tags or phrases from the combined prompt.
Prefix / Suffix — Optional quality tags (like "masterpiece, 8K") added before or after your prompt.
Negative Prompt — A multiline text field for your negative prompt.

21. Prompt Styler

Wraps your positive prompt in a style template using Eclipse's Prompt Styler node (e.g. "photo-hdr"). Contains an embedded Stop (Result Review) toggle inside its Prompt Preview subgraph.

22. Prompt Edit

AI-powered prompt rewriting. Uses the Qwen 9B model with a "Rewrite Style" task to creatively improve prompt quality while preserving the core meaning. Contains an embedded Stop (Result Review) toggle in its Prompt Preview subgraph.

23. Save Prompts

Saves the final combined prompt to a text file. Can append to an existing file. Contains an embedded Stop (Result Review) toggle in its Prompt Preview subgraph.

24. Initial Render

The core generation step. Contains a component subgraph (41 internal nodes) that handles the actual sampling process.

Initial Render — The main txt2img or img2img sampling pass.
Noise Injection — Additional noise patterns injected into the latent (strength 0.45).
Detail Daemon — Micro-detail enhancement during sampling.
Flux Guidance — CFG control specifically for Flux models.
i2i (Denoise) — Standard img2img with configurable denoise strength.
i2i (Flux Preproc) — Flux ControlNet LoRA pathway (e.g. depth) — requires the Preprocessor group to be activated manually.
i2i (DiffSynth: Qwen/ZIT) — Qwen-based img2img pathway.
i2i (DiffSynth: Qwen Lora) — Qwen LoRA variant pathway — requires the Preprocessor group to be activated manually.
Negative Prompt — Enable/disable negative conditioning.
Stop — Halt execution after this render.

Default sampler: euler / simple / 25 steps / cfg 3.5 / denoise 1.0 — configured via Smart Sampler Settings v2.

25. Upscale (2ND Pass)

Second-pass latent-space upscaling. Takes the initial render's latent output, upscales it 1.25× with bicubic interpolation, and runs a second sampling pass.

Offers two samplers: a standard KSampler subgraph or the custom ClownShark Sampler subgraph (15 internal nodes from the RES4LYF pack). The ClownShark Sampler is an advanced sampler with detail boost, SDE, and sigma scaling options.

Default settings: dpmpp_2m / sgm_uniform / 36 steps / denoise 0.5. ClownShark sub-sampler: multistep/dpmpp_2m / beta / 11 steps / denoise 0.23.

26. Initial Render (Preview)

Preview and save checkpoint. Shows the generated image and optionally saves it with full metadata embedding (workflow JSON + generation data). Includes two Stop nodes: Stop (Before Save) and Stop (After Save) so you can halt here before entering the post-processing pipeline.

Right Half — Post-Processing & Detailing

Post-Processing Stage 1 (Groups 27–31)

This section at the bottom-right handles primary image modifications and face detailing.

27. Flux2 Refine (3RD Pass)

A third-pass refinement using a dedicated checkpoint (darkBeast Klein2) via a component subgraph (18 internal nodes). Uses SamplerCustomAdvanced with wavelet color matching (strength 0.75) to preserve the original color palette while refining details at low denoise (0.3). Contains an embedded Stop (Result Review) toggle in its subgraph to preserve top-level workspace space.

28. Flux2: Face Swap

Diffusion-based face replacement using a two-pass BFS architecture built entirely with Eclipse and core ComfyUI nodes. Contains two component subgraphs — BFS_1ST (33 internal nodes) and BFS_2ND (Refine) (30 internal nodes) — for progressive face re-generation.

BFS_1ST: Re-generates the face region using the dedicated detailer checkpoint (darkBeast Klein2) via SamplerCustomAdvanced at full denoise (1.0). Contains an embedded Stop (Result Review) toggle in the subgraph.
BFS_2ND (Refine): Refines the result with a second sampling pass for seamless blending. Contains an embedded Stop (Result Review) toggle in the subgraph.
Includes toggles for Detect / Crop Face and BFS2 (which enables/disables the second-pass BFS refinement).

29. Flux2 Edit

A dedicated image-to-image editing pass for Flux2 via a component subgraph (31 internal nodes). It utilizes its own model loader and a Color Match operation (wavelet color matching at 0.75 strength) to seamlessly integrate modifications. It also contains a custom text input field for localized editing prompts. Contains an embedded Stop (Result Review) toggle inside its subgraph.

30. Upscale Image

First upscale stage using the Image Upscale With Model v2 [Eclipse] node, which consolidates model loading, tiled model upscaling, standard resizing, and sharpening into a single atomic pass:

Combined Operations: Replaces the three classic ComfyUI nodes (Load Upscale Model, Upscale Image using Model, Upscale Image By) with a single configuration.
Flexible Interpolation: If model_name is set to None, the node bypasses model loading entirely and performs a high-quality standard resize (e.g. lanczos, bicubic) using the upscale_by multiplier.
Model Upscaling: When an upscale model is selected (e.g. 4x AnimeSharp), the node performs tiled inference. If upscale_by is greater than 0, it automatically scales the model's native output (e.g. 4×) to your exact target size.
Smart Sharpening: Includes an optional built-in bilateral-filtering-based Smart Sharpen pass (sharpen_enabled) to eliminate noise while preserving clean, sharp edges.

31. Detailer: 1 (Face)

Enhances facial details. Uses Florence-2 VLM with a face detection prompt, creating a precise mask using SAM2.1 + VITMatte. Runs via a component subgraph (46 internal nodes).

Contains both a Stop (Result Review) at the top level and an internal Stop (Detection Review) inside the subgraph.
Default settings: euler / simple / 0.2 denoise / guide_size 512.

Post-Processing Stage 2 (Groups 32–35)

Located in the middle-right row, this stage focuses on eye, mouth, and initial hand detailing.

32. Detailer: 2 (Eye)

Enhances eye details. Uses the same Florence-2 and SAM2.1 + VITMatte masking architecture with an eye detection prompt.

Contains both a top-level Stop (Result Review) and an internal Stop (Detection Review).
Default settings: euler / simple / 0.35 denoise / guide_size 512.

33. Detailer: 3 (Mouth)

Enhances mouth and teeth details using a mouth detection prompt.

Contains both a top-level Stop (Result Review) and an internal Stop (Detection Review).
Default settings: euler / simple / 0.4 denoise / guide_size 512.

34. Detailer: 4 (Hand 1)

First-pass hand detailing. Uses a hand detection prompt to locate and rebuild hand structures.

Contains both a top-level Stop (Result Review) and an internal Stop (Detection Review).
Default settings: euler / simple / 0.5 denoise / guide_size 512.

35. Detailer: 5 (Hand 2 / Customizable)

Set to hand by default in the template (acting as an extra hand pass), but serves as a generic slot that is not strictly hardcoded. The user can change the Florence-2 detection prompt to focus on any other custom region or details (e.g. hair, clothing, jewelry).

Contains both a top-level Stop (Result Review) and an internal Stop (Detection Review).
Default settings: euler / simple / 0.5 denoise / guide_size 512.

Post-Processing Stage 3 & Publishing (Groups 36–42)

Located in the top-right row, this stage completes the detailing, upscales, and watermarks the image before saving.

36. Detailer: 6 (Hand 3 / Customizable)

Also set to hand by default for a sequential third hand pass, but fully customizable by the user to target alternative prompts.

Contains both a top-level Stop (Result Review) and an internal Stop (Detection Review).
Default settings: euler / simple / 0.5 denoise / guide_size 512.

37. SeedVR2 (Upscale)

AI-powered upscaling using the SeedVR2 7B DiT diffusion model — a video upscaler repurposed for single images. Loads its own dedicated DiT model and VAE, processes in LAB color space for better color accuracy. Includes optional pre-resize and RAM cleanup controls. Bypassed by default (resource-heavy).

38. Image Final Crop

A final cropping pass applied to Row 2 outputs before final rescales. It utilizes an Inset & Crop subgraph (6 internal nodes) that features:

Inset & Crop [Eclipse]: Allows manual crop adjustment of the finalized image.
Image Resize [Eclipse]: Resizes the image back to its original dimensions (the size it was prior to cropping) by upscaling or cropping it further, maintaining layout consistency.
Stop (Result Review): Pauses execution inside the subgraph for final crop verification.

39. Rescale Image

Final size and quality adjustment utilizing a dedicated Rescale / Sharpen component subgraph (5 internal nodes):

Color Match [Eclipse] (wavelet color matching at 0.3 strength) — Matches colors back to the original reference to maintain target color grading.
Image Rescale [Eclipse] — Bicubic rescale at 1.25× with supersample enabled (on by default). Supersampling renders at a higher internal resolution and then downscales to avoid aliasing and keep edges clean.
Image Soften [Eclipse] & Image Smart Sharpen (2 passes) — Final smart sharpening and softening pass to polish the output.

40. Create Watermark (Text)

Overlays a text watermark ("© Eclipse") on the image. Configurable font, size, color, and position (default: bottom-right). Includes gradient effects (cyan→→blue) and optional Drop Shadow + Outer Glow. Contains an embedded Stop (Result Review) toggle inside its Preview subgraph.

41. Create Watermark (Logo)

Overlays a custom logo image as a watermark. Loads a logo file and places it at a configurable position (default: bottom-right) with customizable blending, desaturation, resizing, drop shadows, and outer glows.

Alpha Masking & Transparency: This feature works best with high-quality logo files that contain native transparency channels (e.g. professional photographer signature overlays or logos created via services like Photologo). Any logo image containing an alpha/transparency channel can be utilized to generate the precise masking required for the overlay.
Consolidated Preview: Contains an embedded Stop (Result Review) toggle inside its Preview subgraph to review the watermark layout before saving.

42. Save Image

The final output node. Collects the finished image from the entire pipeline using a priority chain that checks all possible sources in reverse order:

watermark_logo (img_out_cr2) →→ watermark_text (img_out_cr1) →→ 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) →→ edit (img_out_edit) →→ bfs (img_out_bfs) →→ refiner (img_out_refiner) →→ initial_render (img_out_init) →→ loaded_reference (ref_image).

This means it always saves the output from the last active processing stage, regardless of which groups are enabled. The image is saved with full embedded metadata (workflow JSON, generation data, all models, VAEs, and LoRAs collected from across the entire workflow).

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 / Size 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 / Size.
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:

Enable Image Load (or folder loaders) and select your source image.
Disable the Initial Render switch in the Initial Render group (Group 24) to skip the initial render step.
- 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 (since generation is skipped).
- Upscale (2ND Pass) Interaction: Note that if Upscale (2ND Pass) (Group 25) remains active, the workflow will feed the loaded image directly into that second rendering pass (2nd pass latent upscale sampler) instead of going straight to the Flux refinement (3rd pass) and detailing stages. 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 Image, etc.).
Queue the workflow — the pipeline picks up your loaded image and runs it through the active post-processing chain.

Troubleshooting

The workflow stops halfway through

Almost every functional group in iGEN ONE has a Stop option built either into its main nodes or directly inside its preview/processing subgraphs. This is useful for checking intermediate results, but they can halt execution if active. If the workflow stops unexpectedly, check the Stop toggles in these groups:

Image loader groups (Image Load, Image Load from Folder)
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)
Each detailer (Detailer 1 through 6)
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.

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.

Custom Node Packages Used

Primary (author's own):

ComfyUI_Eclipse — Loader templates, wireless Set/Get routing, Mode Bridges, Mute/Bypass Repeaters, Smart Prompt, Smart Folder, Smart Detection, Smart LM Loader, Smart Sampler Settings, Save Images, Image Comparer.
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: 70731cc3f92e9ce7d36d38310217c95add253cab6f0dae288a2f57808f28464e