Seamless

Worth clearing up right away, because the name invites the opposite guess: this node doesn't fix unwanted tiling repetition - the stretched, patchy artifacts you get from generating above a model's native resolution (that's a completely different problem, and the fix for it is hi-res fix or a tiled diffusion upscale, not this). JN_Seamless does the reverse, on purpose: it makes your model generate output that tiles cleanly, edge to edge, for things like game textures, wallpaper patterns, or fabric prints.

It's from JNComfy (jn-jairo/jn_comfyui), a one-person pack that also covers audio, face restoration, and a big family of small logic primitives. There's no meaningful community discussion of the pack anywhere, so what's here and in the README is the whole reference - this is old, well-established technique (Automatic1111 has shipped the equivalent "seamless tiling" checkbox for years), just implemented as a JNComfy patch node rather than a UI setting.

How it works

The mechanism is the same one every "seamless tiling" feature in this space uses: patch the model's Conv2d layers to wrap around at the edges (circular padding) instead of padding with zeros. A network trained with zero-padding treats the edge of the canvas as an edge; with circular padding instead, it treats the edge as continuing into itself - which is exactly what makes the output tile without a visible seam.

direction controls which axes wrap: both gives you a full 2D repeating tile, horizontal or vertical wraps only one axis (useful for a banner or border pattern rather than a full tile), and none disables the patch entirely. min_channels/max_channels limit which conv layers actually get patched, based on how many channels they operate on - an escape hatch for cases where patching every layer introduces visible artifacts in a specific part of the network; leave these at their full defaults (0 to 100000) unless you're chasing a specific glitch and want to narrow the effect down.

The vae input matters more than it might look: patching only the model gets you a seamless latent, but if the VAE decode step isn't also patched, the final pixel-space image can still show a seam. Wire vae in if you actually need the rendered image to tile, not just the latent.

flow and dependency are execution-order plumbing, the same pattern used by JN_Dump elsewhere in the pack - connect something through them if you need this patch to apply at a specific point in a sequence rather than trusting ComfyUI's default ordering.

The inputs and outputs that matter

• direction (required, none / both / horizontal / vertical) - which axes get the seamless treatment.
• min_channels / max_channels (required, INT, defaults 0 and 100000) - restrict which conv layers get patched.
• model / vae (optional) - what actually gets patched; patch both if you need the final image, not just the latent, to tile.
• flow / dependency (optional) - execution-order plumbing.
• Outputs: MODEL, VAE, flow.

Installing it

ComfyUI Manager: search "JNComfy". Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/jn-jairo/jn_comfyui

Restart ComfyUI. No models to download for this node - it patches whatever checkpoint you already have loaded.

Common issues & troubleshooting

You wanted this to fix "repeating patterns" in a normal generation. That's the artifact this node deliberately creates, not one it removes - see the note above. If your image is showing unwanted repetition at high resolution, this is the wrong node entirely.

The image tiles, but there's still a faint seam. Almost always means you patched model but not vae - the latent is seamless, the decode step isn't. Wire vae through the node too.

Verify before trusting it in a bigger job. Generate one tile and check it by actually tiling it - paste four copies in a 2×2 grid (the pack's own JN_ImageGrid, named in the README, does this) rather than eyeballing a single image and assuming it'll tile cleanly.