Visualize Tiles (VAE Utils)

This is a planning tool, not a processing node. It takes four numbers describing a tiling scheme and draws you a picture of how a sequence gets carved into overlapping tiles - so you can see the windowing before you commit an expensive generation to it. No latent, no model, no image goes in. Just the numbers, and out comes a diagram. It's the companion to the pack's Tile Model Patch node, and it exists because tiling math is easy to get quietly wrong.

Why you'd reach for it

If you've ever tried to run Wan past its 81-frame native window, you know the tax: you split your target length into tiles, set an overlap so the chunks agree at their boundaries, and account for the frames that get dropped at the start. Get the arithmetic wrong and the video comes back too short, or the end behaves strangely, or you see seams where windows meet. People burn real time - and real GPU minutes - discovering a bad tiling scheme after the render.

Visualize Tiles lets you get that wrong for free, on screen, in a fraction of a second, before anything expensive happens. You dial in the same length, tile size, overlap, and drop-first values you'd hand to Tile Model Patch, look at the diagram, and confirm the windows land where you expect. It's the "measure twice, cut once" node. Unglamorous and genuinely useful, which is a fair description of the whole pack.

How it works

It's a pure visualization. Given a total length, it lays out tiles of tile_size, steps them along with at least min_overlap between neighbors, drops the first drop_first off the front, and renders the resulting layout as an image - which tile covers which positions, where they overlap, what gets dropped. There's no diffusion and no decode happening; it's drawing a schedule, not producing content. That's why it's instant and why it needs nothing but four integers.

The values map directly onto the temporal half of Tile Model Patch (tile_t, min_overlap_t, drop_first_t), which is the point - you tune the scheme here, then transfer the numbers over there with confidence.

The inputs that matter

All four are plain integers with sensible defaults:

• length (default 21) - the total sequence length you're tiling, e.g. your latent frame count.
• tile_size (default 13) - how big each window is.
• min_overlap (default 5) - the minimum overlap between adjacent tiles. Bigger overlap means smoother joins and more redundant compute.
• drop_first (default 2) - how many positions to drop off the front, which mirrors the special handling Wan's causal VAE gives the first frames.

The output is an IMAGE, so you wire it to a Preview Image node and just look at it. That's the entire interaction.

Installing it

The pack has zero dependencies. In ComfyUI Manager, search ComfyUI-VAE-Utils. Or clone it directly:

cd ComfyUI/custom_nodes
git clone https://github.com/spacepxl/ComfyUI-VAE-Utils

Restart ComfyUI. Nothing to download for this node - it draws a diagram from numbers.

Common issues

There's not much to break here, which is the nice part. The one thing worth saying: this node doesn't do the tiling, it only illustrates it. So a lovely-looking diagram is not proof your generation will be seamless - it's proof your scheme is what you think it is. The actual coherence still depends on Tile Model Patch and on whether your overlap is large enough for the content, and long-form Wan's real enemy, identity drift across window boundaries, is a model-side problem this preview can't see. Use it to catch the arithmetic mistakes - wrong length, too-small overlap, a tile size that leaves an awkward stub at the end - before they cost you a render. That's exactly the class of mistake it's good at surfacing, and exactly the class that's most annoying to discover any other way.