Advanced Tiling

If you've ever "generated a seamless texture" and then watched the seam tear the moment you tiled it in Blender or a game engine, this node is the fix. Advanced Tiling is the heart of the ComfyUI-AdvancedTiling pack: it rewrites how your model samples the edges of the image so the left edge genuinely continues into the right edge - and in its party trick mode, the whole image is laid out on a hexagon grid so it tiles like a honeycomb.

It's a model patch node, not a sampler. You feed a MODEL in, get a patched clone out, and hand that to your KSampler instead of the unpatched model. Because it clones (model.clone()) before patching, nothing about your original model changes; the patch lives on the copy you route through.

How it works

The pack splits the work by architecture, and it picks the path for you.

For UNet-based models (SD 1.5, SD 2.1, SDXL) it patches every Conv2d layer in the model. The patched convolution pads the tensor, then remaps the padding pixels to wrapped source content before the convolution runs. Rectangular mode wraps right↔left and bottom↔top (toroidal, so a perfect tile is already in the latent). Hexagon mode remaps every pixel outside the central hexagon back into it using hexagonal-grid math - the same cube/axial coordinates from the Red Blob Games guide the author credits - with the rotation angle skewing the hex basis vectors.

For DiT-based models (FLUX.2, Qwen Image) there are no Conv2d layers to patch, so it uses toroidal attention instead: it injects wrapped-neighbor key/value entries into every attention layer plus synthetic RoPE position embeddings, so boundary patches literally see content from the opposite edge as spatially adjacent. Hexagon mode additionally copies wrapped content into the latent on every denoising step, which is what keeps your KSampler preview from looking like static. The node detects which route to take by checking whether the diffusion model contains Conv2d layers - you don't choose.

Inputs and outputs

Only two inputs, both required:

• settings - an ADVANCED_TILING_SETTINGS object from the Advanced Tiling Settings node. This is where you pick Hexagon vs Rectangular vs None.
• model - the MODEL you'd otherwise feed straight to your sampler.

Output is a single MODEL, which wires into the model input of KSampler (or whatever sampling node you use).

How to install

This pack has no extra Python dependencies - no requirements.txt, just torch/numpy code - so install is painless. In ComfyUI Manager, search "Advanced Tiling" (pack title ComfyUI-AdvancedTiling) and hit install, or from the terminal:

cd ComfyUI/custom_nodes
git clone https://github.com/JosefKuchar/ComfyUI-AdvancedTiling

Restart ComfyUI and the three nodes appear. One optional extra: if you happen to run raylight for distributed inference, the pack also registers an "Advanced Tiling (Raylight)" node - it only shows up when raylight is installed, and you can safely ignore it.

Common issues

• "Model does not have pe_embedder" - this is the DiT path refusing a model it can't tile. Toroidal attention needs a model with RoPE position embeddings; FLUX.2 and Qwen Image work, a random third-party DiT may not.
• Seam artifacts. The README is honest about this: the author notes artifacts exist and isn't sure if it's the implementation or just Stable Diffusion not being built for this. Realistic expectations, then - hexagon especially is more "texture foundation" than "finished asset."
• Output looks wrong but the patch shouldn't matter - set mode to "None" in the Settings node. That's the pass-through; if output still misbehaves, the problem is elsewhere in your workflow.
• Slow decode. The README flags the first VAE decode pass as very slow. That's the other node in this pack, but it's worth knowing going in.

Put the node between your model loader and the sampler, keep the settings node consistent with the decode node on the other side, and you're tiling.