Tile Grid Advisor

You're building a tiled upscale workflow and the question hits you: what should tile_size be? You know your image is 1920×1088, you know your card can probably handle ~2000px tiles, but you actually think in terms of how many tiles you want - four, six, a fifteen-tile grid. Tile Grid Advisor is a tiny helper that inverts that question. Give it the image, a desired grid like 2×2, and your overlap, and it tells you the exact tile_size that produces it. That's the whole job, and it does it honestly.

It ships in the same pack as Tiled Upscale & Refine, the all-in-one tiled upscaler for FLUX.2 klein and other reference-latent edit models - and this node is the answer to its single most annoying input. You can also feed its output into the pack's manual Tile Split node if you're building a custom pipeline.

How it works

It's pure arithmetic, no model involved - which is the point, it's instant and costs nothing. For each axis it works out the tile size you'd need to fit count tiles across with the given overlap between neighbours:

needed(size, count) = ceil((size + overlap * (count - 1)) / count)

It takes the larger of the two axes, rounds to a multiple of 16 (so tiles map cleanly onto the model's latent grid), and that's the suggestion. Then - and this is the part I appreciate - it runs the real tile planner on that size and reports the grid you'd actually get, not the one you asked for.

That matters because the honest answer is sometimes "that grid isn't reachable." If your aspect ratio and overlap don't divide evenly, you can't hit exactly 3×2 with a single shared tile size - the longer axis sets the size, so you get the closest fit and the node tells you so in its output. No silent surprises.

The inputs and outputs

Only three inputs, all obvious:

• image - the source you're planning tiles for; it's where the dimensions come from.
• tiles_x / tiles_y - the grid you want, e.g. 2 and 2 for a 2×2.
• overlap - the overlap you'll use in the actual tiled pass, in pixels.

Two outputs:

• suggested_tile_size - an INT, wire this straight into TiledUpscaleRefine's tile_size input (or Tile Split's).
• info - a STRING explaining the actual grid you'll get, plus the caveat when your requested count isn't exactly reachable.

Installing it

Same one-liner as the rest of the pack - ComfyUI Manager, search ComfyUI-TiledUpscale, install, restart. Or manually:

cd ComfyUI/custom_nodes
git clone https://github.com/GianlucaMancuso/ComfyUI-TiledUpscale

No model downloads, no extra dependencies beyond the pack's color-matcher requirement (which Manager handles, or pip install -r requirements.txt if you cloned by hand). This particular node doesn't even use that dependency - it's a pure math utility.

Where it bites

Two caveats, both worth knowing before you trust the suggestion blindly.

First, it doesn't know about your VRAM. It will cheerfully suggest a 3000px tile for a grid you asked for - which is correct math and possibly a hard OOM on an 8GB card. The suggestion is a floor for your grid, not a ceiling for your GPU. If it suggests something your card can't handle, increase the tile count rather than fighting the number.

Second, its output can exceed the input caps downstream. TiledUpscaleRefine's tile_size accepts up to 4096, and TileSplit up to 8192 - a large grid on a big image can produce a suggestion above the refine node's cap, in which case you either clamp it by hand or split it into a coarser grid. The info output tells you the actual resulting grid, so read it once before wiring up a 40-tile run.

Bottom line: it's a calculator, and a good one. If you're hand-tuning tile_size by trial and error, this saves you the fiddling and tells you when your plan is impossible. Ten seconds to install, no downside.