Tile Split

Tiled processing is one of those techniques you don't think about until your GPU laughs at you. You want to work on a 4K image, your 8GB card starts thrashing, and the fix is old and boring: split the image into overlapping tiles, process each tile on its own, stitch them back. Tile Split is the front half of that pipeline, and it's built to be fed into samplers and decoders that work one tile at a time.

What it does

Tile Split takes an image and chops it into a grid of overlapping tiles, outputting two things: a list of tile images and a tile pipe - a small bundle carrying each tile's position, the original size, and the grid layout. That pipe is the secret sauce: you don't have to remember the coordinates yourself, because the matching Tile Assembly node (or the all-in-one Tile Decode & Assembly in the same pack) reads them straight off the pipe and puts everything back in the right place.

The three controls that matter:

• width_factor / height_factor - the number of tile columns and rows. Defaults are 2 columns × 3 rows. More tiles means smaller tiles means less VRAM per pass, but more seams to blend and slower overall.
• overlap_rate - how much adjacent tiles overlap, default 0.15 (15%). Overlap is what lets the seams blend together instead of showing hard lines. Zero overlap is fastest and almost always looks bad.

The VAE alignment thing, explained

Here's the part that trips people up: tiles aren't arbitrary rectangles. When you later VAE-encode or decode a tile, its dimensions have to be a multiple of the model's latent compression ratio - 8 for SD/SDXL/Flux1, 16 for Flux2. Feed it a 7-aligned tile and you get dimension errors or silent garbage.

Tile Split handles this by detecting your VAE's spatial compression ratio and auto-aligning every tile to the right multiple. That's what the optional vae input is for - wire your VAE in and the alignment just happens. If you don't connect a VAE (say, you're running Flux2), set align_override to 16 manually. The tooltip literally tells you: use 16 for Flux2 when no VAE is connected.

Where it slots in

The canonical workflow is tiled diffusion upscaling: split → run each tile through a sampler (optionally with a tile-ControlNet so tiles stay faithful to the source) → assemble. It's also how you do VRAM-limited VAE decoding of huge latents - decode in tiles rather than all at once. On a 24GB card you often don't need this; on anything smaller, tiling is the difference between running and watching an OOM error.

Install it

Ships in ComfyUI_Eclipse. ComfyUI Manager → search "Eclipse" → Install, then restart:

cd ComfyUI/custom_nodes
git clone https://github.com/r-vage/ComfyUI_Eclipse

Pack deps (opencv-python, pilgram, PyYAML, aiohttp plus the standard stack) are handled for most setups; portable installs may need pip install -r custom_nodes/ComfyUI_Eclipse/requirements.txt. Find it under Eclipse → Image → Transforms.

Gotchas

First, only the first image in the batch gets used for splitting - the node flattens its input and splits on the first frame, so don't feed it a batch expecting per-frame tiles. Second, remember overlap exists for a reason: crank overlap_rate to 0 and the seams will show up as hard line artifacts after assembly. And if you're splitting to escape VRAM hell, resist the urge to make dozens of tiny tiles - each tile pays a fixed overhead, and you'll end up slower than if you'd just processed the whole thing with a slightly lower batch size. Tiling is a scalpel, not a hammer.