Combine Tiles 988 v2

The first Combine Tiles node assumes your processed tiles are exactly the size the tiling algorithm planned. That assumption is a lie half the time. Run each tile through a diffusion upscaler, an ESRGAN model, or a VAE pass, and your 1024px tiles come back as 2048px tiles - and the stitch step now has geometry it can't honor. Combine Tiles 988 v2 is the version that was built to cope with that.

It does everything the original does - places tiles at their dac_data coordinates and blends overlaps with Gaussian-blurred masks - and then adds two genuinely useful behaviors: it detects when your tiles don't match the planned tile dimensions and resizes them back, and it lets you cap the blend overlap so huge overlaps don't turn into soft mush.

How the auto-resize works

When a tile comes in at the wrong size, v2 first tries NVIDIA RTX VSR (nvvfx) to resize it down to the exact planned dimensions - which sounds like overkill until you remember this node lives in an upscaling pipeline where the tiles just came from a model. If nvvfx isn't installed, it falls back to a plain lanczos resize. Either way the info output tells you which path it took ("nvidia_rtx_vsr", "lanczos (fallback - nvvfx not available)"), so you're never guessing whether the fancy path actually ran. Don't install the RTX SDK just for this; the fallback is fine, and the KB's upscaling essay is pretty clear that the hardware VSR path is a "more pixels" tool, not a "more detail" tool anyway.

The blend mode that matters

The second input to understand is blend_mode, a three-way choice about how much overlap to actually blend:

• auto (actual + cap) (default) - uses the real overlap, but caps it at roughly 10% of tile size (min 128px). The sane default.
• actual overlap only - blends the full real overlap. Pick this when your upscale needs the widest seam coverage.
• cap 128px - hard-cap blending at 128px. Good when tiles have big overlaps and you want to avoid double-processing regions being over-smoothed.

Where people get burned: leaving tiles at wildly different sizes (e.g. some model pass output 1536, another 1792) and watching the combine produce a blurry collage. The auto-resize handles one uniform mismatch; wildly heterogeneous tile sizes are a workflow bug, not a node bug.

Inputs and outputs

• images - your processed tiles, in the order Divide Image Select gave you.
• dac_data - the geometry from DaC Algorithm 988 (or its v2 / a scaled copy).
• blend_mode - as above.

Outputs: image (the combined full-res result), matrix (text grid for Display UI 988), and info (the resize/blend diagnostics - read it at least once to confirm the pipeline is doing what you think).

When to reach for it

If your tile-processing pass preserves tile size exactly, the original Combine Tiles is simpler. The moment you put any model between Divide Image Select and Combine - and the whole point of the DaC pipeline is that you do - v2's auto-resize and diagnostics save you a session of staring at a broken seam wondering what happened.

Install

Part of the ComfyUI-988 pack: ComfyUI Manager (search "ComfyUI-988"), or:

cd ComfyUI/custom_nodes
git clone https://github.com/kajan988/ComfyUI-988
cd ComfyUI-988
pip install -r requirements.txt

Then restart. Note the v2's NVIDIA path needs nvvfx (the RTX VSR SDK) which is not in the pack's requirements - without it you get the lanczos fallback, which is the expected experience on non-RTX or minimal setups. Restart matters here: the frontend registers the node class on load.