Tiled Diffusion (Forge Port)

Let's be honest about what this is: a one-node pack that exists because one specific model, Anima, refuses to generate anything above 1536x1536 without collapsing into tiled garbage. The author got tired of that, ported the sd_forge_multidiffusion model wrapper from A1111 Forge into ComfyUI, and called it Tiled Diffusion (Forge Port). It's niche, it's barely two months old at the time of writing, and there's essentially zero community chatter about it. But if you've got a model that hard-caps its resolution, or a low-VRAM card that can't do 2K+ in one shot, it's a genuinely clever tool that most tiled-upscaling guides never mention.

The trick: tile the compute, not the image

Most tiled approaches you already know split the job at the workflow level. Ultimate SD Upscale crops the image, runs whole diffusion passes on each crop, and stitches. This node does something sneakier. It wraps your MODEL - literally patches the cloned model's UNet function - so that every single denoise step inside a completely normal KSampler runs tile by tile.

You wire your checkpoint into model, out comes a patched MODEL, and that goes into any regular sampler you like. The sampler still runs one continuous denoise over the full image; only the heavy per-step math happens on overlapping tiles. The result is a full-res generation or upscale with no tile seams to stitch and no second-pass crop boundaries to hide. It's the same lineage as pkuliyi's multidiffusion extension that the upscaling KB calls one of the most reliable ways to push 2K+ on 6GB VRAM - just implemented the way Forge does it, as a model wrapper.

The two method choices are the two classic blend modes. MultiDiffusion averages the overlapping regions uniformly. Mixture of Diffusers (the default) weights each tile with a gaussian falloff, so the blend is softer and seams are less likely to ghost. For upscaling, gaussian is almost always the better pick - which is why the author recommends it.

The inputs that actually matter

Five inputs, all required, and you'll only ever touch a few:

• method - Mixture of Diffusers or MultiDiffusion. Leave it on Mixture unless you're chasing seams.
• tile_width / tile_height - tile size in pixels (internally divided by 8 into latent space). The author's recipe: set both to your base image dimensions, not to small squares.
• tile_overlap - how much adjacent tiles overlap. Too little and you see boundaries; too much and you're doing redundant work. 128 is the recommendation.
• tile_batch_size - tiles processed per step. Default 1 is technically fine but slow; 4 is the sweet spot the README ships with.

The one output is a MODEL that feeds your KSampler. That's the whole node.

Installing it

It's on ComfyUI Manager if you search ComfyUI_sd_forge_multidiffusion, or the manual route:

cd ComfyUI/custom_nodes
git clone https://github.com/StableJeet/ComfyUI_sd_forge_multidiffusion

Then restart ComfyUI. There's no requirements.txt and no model download - the whole thing is two Python files using what ComfyUI already ships. Easiest install you'll do today.

Where people get burned

The pack contains only this node - it tiles the UNet, not the VAE. On very large images the VAE encode/decode can still blow your VRAM, so pair it with a tiled-VAE node from another pack (the classic ComfyUI_TiledKSampler or a TiledVAEDecoder) and you've got the full kit.

Second, because it works by installing a function wrapper on the model clone, don't stack it with other model-wrapper patches - ComfyUI only keeps one UNet wrapper, and the last one applied wins. If another node is already patching your model's UNet, expect a fight.

And one honest caveat: this is a hobby port of a hobby port, one commit old, and "Anima" isn't something the wider community has standardized around. If your model tiles fine on its own, you don't need this. If it doesn't - this is the workaround that actually works.