Combine Tiles 988

Tiled upscaling has a dirty little secret: cutting an image into tiles is easy, processing each tile is easy, and then you try to glue them back together and the whole thing looks like a tiled bathroom floor. Seams where the tiles meet, mismatched brightness, a faint grid over your "clean" upscale. Combine Tiles 988 is the node that exists to make that last step invisible.

It's the final stage in this pack's "DaC" (Divide and Conquer) upscale pipeline, which works exactly like the classic tiled-upscaling lineage the community has converged on - split the image, process tiles independently on limited VRAM, then blend. The pipeline is DaC Algorithm 988 (plans the grid) → Divide Image Select 988 (cuts the tiles) → your img2img/upscale/ControlNet pass on each tile → Combine Tiles 988 (stitches). If you've used Ultimate SD Upscale or a tile-ControlNet workflow, you already know the shape of this; the 988 pack just gives you each stage as its own visible, inspectable node.

How it works

The node reads the whole tiling geometry from the dac_data structure that DaC Algorithm produced - upscaled dimensions, per-axis overlap, grid size, and tile order. It places every tile back at its calculated coordinate, and where two tiles overlap it builds a Gaussian-blurred mask so the transition is a soft crossfade instead of a hard edge. That blur is the entire point: without it you get a visible line every tile_width - overlap pixels.

The inputs that matter

Only two, and one of them is the one people get wrong:

• images - the processed tiles, as a list. The node assumes they arrive in the same order they left Divide Image Select, which means the order recorded in dac_data (linear or spiral). Stitch them in a different order and your output is scrambled in a way that's hard to spot until it's too late.
• dac_data - the geometry dict straight from DaC Algorithm 988 (or a scaled copy from DAC Data Scale 988). Wire it through unchanged; this is why the whole pipeline is a chain rather than a free-for-all.

Outputs: image, the combined full-resolution result (send it to Preview Image or Save Image), and matrix, a text rendering of the tile grid meant to be piped into Display UI 988 so you can eyeball whether the grid came out the shape you expected before you commit to the expensive processing pass.

Why you'd reach for it

The KB's upscaling essay makes the case better than I can: on a 6GB card you are not upscaling a 4K image in one diffusion pass, but you absolutely can if you work in 1024px tiles. DaC exists to make the "arbitrary output size on limited VRAM" playbook first-class in ComfyUI, and this node is the payoff - it's the part that decides whether the final image reads as one coherent picture or a patchwork.

Troubleshooting

• Visible seams or grid lines: your overlap is too small for the blend to hide, or the dac_data you're feeding doesn't match the tiles (e.g. you ran a model that changed tile dimensions - that's what Combine Tiles v2's auto-resize is for).
• Scrambled/misplaced content: tile order mismatch. Check the matrix output and confirm your processing pass didn't reorder the list.
• matrix looks empty: it's a string, not an image - you have to feed it to a display node like Display UI 988 to see it.

Install

It's part of the ComfyUI-988 pack. Easiest via 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 ComfyUI. The pack's requirements are light (lmstudio, requests, Pillow, numpy) - no model downloads, no hidden weights. You'll find all three DaC nodes under the 🦇988/Image category.