ComfyUI Outpainting Masterclass: Seamless Edges Every Time

ComfyUI outpainting is the technique that most people give up on. You extend the canvas, you generate the new region, you get a visible seam where the old image meets the new. The seam is the giveaway. Once you see it you cannot unsee it. After two years of fighting this exact problem, I finally have a workflow that produces seamless edges reliably, and most of the techniques that make it work were not common knowledge a year ago.

Quick Answer: To get seamless ComfyUI outpainting in 2026, use the Pad Image for Outpainting node with at least 64 pixels of feathering, enable Differential Diffusion in your sampler graph, do multi-pass extension at 512 or 768 pixels per pass instead of one giant extension, and run a final low-denoise pass over the seam region with the same prompt. Flux Fill produces cleaner seams than SDXL inpainting models for most use cases. Sky, hair, and pattern continuity require special handling.

Why Outpainting Seams Look Wrong (The Boundary Discontinuity)

I spent maybe 30 hours last year trying to figure out why my outpaintings always had seams. The conclusion was technical. Outpainting seams exist because diffusion models do not have any inherent mechanism for boundary continuity.

Here is what happens during an outpainting pass. You add padding around your original image. You create a mask that is white over the new region and black over the original. The sampler runs noise through the masked region while preserving the unmasked pixels.

The mask boundary is the problem. The sampler treats the mask as a hard binary. Pixels are either in the generation region or they are not. There is no smooth transition. The model produces new content in the masked region with whatever logic it learned from training, and the new content has no obligation to match the texture, color, or detail of the unmasked region right at the boundary.

The result is a visible discontinuity. Sometimes it is a color shift (the new region is slightly darker or lighter). Sometimes it is a texture mismatch (the new sky has different cloud noise than the original). Sometimes it is a hard edge artifact where the model's denoising process produced a sharp gradient right at the mask line.

Feathering is the first defense. Differential Diffusion is the deeper fix. Multi-pass extension is the production-grade approach. Get all three right and the seams disappear.

For the broader inpainting context that overlaps with outpainting, the ComfyUI inpainting advanced techniques guide covers the mask manipulation techniques that apply to both directions.

The 5 Blending Techniques Compared

I have tried five different approaches to making outpainting seams disappear. Here is what each one actually does and when each one wins.

Technique 1, plain Pad Image without feathering. The naive baseline. Hard mask boundary. Seams always visible. Useful only as a quick prototype to see what the new content looks like before fixing the seam.

Technique 2, Pad Image with 64-pixel feathering. The mask transitions from black to white over 64 pixels. The sampler can blend the new region into the existing image across that transition zone. Most simple outpainting cases work with just this. Average seam visibility drops from "obvious" to "subtle."

Technique 3, feathering plus Differential Diffusion. Differential Diffusion uses the mask as a denoising strength field rather than a binary. Pixels at the mask boundary get partial denoising. The result is much smoother gradients. Combined with feathering, this gets you to "seam barely visible on close inspection."

Technique 4, multi-pass outpainting. Instead of extending the canvas by 1024 pixels in one pass, do it in two or three passes of 384 to 512 pixels each. Each pass produces a smaller new region with more original-image context to anchor against. The cumulative seams are softer than one giant extension.

Technique 5, full pipeline with final seam-region inpaint. All of the above, plus a final low-denoise pass over a narrow band along where the seam used to be. The final pass smooths any remaining discontinuity. This is the production workflow that gets you to "seam undetectable."

I rate these on a 1-to-5 scale based on 50 test images each.

• Technique 1, baseline, average 1.5/5 seam quality
• Technique 2, with feathering, 2.8/5
• Technique 3, plus Differential Diffusion, 3.8/5
• Technique 4, plus multi-pass, 4.2/5
• Technique 5, full pipeline, 4.7/5

The full pipeline takes about 3x longer than the baseline. For client work where seamless output matters, the time is worth it. For experiments and drafts, technique 2 is fine.

Setting Up the Pad Image for Outpainting Node

The Pad Image for Outpainting node is the foundation of any outpainting workflow. According to the ComfyUI Wiki Image Pad for Outpaint reference, the node takes an input image and adds configurable padding on each side, producing an extended image and a corresponding mask.

The node has these inputs:

• image: your source image
• left, top, right, bottom: how many pixels to add on each side
• feathering: the width of the feathered transition zone on the mask

The first decision is direction. Are you extending the image up, down, left, right, or in multiple directions at once? For wide-aspect extensions like extending a portrait shot to landscape, you usually add equal left and right padding. For sky extensions you add top padding. For full bleed extensions you add some on every side.

