Y7 Flux.2 Klein Upscaler (Tiled)

Flux.2 Klein is a joy to generate with precisely because it's small - 4 steps, a couple of seconds, edits baked in. Then you ask for a genuinely big image and it OOMs, or quietly stops holding the picture together. The Y7 Flux.2 Klein Upscaler (Tiled) is the workaround: it enlarges your image with a plain upscaler, then walks over the result one tile at a time and has Klein repaint each tile as a tiny inpaint. Output size stops mattering - what fits in VRAM is the tile, not the picture.

This is the "adds detail" job: a pixel upscaler (optional, ESRGAN-style) enlarges, and Klein supplies the new detail. Same lineage as Ultimate SD Upscale, except the sampler, guider and sigma schedule are built in - feed it a model, a VAE, conditioning and an image, and nothing else. It's a tightened port of Gavr728's community ComfyUI_KleinTiledUpscaler, the "basically USDU for Klein" node that made the rounds in spring 2026.

How it works

Each tile is cropped with an overlap band around it. Klein repaints the middle; the surrounding band is frozen context it can see but not change (via the denoise mask), which is how a tile agrees with its neighbours instead of inventing its own version of the scene. Three details are where this class of node usually falls apart:

• The reference latent is swapped per tile. At CFG 1.0 Klein is an edit model - its "what am I looking at" signal lives in a reference latent in the conditioning, not the prompt - so this node crops that reference to match each tile. Skip that in a hand-built workflow and you get the classic tile-grid effect.
• Seams are correct by construction. Tiles blend via complementary raised-cosine ramps that sum to exactly 1.0 at every pixel - no mask_blur widget, because there's nothing to tune. The whole canvas is never VAE-encoded, only tiles, which is what keeps VRAM flat as the output grows.
• Each tile gets its own sigma schedule and seed. Flux.2's schedule shift depends on how many tokens you're sampling, and a tile is not the canvas - so a schedule typed for the whole picture is wrong for every tile. Per-tile seeds stop ancestral/SDE samplers stamping the same texture everywhere.

Wiring it up

The example workflow keeps it simple: a Klein checkpoint via UNETLoader, CLIPTextEncode through the matching Qwen3 text encoder for positive, and a ConditioningZeroOut for negative - at CFG 1 it does nothing anyway.

The dials you'll actually touch:

• tile_size (default 1024) - the VRAM knob. Down when you OOM, up when tiles invent too much.
• overlap (128) - how far each tile sees past its edge. Raise it if a roofline or horizon breaks at a seam.
• steps (4) - right for the distilled checkpoints. cfg stays at 1.0; push it above and every tile costs twice as much.
• scale_factor (2.0) - set it to 1.0 and nothing enlarges: the node becomes a sharpen/refine pass. Unplug upscale_model then and lean on refine_strength (0.85–0.92).
• upscale_model (optional) - pick a clean model, not a sharp one. Halos get frozen into the context and copied as real detail, so anything with "Sharp" in the name is a trap.

Outputs: image, a matching latent (same geometry, so you can sample onward without a re-encode), and a report string listing the grid, tile sizes and blend widths it actually used - pipe that into a text viewer when results look wrong.

Install and gotchas

Install is the whole pack: ComfyUI Manager → search "Y7Nodes", or clone into custom_nodes and pip install -r requirements.txt, then restart. That requirements.txt matters - the default color_match: mkl needs the color-matcher package; without it you get an import error the moment a tile finishes. It's there because Klein shifts colours warm on edits (a known quirk), and tiles drift apart in tone otherwise.

If tiles still show as a grid, that's drift, not blending - raise overlap and check color_match is on. If the result is too crisp, unplug the upscaler and compare against plain bicubic before touching anything else; the sharpening is usually coming from there. And don't fight "too much detail" with denoise - Flux.2's schedule hugs the high-noise end, so at 4 steps you get about five reachable settings, most of which do nothing until they suddenly do everything. That's refine_strength's job.

One honest caveat: this is a personal quality-of-life pack, and the README doesn't even document this node - the real write-up lives in the pack's docs/nodes/Y7Nodes_Flux2KleinUpscaler.md. It's also slow at the truly huge end: a 4x pass is many minutes even on a 3090. But for taking a Klein image to 2x cleanly on a modest card, it's the least wiring I've found between you and a finished wall-size print.