Seamless Latent Tiling ✦

If you've ever needed a tileable texture, you know the drill: generate, pray the edges line up, then spend an hour offsetting, masking, and inpainting the seams. This node skips all of that. It makes the generation itself seamless, so the left edge of your output matches the right edge by construction. Tile it 3×3 and it just works.

The trick isn't magic - it's circular padding. At every denoising step, the node pads your latent with copies of itself (right edge wrapping to the left, bottom to top), runs the UNet on that bigger wrapped tensor, then crops the prediction back to the original size. Because every convolution now sees continuous context across the seam boundary, the model literally predicts as if the image wraps. It's the same idea as A1111's tiling checkbox, done properly inside ComfyUI instead of via a monkey-patch on torch's padding mode.

Where it goes in the graph

It's a model wrapper, not a sampler. You slide it between your model loader and your KSampler:

Model Loader → [Seamless Latent Tiling ✦] → KSampler → VAE Decode → Save

The model input takes your loaded checkpoint and the model output feeds the sampler. Everything else in your workflow stays untouched - no model modifications, works with SD 1.5, SDXL, turbo/lightning, LoRAs, whatever.

The inputs that matter

There are exactly three, and you'll mostly touch one.

• padding - the overlap region in image-space pixels (the node divides by 8 for latent space). Default 64. The README's guidance holds up: 64 is fast and fine for simple patterns, 128 is the recommended starting point, 256 gives maximum context for busy scenes at a real speed cost.
• tile_x - enable left↔right tiling.
• tile_y - enable top↔bottom tiling. Turn one off if you only need a horizontal border strip - it saves memory and keeps the other axis looking natural.

One honest warning about the memory cost: with 128px padding on a 512×512 image the latent goes from 64×64 to 96×96, roughly 2.25× the area, and the UNet processes that at every step. On a cramped card, drop to 64 padding or disable an axis before you start dropping your resolution.

Install

ComfyUI Manager is the easy route - search "ComfyUI-seamless_latent_tiling". Otherwise:

cd ComfyUI/custom_nodes
git clone https://github.com/mikemojen/ComfyUI-seamless_latent_tiling

Restart ComfyUI and it appears under sampling/seamless. Note the pleasant surprise: this pack ships no requirements.txt and downloads no models - it's pure PyTorch, so no dependency conflicts to untangle. That's rarer than it should be in the custom-node world.

Getting good results

Prompt for what you want: "seamless pattern", "tileable texture", "repeating design" all help the model think in tiles. Square images (512×512 or 768×768) tile most reliably. If you still see faint seams after generation, bump the padding before you reach for anything else.

The real gotchas, straight from the author's own docs:

• ControlNet will break seamlessness. ControlNet injects spatial features at intermediate UNet layers that this node doesn't pad, so control guidance near the edges fights the wrap. Run without ControlNet, or expect to clean up edges afterward.
• Inpainting models do work - the concat conditioning (c_concat) is padded when its spatial dims match the latent - but it's the less-tested path, so verify on your model.

The name deserves its diamond: if seamless output is your goal, this is the node that actually solves it rather than patching the result afterward. The other three nodes in the pack exist to clean up the mess when you can't regenerate - this one prevents it.