NIX_ImageTile

NIX_ImageTile is the "process it in slices" node. You hand it one image and it hands back a batch of smaller tiles, arranged in a grid, with optional overlap so you can regenerate each tile independently and stitch them back into a big image. If your GPU can't fit a 4K render in one pass, this is how you cheat the VRAM limit.

It's one node in the NIX pack, which is worth knowing because the pack is tiny and dependency-free (numpy + Pillow, both already in ComfyUI). Install once, get a dozen utilities.

How it works

Feed an image, pick rows and cols, and set overlap_x / overlap_y if you want neighboring tiles to share edge pixels. The node computes tile size as image size / grid count + overlap, centers each tile on its grid cell, clamps to the image bounds, and concatenates everything into one batch along the first dimension.

The outputs are the tile batch (IMAGE), plus tile_width, tile_height, overlap_x, and overlap_y as integers - the geometry you'll need when you stitch the results back together. The batch dimension is the one that matters: rows×cols images come out of the single IMAGE output in row-major order (top-left, then across).

The workflow it enables

This is the tiled-diffusion pattern from the upscaling playbook: generate at native resolution, upscale each tile through a sampler, reassemble. Tiling is how people hit arbitrary output sizes on 6GB cards - instead of one huge latent, you sample N manageable ones.

The honest warning is that NIX_ImageTile is only half the machinery. There's no stitch node in the pack - no matching NIX node to paste the tiles back into one image. You'll need a reassembly node from elsewhere, or a tile-aware upscaler that handles the glue internally (Ultimate SD Upscale, Tiled Diffusion). And the KB's most-repeated tiled-upscaling lesson applies hard here: without a ControlNet Tile condition holding each tile faithful to the source, tiles drift and you get patchwork artifacts where edges disagree. Overlap helps; a condition helps more.

The few inputs that matter

• rows / cols - grid dimensions. 2×2 = four tiles. Both default to 2, min 1, max 256.
• overlap_x / overlap_y - extra pixels added to each tile's size so tiles share context. Zero is fine for simple slicing; nonzero is for when you need edges to blend. Both default to 0.
• image - a single image is what this is built for. A batch in here isn't an error, but every frame gets the same grid applied, so a 2×2 grid on a 4-image batch yields 16 tiles, not 4.

Getting it installed

• ComfyUI Manager: search "NIX" (or the pack title "NIX ComfyUI Plugin"), or use Install Custom Nodes → Git URL with https://github.com/J-ChenX/ComfyUI-NIX. Restart after.
• By hand:

  cd ComfyUI/custom_nodes
  git clone https://github.com/J-ChenX/ComfyUI-NIX
  

  Restart ComfyUI. No model downloads, no extra pip packages beyond what's already there. You'll find it under the "NIX" category.

Things that will bite you

• Tiles all arrive in one batch. Feed the batch straight into a KSampler and it'll process every tile in one go - which is the point, but decoding a huge batch through the VAE can spike VRAM and defeat the purpose of tiling. Batch-split if your card complains.
• Overlap means duplicated pixels. Tiles share edges; unless your stitch averages or feathers the overlap region, you'll see seams where each tile drew the same strip slightly differently.
• No reassembly included. Plan the stitch node before you build the graph, or you'll tile into a dead end.
• Zero community footprint. This pack barely registers in Reddit/forum signal as of mid-2026, so you won't find a prebuilt "NIX tile" workflow to crib. The good news: the source is a single readable Python file, and tiled upscaling guidance is abundant elsewhere.