Split Image into List of Tiles

Tiled upscaling is how people upscale way past what their VRAM should allow: instead of feeding a giant image to a model, you cut it into overlapping tiles, process each tile, and stitch them back. Split Image into List of Tiles is the "cut" half of that story - and its sibling, ImageMergeTileList, is the "stitch" half. Together they let you build tiled pipelines out of core nodes, no extension pack required.

You'll reach for this when an image is too big to run through a sampler or upscaler in one piece, or when you want each region of an image processed independently (tile-by-tile detail pass, tile-level ControlNet, repairing a damaged section in place).

How it works

The tiling is smarter than a dumb crop grid, and the details are worth knowing because they explain the output you'll see.

• Overlap. overlap is how many pixels neighboring tiles share, so the processed result doesn't have hard seams and a model has context across tile borders. Default is 128px.
• The stride rule. The step between tiles is max(25% of the tile size, tile_size − overlap). In plain terms: overlap beyond 75% of the tile is ignored - there's a hard ceiling on how much context tiles share. Don't set overlap to 800 on a 1024 tile expecting triple coverage; the stride just won't go below 25%.
• Edge anchoring. Tiles are generated row-major, but the last row and column are anchored to the bottom and right edges of the image. So edge tiles are typically smaller than the requested tile size - a 1024 tile on a 2500px-wide image gives you a 1024, a 1024, and a 452-ish leftover at the right. That's deliberate: the edges always get fully covered.
• Output is a list of IMAGE tensors, one per tile, in the exact order the merge node expects.

The inputs that matter

• image - the IMAGE to split.
• tile_width (default 1024, 64–16384) and tile_height (default 1024, 64–16384) - the target tile size.
• overlap (default 128, 0–4096) - shared pixels between neighbors; 0 gives a clean grid of non-overlapping tiles.
• Output: IMAGE list of tiles.

Building the full loop

The canonical pattern: split → run each tile through whatever per-tile processing you want (an upscaler, a low-denoise img2img pass) → ImageMergeTileList to reassemble. If your per-tile pass changes resolution - say, upscaling each 1024 tile by 2× - then set final_width/final_height on the merge node to the upscaled target, because the merge reconstructs at those dimensions.

Gotchas

• Tiles aren't all the same size. The bottom/right edge tiles are smaller. Any node you run per-tile must tolerate variable sizes, or you'll need to handle the stragglers.
• Order matters. The merge node assumes this node's exact tile ordering. If you shuffle or drop tiles, the reconstruction will be scrambled.
• Overlap has a ceiling. As noted, stride bottoms out at 25% of the tile size - overlap beyond that does nothing.
• Your VRAM per tile, not per image. This is the whole point: the sampler only ever holds one tile's worth of latents, which is how people run giant upscales on 8GB cards. But it does mean N tiles = N samplings; tiling is the VRAM lever, not a speed trick.

This and its merge sibling are the only core nodes that do real tiled splitting, and they're a recent addition - update ComfyUI if you don't see them. No models, no install. Cut your image into manageable pieces, process them, and stitch them back without ever holding the whole thing at once.