The second decision is feathering width. Most tutorials use 0 or 32. I run 64 to 128 for most work. The wider the feathering, the more transition zone the sampler has to blend across, but also the more original image gets partially overwritten. The 64-pixel default is a good compromise for most cases.

The third decision is target resolution. The padded image goes into your sampler at a specific size. Stick to multiples of 64 pixels in both width and height. SDXL samplers prefer multiples of 8 for any internal operations. If your final target is 1920x1080, work in 1920x1088 or 1920x1024 inside the workflow and crop the last 8 pixels in post.

The connection order in your workflow:

• Original image goes into Pad Image for Outpainting
• Pad Image outputs extended image and mask
• Both flow into Set Latent Noise Mask (for SDXL) or into Differential Diffusion node (for the better pipeline)
• The masked latent goes into KSampler
• Sampler output goes through VAE Decode
• Final image is your outpainted result

For more outpainting basics that pair well with this guide, the Flux Fill complete guide for inpainting and outpainting covers the Flux-specific workflow patterns.

Mask Feathering: Pixel Counts That Actually Matter

The feathering parameter is more important than people realize. It is the single biggest controllable factor in seam visibility.

I ran a controlled test of feathering values from 0 to 256 pixels in 32-pixel increments. Same source image, same prompt, same seed, same model. Only the feathering changed.

Feathering 0: Hard mask boundary. Visible seam in every case. Color shifts of 5 to 15 percent across the boundary. Useless for any production work.

Feathering 16: Slight softening. Still visible seam in 8 out of 10 cases. Color shifts of 3 to 10 percent.

Feathering 32: The default in many tutorials. Better but still has seam visibility in maybe 50 percent of generations. Acceptable for casual work.

Feathering 64: My recommended default. Seam visibility drops to maybe 20 percent of cases. Even visible seams are subtle.

Feathering 96 to 128: The high-quality zone. Seam visibility under 10 percent. The cost is that more of the original image gets partially modified.

Feathering 192 to 256: Excessive for most cases. The transition zone becomes so wide that the original image's edge details get blurred. Sometimes useful for very high-quality work on simple backgrounds.

The rule of thumb. For most outpainting, use 64. For higher quality where you can afford some edge softening, use 96 to 128. For drafts and prototyping, use 32.

Real talk. The feathering parameter is invisible in many ComfyUI tutorials because the focus is on the model. The model matters less than people think. The feathering value is the difference between professional-looking outpaintings and obviously AI-extended images.

Differential Diffusion for Gradient Boundaries

Differential Diffusion is the technique that took outpainting from "okay" to "production-grade" for me. According to the ComfyUI DiffusersImageOutpaint GitHub readme, it changes how the mask is interpreted during sampling.

Standard inpainting and outpainting use the mask as a binary signal. Pixels in the masked region get fully denoised. Pixels outside get not denoised at all. The boundary is sharp.

Differential Diffusion interprets the mask as a continuous denoising strength field. A pixel at the mask center gets full denoising. A pixel at the mask edge gets partial denoising. A pixel just outside the mask gets a tiny bit of denoising that smooths into the original image.

The result is gradient continuity across the boundary. Instead of "everything new on one side, everything original on the other," you get a smooth transition zone where the sampler produces partial blends.

Setup in ComfyUI:

• Add the Differential Diffusion node from the standard ComfyUI nodes pack
• Connect your model output through Differential Diffusion before the KSampler
• The mask from Pad Image for Outpainting goes into Differential Diffusion's mask input

That is it. The node has no parameters to tune. It is either in your workflow or not. When it is in, the boundary handling improves dramatically.

The cost. Differential Diffusion adds about 20 to 30 percent to generation time because the sampler has to do extra work in the transition zone. For high-quality outpainting, this is worth it. For high-volume batch work, you might skip Differential Diffusion and rely on feathering plus multi-pass.

Hot take. Almost nobody mentions Differential Diffusion in beginner outpainting tutorials. It is the single biggest quality improvement available and most people are not using it. If you take one thing away from this guide, add Differential Diffusion to your workflow tonight.

Multi-Pass Outpainting for Large Extensions

When you need to extend the canvas significantly (say doubling its size or going from portrait to wide landscape), one big single-pass outpainting struggles. The new region is too large. The model has to invent too much content with too little reference from the original image.

Multi-pass outpainting solves this by extending in smaller increments. Instead of adding 1024 pixels on the right side in one pass, you add 384 pixels three times. Each pass uses the result of the previous pass as the new "original" image.

The multi-pass workflow:

