Tile Image

Tile Image (class ImageTiler) is the "break it into pieces" half of this pack's tiling pair, and the name is doing the whole job. You hand it one big image, tell it how many rows and columns to slice into, and it hands back a batch of overlapping tiles small enough for your sampler to chew on. Its twin, ImageUntiler, reassembles them later.

When do you reach for it? When a canvas you want to render or upscale is bigger than your card can handle in one pass - think 2048×2048 and up on an 8 GB GPU. This is the tiled-diffusion pattern, the same idea that made Ultimate SD Upscale and Tiled Diffusion staples of the upscaling scene, stripped down to raw building blocks: split, run your img2img or upscale pass per tile, stitch back. It's not magic, but it turns "arbitrary output size on limited VRAM" from a dream into a routine workflow.

How it works. It's pure tensor math - no models, no VAE decode gymnastics, just torch slicing and padding, so it costs you almost nothing in VRAM itself. Internally the node pads your image to a size that's an exact multiple of rows × cols so every tile comes out identical, works out the base tile size, then adds your overlap around the edges. The detail that keeps edge tiles clean: it pads borders in replicate mode rather than zeros, so the outer tiles don't get ugly black bars.

That overlap is the parameter that actually matters. Tiles meet at boundaries, and if you process each one independently the seams will show. A bit of overlap means neighbours share real pixels, and ImageUntiler's blending can smooth the boundary instead of leaving a hard line. The node rounds overlap down to an even number (it's forced even for symmetric padding) and caps it so it can never exceed the tile itself.

The inputs and outputs that matter. You only set four things:

• image - the big image, any size.
• rows and cols (defaults 2, 2) - the grid. More tiles means smaller tiles, lighter per-pass VRAM, but more seams to manage.
• overlap (default 64) - shared pixels between neighbours. Start at 64; raise it if seams are visible.

Outputs are tiles - a batch of rows × cols images, one per tile - plus original_width and original_height. Wire those two into ImageUntiler so it can crop back to your exact original dimensions instead of the padded grid size.

Install. This is a small, quiet pack (created July 2025, essentially zero community footprint). Good news: it has no dependencies and downloads no models - it's torch ops only, using what ComfyUI already ships. Manager may not surface it in search because it isn't on the official Comfy Registry as of writing, so the clone is the reliable route:

cd ComfyUI/custom_nodes
git clone https://github.com/einhorn13/ComfyUI-ImageProcessUtilities

Then restart ComfyUI. That's the entire install.

Common issues. The one that bites: ImageUntiler demands a tile count divisible by rows × cols, so if you tile with 2×2 but forget and set the Untiler to 3×3, you get a ValueError. Keep both ends in agreement. And if you run each tile at a different seed, you'll see seams and style drift - that's normal for any tiled workflow. More overlap, or a lower denoise strength on the tile pass, is the usual fix.