KSampler (Multi-Seed+)

KSampler (Multi-Seed+) is the flagship of Pirog's Nodes, and it's a lot. Where the plain Multi-Seed sampler just walks seeds, this one is a full pipeline in one box: it creates or encodes a latent, samples multiple seeds, decodes back to an image, and - the headline feature - can split your image into overlapping tiles, sample each tile as its own inpainting pass, and stitch them back together. That's the tiled-diffusion trick for generating high resolutions on limited VRAM without the patchwork seams people usually get.

How it works

The flow depends on denoise:

• denoise = 1.0 - it builds an empty latent from width and height, samples, decodes. Pure txt2img.
• denoise < 1.0 - it VAE-encodes your input_image and treats the whole thing as img2img.

Then the sampler runs seed_count passes with incrementing seeds, like its little sibling. The tiling layer kicks in when you raise vertical_splits or horizontal_splits above 1. Each tile gets an overlap expansion border plus a gradient mask - the tile's center is weighted fully, edges fade toward the next tile - and the tiles are reassembled with weighted accumulation. That gradient-weighting is the difference between "seamless" and "visible grid lines"; it's the part this node actually does well.

There's also noise_type (vanilla / spectral-diverse / hierarchical) for how the initial noise is generated, plus the same Detail Daemon (dd_* inputs) and injected_noise as the base Multi-Seed node.

The inputs that matter

• model, vae, positive, negative - the standard sampler stack, plus a VAE since this node encodes and decodes for you.
• seed / seed_count - how many variations per run.
• width / height - txt2img size when denoise=1.0.
• vertical_splits / horizontal_splits - the tiling switch. 1/1 = no tiling.
• overlap (default 64) - pixels of shared border between tiles. Keep it a multiple of 8.
• tile_supersampling and supersampling_min/max_resolution - tiles get scaled up before processing and back down after, which is how a 1536×1536 tile gets a full 2048px generation budget. This is where the quality lives, and also where the compute time goes.
• input_image - optional, only used for img2img.

Output: IMAGE - decoded images, one per seed, ready to wire straight to a save node.

Where it fits

This is the pack's answer to high-res generation on mid-range cards: instead of OOMing on a 2K latent, you process four 1K tiles. It shares DNA with the tiled-diffusion upscaling approach from the A1111/multidiffusion world, but self-contained. People also use it for outpainting - set a low denoise, feed the existing image, tile outward.

Installing it

Same pack, same install:

cd ComfyUI/custom_nodes
git clone https://github.com/Pirog17000/Pirogs-Nodes
pip install -r Pirogs-Nodes/requirements.txt

Or ComfyUI Manager → search "Pirog's Nodes" → restart. No model downloads.

Gotchas

Tiling is slow - you're sampling each tile as a separate inpainting pass, and supersampling multiplies that. The trade is real: the upscaling KB notes tiled diffusion can use a third of the VRAM of a straight pass but takes far longer. Keep overlap modest (64–128) because every overlap pixel is redundant work. If tiles look disconnected or color-shifted, your denoise is probably too high - this wants to refine, not regenerate. And start with noise_type on vanilla; the fancier noise modes are genuinely experimental.