1. Pad Image for Outpainting, right side only, 384 pixels, feathering 64
2. KSampler with Differential Diffusion to fill the new region
3. Use the output as the input to a second Pad Image node
4. Pad Image for Outpainting, right side only, 384 pixels, feathering 64
5. KSampler again
6. Repeat for the third pass

The result is three smaller extensions that compound into a 1152-pixel extension, but with much better coherence than one 1152-pixel single pass.

The trade-off. Three passes take roughly 3x the generation time of one pass. The quality improvement is real, especially for content like skies, landscapes, and architectural backgrounds where coherence matters. For simple flat backgrounds, single-pass with good feathering is often enough.

I use multi-pass automatically for any extension over 512 pixels. Under 512, single pass with the full pipeline (feathering + Differential Diffusion + final seam-region inpaint) is usually fine.

For the prerequisite techniques on inpainting that overlap with outpainting, the ComfyUI mask editor mastery guide for inpainting covers the mask manipulation patterns.

Choosing Between SDXL Inpainting and Flux Fill

The model you outpaint with matters a lot. SDXL with a dedicated inpainting checkpoint (like JuggernautXL Inpaint) and Flux Fill are the two main 2026 options. Each has its place.

SDXL inpainting:

• Faster generation, around 8 to 12 seconds per outpaint pass on RTX 4090
• Smaller VRAM footprint, runs on 12 GB cards comfortably
• Wide ecosystem of inpainting-tuned checkpoints
• Works well for stylized and artistic outpainting
• Sometimes weaker on photorealistic edge detail

Flux Fill:

• Slower, around 14 to 20 seconds per outpaint pass
• Higher VRAM, needs 16 GB minimum for comfortable use
• Native model from Black Forest Labs designed for fill tasks
• Excellent photorealistic edge continuity
• Better at matching lighting and color tone across the seam

My split. For most production photorealistic work, Flux Fill. For batch processing or stylized work, SDXL inpainting with a tuned checkpoint. For tight VRAM, SDXL is the only practical choice.

A specific use case where Flux Fill wins consistently is sky extensions in landscape photography. The lighting gradient and color tone across a sky is something Flux Fill handles much better than SDXL out of the box. SDXL inpainting can match it but requires a sky-specialized checkpoint.

For full Flux Fill workflows specifically, the Flux Fill complete guide for inpainting and outpainting covers the Flux-specific parameters and the differences from SDXL setups.

Failure Cases: Sky, Hair, Patterned Backgrounds

Three subject categories that break standard outpainting workflows. Each one needs a slightly different approach.

Sky. The first 60 percent of skies extend fine. The remaining 40 percent fail with visible cloud-direction discontinuities, color band changes, or sun-position inconsistencies. The fix is multi-pass with a specific sky prompt at each pass that mentions the same time-of-day and weather conditions as the original. Plus a final seam-region pass at very low denoise (0.2 to 0.3) to smooth any residual artifacts.

Hair. Faces have hair flowing in specific directions and with specific strand patterns. Extending the canvas around a face often produces hair that does not match the existing direction or strand density. The fix is to mask out the hair region for special handling, run the main outpaint, then run a hair-specific inpaint pass over the affected region with a hair-direction-aware prompt.

Patterned backgrounds. Brick walls, wallpaper, fabric textures, anything with a repeating pattern. The standard outpaint can produce pattern misalignment at the seam. Fix is either to use a ControlNet with a pattern reference, or to inpaint the extended region with a stronger prompt about the specific pattern type and texture scale.

These three are the "always check" cases. Even with the full pipeline, generate three or four outputs and pick the best one. Some of the failures are unfixable in a single pass and need a manual touch-up in Photoshop. The full-pipeline outpainting workflow gets you to "fixable" rather than "broken."

For the deeper inpainting technique pairing, the inpainting and outpainting advanced techniques in ComfyUI guide covers the chained workflow approach that handles these difficult cases.

The Full Production Workflow Inside Apatero

Once you have a working full-pipeline outpainting workflow in ComfyUI, the next step is making it reusable. The JSON file is portable but managing it across projects, sharing it with collaborators, and running it at production volume gets clunky.

Full disclosure, I help build Apatero. The outpainting workflow is one of the Realm templates we shipped because the manual ComfyUI setup is exactly the kind of thing teams ask for ready-made. Apatero Realms wrap the full pipeline (Pad Image, feathering, Differential Diffusion, multi-pass, final seam-region pass) into a single configurable Realm that anyone on your team can use.

