ComfyUI-FluxProgressiveLockedUpscale

A single ComfyUI node that runs a 3-stage Flux pipeline — base generation, progressive locked-noise upscale, and an optional refine pass — all driven by a SAMPLER you connect (e.g. a RES4LYF ClownSampler).

It is a Flux-oriented port of the idea in ComfyUI-ZImageTurboProgressiveLockedUpscale, reworked so that all sampling goes through comfy.sample.sample_custom with your SAMPLER object instead of the built-in KSampler. That means you get the full RES4LYF engine — eta, SDE noise modes, res_2m / res_3s, bongmath, guides — for free, just by wiring a ClownSampler in.

Node name: Flux: Locked Progressive Upscale 3-Stage (RES4LYF) Category: upscale

---

Why this exists

Normal latent upscaling re-noises the whole image, so the model is free to drift the composition, faces, and text every time you go up in resolution. This node keeps the composition-bearing coarse structure exactly while only letting the model add fresh high-frequency detail at each new resolution.

It does that with four mechanics (all latent-shape based, so they're model-agnostic):

1. Progressive scale ladder — the total upscale is split into several small steps (each <= max_step_scale) instead of one big jump.
2. Locked noise (orthogonal subspace) — the noise used at the new resolution keeps the previous stage's coarse modes exactly and only injects new noise in the orthogonal (high-frequency) complement. It's still statistically N(0, I) at the new resolution, so the sampler behaves normally — but composition is preserved.
3. Pixel-space lifting — between stages the latent is decoded → upscaled (with your upscale_model if provided, else bicubic) → re-encoded, so detail rides on real pixels.
4. Sigma-sliced partial denoise — each upscale stage runs only the tail of the schedule (tail_steps_*), so the model refines rather than redraws.

---

The 3 stages

| Stage | When it runs | Controls | |-------|--------------|----------| | 1 — Base generation | Only when an empty latent is fed in | base_steps, base_scheduler, optional base_sampler | | 2 — Progressive locked upscale | Always | upscale_factor, max_step_scale, upscale_steps, upscale_scheduler, tail_steps_first_upscale, tail_steps_last_upscale, main sampler, optional upscale_model | | 3 — Refine | When enable_refine is on | refine_steps, refine_scheduler, refine_enter_sigma, optional refine_sampler |

All three stages currently share the same model, vae, positive, negative, cfg, and seed (single-model Flux). Each stage gets its own scheduler + step count, and Stage 1 / Stage 3 can take their own SAMPLER (or fall back to the main one).

---

Inputs

Shared

| Input | Type | Notes | |-------|------|-------| | model | MODEL | Your Flux model. | | latent | LATENT | Empty latent → full generation (Stage 1 runs). Non-empty → img2img-style upscale (Stage 1 skipped). | | positive / negative | CONDITIONING | Prompt conditioning. | | vae | VAE | Used for the decode/encode handoffs between stages. | | sampler | SAMPLER | Main sampler (RES4LYF ClownSampler). Drives Stage 2, and is the fallback for Stages 1 & 3. | | cfg | FLOAT | Keep 1.0 for guidance-distilled Flux (use a FluxGuidance node on the conditioning instead). | | seed | INT | Master seed; per-stage seeds are derived deterministically from it. |

Stage 1 — Base generation

| Input | Type | Default | |-------|------|---------| | base_steps | INT | 20 | | base_scheduler | combo | beta57 | | base_sampler (optional) | SAMPLER | falls back to sampler |

Stage 2 — Progressive locked upscale

| Input | Type | Default | Notes | |-------|------|---------|-------| | upscale_factor | FLOAT | 6.0 | Total upscale relative to the input latent. | | max_step_scale | FLOAT | 1.6 | Max per-stage ratio. Number of stages ≈ ceil(log(factor)/log(max_step_scale)). | | upscale_steps | INT | 20 | Base schedule length; each stage runs only its tail. | | upscale_scheduler | combo | beta57 | beta57 / ays_kl / any comfy scheduler. | | tail_steps_first_upscale | INT | 6 | Tail steps for the first (smallest) upscale → stronger refine. | | tail_steps_last_upscale | INT | 3 | Tail steps for the last (largest) upscale → lighter touch. | | upscale_model (optional) | UPSCALE_MODEL | — | Pixel-space upscaler (e.g. RealESRGAN); bicubic if unset. |

Stage 3 — Refine

| Input | Type | Default | Notes | |-------|------|---------|-------| | enable_refine | BOOLEAN | True | Off → node returns the upscale result directly. | | refine_steps | INT | 20 | Schedule length; executed steps depend on refine_enter_sigma. | | refine_scheduler | combo | beta57 | | | refine_enter_sigma | FLOAT | 0.60 | Enter the schedule at this sigma. Lower = less denoise = more preservation. Retune for Flux (often higher than the Z-Image default). | | refine_sampler (optional) | SAMPLER | falls back to sampler |

Outputs

| Output | Type | |--------|------| | latent | LATENT | | image | IMAGE | | seed | INT |

---

Example workflow (full generation → finished image)

Load Checkpoint / UNet ─┬─ MODEL ─────────────────────────────┐
                        └─ VAE ────────────────────────────┐  │
CLIP Text Encode (+) ── CONDITIONING ─(FluxGuidance)─┐      │  │
CLIP Text Encode (−) ── CONDITIONING ────────────┐  │      │  │
EmptyLatentImage (e.g. 144×208) ── LATENT ─────┐  │  │      │  │
RES4LYF ClownSampler ── SAMPLER ────────────┐  │  │  │      │  │
                                            ▼  ▼  ▼  ▼      ▼  ▼
                        Flux: Locked Progressive Upscale 3-Stage
                                            │
                                            ├── IMAGE → Save Image
                                            └── LATENT → (optional further work)

• Full generation: feed an empty EmptyLatentImage at your small base size (e.g. 144×208). Stage 1 generates the base, Stage 2 walks it up by upscale_factor, Stage 3 polishes. The whole image comes out of one node.
• Upscale an existing image: VAE Encode your image → feed that LATENT in. Stage 1 is skipped automatically and the node just upscales + refines.

eta, bongmath, SDE noise mode, res_2m/res_3s, etc. are all set on the ClownSampler node, not here — wire different ClownSamplers into sampler / base_sampler / refine_sampler if you want different behavior per stage (e.g. eta=0.5 for base/upscale, a clean eta=0.0 ClownSampler for refine).

---

Installation

ComfyUI Manager (Git URL)

Manager → Install via Git URL:

https://github.com/lookuters22/ComfyUI-FluxProgressiveLockedUpscale

Manual

cd ComfyUI/custom_nodes
git clone https://github.com/lookuters22/ComfyUI-FluxProgressiveLockedUpscale

Restart ComfyUI. No extra Python dependencies — it only uses what ComfyUI already ships (torch, comfy internals). A RES4LYF install is recommended so you have a ClownSampler node to drive it (any SAMPLER works, but RES4LYF is the intended pairing).

---

Notes & tuning

• cfg: leave at 1.0 for distilled Flux and control guidance via a FluxGuidance node on the positive conditioning.
• refine_enter_sigma: Flux flow sigmas differ from Z-Image. Start around 0.5–0.8 and raise it for a stronger refine, lower it to preserve more of the upscale result.
• Stages count: with upscale_factor=6.0 and max_step_scale=1.6 you get ~4 upscale stages, which is why starting from a small base (e.g. ~140×200) is cheap and fast.
• Single-model for now: all stages use the same Flux model. Cross-model setups (e.g. Z-Image base + Flux refine) are a planned extension — the pixel-space handoffs are already in place to make that a clean upgrade.

Credits

• Locked-noise / progressive-upscale concept: ComfyUI-ZImageTurboProgressiveLockedUpscale by peterkickasspeter-civit.
• Sampler engine: RES4LYF by ClownsharkBatwing.

License

MIT