The advantage at scale. If you are outpainting 200 images for a campaign, you want every image to use the same pipeline with the same parameters. A Realm enforces that. Manual ComfyUI workflows drift if anyone adjusts a slider mid-batch.

If you do not want to manage the workflow yourself, Apatero has outpainting available as a Realm template. Drop in your source image, set the extension direction and amount, the rest of the pipeline runs automatically. I built it because I was doing repeated outpainting work for client projects and the per-image manual setup was eating my time.

This is not the only way to do production outpainting. Headless ComfyUI in a script also works fine. The Realm approach is the shortest path from "I have a tuned workflow" to "my team can use it without rebuilding it."

FAQ

Why does my outpaint look fine in the preview but bad when zoomed in? The seam discontinuity is often a couple of pixels wide. At normal viewing distance it looks fine. Zoomed in you see the boundary. The fix is the final seam-region inpaint pass at low denoise. That pass smooths the few pixels at the boundary.

Do I need a dedicated inpainting model or can any model do outpainting? Dedicated inpainting models perform meaningfully better. SDXL has inpaint-specific checkpoints. Flux has Flux Fill. Using a regular text-to-image model for outpainting works but produces worse seams and worse content coherence.

What is the right feathering for landscape extensions versus portraits? Landscapes with smooth gradients (skies, water) benefit from larger feathering, around 96 to 128. Portraits and detailed subjects benefit from smaller feathering, around 64. The principle is that smoother content can tolerate more transition zone, detailed content needs tighter boundaries.

Can I outpaint in multiple directions in one pass? Yes, by setting padding on multiple sides of Pad Image for Outpainting. The seam-handling is harder because you have more boundary to manage. For best quality, do multi-pass with one direction per pass.

Does Differential Diffusion work with Flux Fill or only SDXL? Both. The Differential Diffusion node accepts model output from either. The benefit is slightly larger with SDXL because Flux Fill has better default boundary handling, but both improve with Differential Diffusion in the pipeline.

My seams look fine but the new content doesn't match the original style. What's wrong? The prompt is the issue, not the seam workflow. Your outpainting prompt needs to match the lighting, color, time of day, and overall style of the original. Generic prompts produce stylistic mismatches even with perfect seams. Use the same style references that produced the original image.

Can I outpaint while preserving specific details in the original image? Yes, you control the mask. Lower feathering values preserve more of the original right up to the boundary. Or use a stricter mask shape that only covers the truly new pixels. Or do the outpaint first, then do a low-denoise final pass over the entire image to homogenize the style.

What's the largest single-pass extension that still looks good? For SDXL, around 512 to 768 pixels in one direction with high quality. For Flux Fill, around 768 to 1024. Beyond those sizes, multi-pass produces noticeably better results.

Do I need ControlNet for outpainting? Usually not. Outpainting works well without ControlNet for most cases. Where ControlNet helps is preserving structural elements (specific building lines, specific horizon position) that pure outpainting might lose. Add it when needed, not as default.

Why does my sky look weird when I extend upward? This is the most common failure mode. The fix is to specify the exact sky type in your prompt ("clear cloudless blue sky at 11 AM, sun behind camera" or similar). Multi-pass with this prompt is more reliable than one big single-pass. Plus a final low-denoise pass over the seam region.

Real Production Notes from a Year of Outpainting Work

I have outpainted maybe 2,000 images across the last year, across client work, personal projects, and content for ApaWeb. The patterns that stick.

The biggest lesson is to plan the extension before generating the original. If you know you will need a landscape extension of a portrait image, generate the portrait with composition that leaves room for the extension. Faces too close to one edge of the frame are nightmare to extend gracefully. Better to compose for the final aspect ratio from the start.

The second lesson is that multi-pass is worth the time. The 3x generation time of three passes feels heavy until you compare a multi-pass result with a single-pass result side by side. The single-pass result has artifacts. The multi-pass result feels native.

The third lesson is to keep your prompts consistent across passes. The same prompt with small variations across multiple passes produces incoherent results. Use the exact same prompt with maybe one small adjustment per pass and the model produces coherent extensions.

The full pipeline takes time but it works. Once you have the workflow set up and tuned, you have it forever. The thirty minutes you spend setting up the Pad Image + Differential Diffusion + multi-pass + final seam-inpaint workflow pays back across every future outpainting project.

According to the ComfyUI Outpainting Workflow Example official docs, the official recommendation now includes the techniques in this guide as best practices. The community is converging on the production-grade pipeline as the standard answer for serious outpainting work.

If you are still doing single-pass outpainting with default feathering and wondering why your seams are visible, try the full pipeline once. The result speaks for itself.