To upscale NSFW images in ComfyUI, use one of three workflows: an Upscale Image (using Model) node for fast deterministic enlargement, a latent upscale plus a second KSampler pass at 0.3 denoise to add detail, or the Ultimate SD Upscale node for tiled output on low VRAM. Fully local, uncensored. Keep all subjects adult, fictional, and AI-generated.
ComfyUI is the most flexible place to upscale AI art because you build the exact pipeline you want from nodes, and because it runs locally it never filters adult content or uploads your images. The downside is the learning curve: there are several ways to upscale and they produce very different results. This guide covers the three that matter, node by node, so you can pick the right one and wire it correctly. New to ComfyUI itself? Start with our ComfyUI complete guide.
Before anything else, get your upscaler models in place. Drop ESRGAN .pth or .safetensors files into ComfyUI/models/upscale_models so they appear in the loader. Our best upscaler models guide lists which to use for photoreal versus anime.
The three workflows at a glance
| Workflow | Adds detail? | Speed | VRAM | Best for |
|---|---|---|---|---|
| Upscale Image (using Model) | No, enlarges only | Fast | Low | Already-sharp sources, quick 4x |
| Latent upscale + 2nd KSampler | Yes | Medium | Medium to high | Adding detail, faithful results |
| Ultimate SD Upscale node | Yes | Medium | Low (tiled) | Big sizes, limited VRAM |
Workflow A: Upscale Image (using Model)
The simplest. This is a pure ESRGAN upscale: load a model, run the image through it, save. It enlarges by the model’s fixed factor (usually 4x) and sharpens existing detail. It adds no new content, so it is deterministic, fast, and light on VRAM.
Node chain:
# ComfyUI - deterministic ESRGAN upscale
Load Image
-> Upscale Image (using Model)
model: 4x-UltraSharp # photoreal; use 4x-AnimeSharp for anime
-> (optional) Upscale Image By
scale: 0.5 # downscale 4x back to a 2x final size
-> Save ImageDrop in the Load Upscale Model node, point it at your ESRGAN file, feed it into Upscale Image (using Model) along with your image, and connect to Save Image. If 4x is too large, add an Upscale Image By node at 0.5 to land on a clean 2x. That is the entire workflow. Use it when your source is already crisp and you just need more pixels.
Workflow B: latent upscale + second KSampler pass
This is the detail route. After your first generation (or after loading an image and encoding it), you upscale in latent space then run a second KSampler pass at low denoise. The model repaints the larger image, adding genuine new detail while the low denoise keeps the face and composition.
Node chain for upscaling an existing image:
# ComfyUI - latent upscale + refine pass
Load Image
-> VAE Encode # image to latent
-> Upscale Latent
width: 1536 height: 2048 # target size
method: nearest-exact
-> KSampler
model: your checkpoint
denoise: 0.35 # 0.3 to 0.4 keeps likeness
steps: 20
cfg: 6
sampler: dpmpp_2m
scheduler: karras
-> VAE Decode
-> Save ImageFeed the same positive and negative conditioning you used to generate the image into the KSampler. The crucial setting is denoise: keep it 0.3 to 0.4. Below that you barely add detail; above 0.5 the face starts to drift. This route gives more faithful results than a pixel upscale because it is the same model that made the image refining it.
A common refinement is to upscale in pixel space with an ESRGAN model first (Workflow A), then VAE encode and do a low-denoise KSampler pass. That combines clean enlargement with diffusion detail.
Workflow C: Ultimate SD Upscale custom node
The best workflow for large output and limited VRAM. Ultimate SD Upscale is a custom node (install it via ComfyUI Manager by searching “Ultimate SD Upscale”). It tiles the image, enlarges with your ESRGAN model, refines each tile with a diffusion pass at low denoise, and seamlessly stitches the tiles back. Because it processes one tile at a time, a 6GB to 8GB card can produce 4K results that would otherwise run out of memory.
Node chain:
# ComfyUI - Ultimate SD Upscale (tiled)
Load Image
-> Ultimate SD Upscale
model: your checkpoint
positive / negative: your conditioning
upscale_model: 4x-UltraSharp
upscale_by: 2.0
denoise: 0.3
steps: 20
cfg: 6
sampler: dpmpp_2m
scheduler: karras
tile_width: 512
tile_height: 512
mask_blur: 8
tile_padding: 32
seam_fix_mode: Band Pass
-> Save ImageInstall via ComfyUI Manager, restart, and the Ultimate SD Upscale node appears under the upscaling category. Feed it your image, checkpoint model, conditioning, and an ESRGAN upscale model. The tile settings control VRAM: smaller tiles use less memory but take more passes and risk seams. 512 is a safe default. Use seam_fix_mode if you see lines between tiles. This is the workflow most people settle on for serious upscaling.
Try our free NSFW generator to produce base images, then refine them locally with any of these workflows.
Tile size, denoise, and steps guidance
Three settings decide quality and memory.
- Tile size: 512 for 6GB to 8GB VRAM, 768 to 1024 for 12GB or more. Bigger tiles mean fewer seams but more memory.
- Denoise: 0.3 is the sweet spot. 0.2 for minimal change, up to 0.4 for soft sources. Never go above 0.5 on a faithful upscale.
- Steps: 18 to 24. More steps will not fix a bad denoise setting.
- Mask blur and tile padding: raise both if tile seams appear. 8 and 32 are good starts.
For more on fitting big upscales into small cards, see how to upscale NSFW images on low VRAM and GPU hardware requirements.
Photoreal vs anime in ComfyUI
The only thing that changes between photoreal and anime is the upscale model and a slight denoise tweak.
- Photoreal: upscale_model 4x-UltraSharp or 4x_foolhardy_Remacri, denoise 0.3.
- Anime: upscale_model 4x-AnimeSharp or RealESRGAN_x4plus_anime_6B, denoise 0.25 to keep flat color clean.
If you generated with Pony Diffusion or Illustrious, use the anime upscale model and the matching checkpoint in the KSampler so the refine pass stays on-style.
Common mistakes
- Upscale model in the wrong folder. It must be in ComfyUI/models/upscale_models or the loader will not see it.
- Denoise too high in the refine pass. Above 0.5 the face changes. Stay 0.3 to 0.4.
- Wrong conditioning in the KSampler. Use the same prompt and negative as the original or the refine pass drifts.
- Tiles too large for your VRAM. Out-of-memory errors mean smaller tiles in Ultimate SD Upscale.
- Using latent upscale with a mismatched checkpoint. Refine with the model that made the image.
Troubleshooting artifacts
- Visible tile seams: raise mask_blur and tile_padding, enable seam_fix_mode Band Pass, or use larger tiles.
- Face changed: denoise too high, drop to 0.25 to 0.3.
- Duplicated features across tiles: denoise too high or tiles too small; increase tile size and lower denoise.
- Out of memory: smaller tiles, enable tiled VAE, close other GPU apps.
- Soft result: source too soft for ESRGAN alone, add a KSampler refine pass.
If problems trace back to the original render rather than the upscale, fix generation first with the NSFW AI troubleshooting guide.
A note on safety
Upscale only adult, fictional, AI-generated or fully owned subjects. Keep a baseline safety negative in your conditioning, which doubles as the negative the refine pass uses:
negative: child, minor, underage, loli, shota, lowres, deformed, bad anatomyA clean source, the right model, and a local ComfyUI pipeline give you private, uncensored, high-resolution results. Generate base images for free and refine them entirely on your own machine.
A complete two-pass workflow
The most reliable ComfyUI upscale combines a pixel enlarge with a diffusion refine. This is what most experienced users build.
# ComfyUI - two-pass: ESRGAN enlarge then diffusion refine
Load Image
-> Upscale Image (using Model)
model: 4x-UltraSharp # clean 4x enlarge
-> Upscale Image By
scale: 0.5 # back down to a sane 2x
-> VAE Encode
-> KSampler
denoise: 0.3 # adds detail, keeps face
steps: 20 cfg: 6
sampler: dpmpp_2m scheduler: karras
(feed original positive + negative conditioning)
-> VAE Decode
-> Save ImageThe ESRGAN node gets you clean pixels, the KSampler pass paints in detail. This avoids the latent-upscale softness while still adding real texture. It is the best general-purpose recipe in ComfyUI.
Saving and reusing the workflow
Once your upscale graph works, save it. In ComfyUI use the menu to Save the workflow as a .json file, or drag a saved PNG (which embeds its workflow) back onto the canvas to reload it. Build one good upscale workflow and reuse it forever. You can also turn the upscale portion into a group node so it drops into any generation graph as a single block. This is the real payoff of ComfyUI: a repeatable, uncensored, local pipeline you own.
Chaining upscaling onto generation
A powerful pattern is to wire the upscale directly onto the end of your generation graph so a single queue produces a finished high-resolution image. Your txt2img KSampler feeds its latent into a VAE Decode, then into an Upscale Image (using Model) node, then optionally into a second KSampler refine. One click, one finished 4K adult image, fully local. The downside is you upscale every render including the bad ones, so many users keep upscaling as a separate graph and only run it on keepers. Try our free NSFW generator to make those keepers first.
Speed and VRAM expectations
On a mid-range card like an RTX 4060 or 4070:
- Upscale Image (using Model) 4x: a couple of seconds.
- Latent upscale + KSampler refine: 20 to 60 seconds depending on size and steps.
- Ultimate SD Upscale 4x tiled: 30 to 90 seconds.
If you run out of memory, lower tile size first, then enable tiled VAE, then close other GPU apps. See GPU hardware requirements and low VRAM upscaling for tuning a constrained card.
Useful nodes to know
Beyond the three core workflows, a few nodes make ComfyUI upscaling smoother:
- Load Upscale Model feeds an ESRGAN model into the upscale node. Required for Workflow A and Ultimate SD Upscale.
- Upscale Image By scales by a multiplier, handy for downscaling a 4x result to a clean 2x.
- Image Scale resizes to exact pixel dimensions when you need a specific output size.
- VAE Encode / VAE Decode convert between image and latent for the refine pass.
- Tiled VAE (from a custom node pack) reduces VRAM during decode on big images.
Knowing these by name makes wiring any upscale graph fast. Most upscale problems come down to a missing VAE Encode before a KSampler, or feeding an image where a latent is expected.
Matching the refine pass to your generation
The diffusion refine pass is only as good as the conditioning you feed it. Use the same checkpoint, the same positive prompt, and the same negative prompt as the original generation. If a LoRA shaped the character, load it for the refine too, or the upscaled face drifts off-character. For consistent characters this is essential, and the principles in best NSFW LoRAs and how to train a NSFW LoRA apply directly. The refine pass is a second, gentler generation, so treat its conditioning with the same care as the first.
Combining with detailers
A powerful ComfyUI pattern is to run a face or hand detailer before or after upscaling. Nodes like FaceDetailer (from the Impact Pack) crop the face, refine it at high resolution, and paste it back. Running a detailer after a tiled upscale fixes the most common weak spot, the face, at full resolution. This pairs naturally with the upscale workflows here and is part of how to add detail to NSFW AI images. The order that usually works best: generate, detail the face, then upscale, then a light final detail pass if needed.
Reviewing your result
Queue done does not mean job done. Open the Save Image output at 100 percent and scan in order: eyes and catchlights, skin transitions, hands, hair edges, fabric, then tile boundaries. Doubled features point to denoise being too high; faint straight lines in flat areas point to tile seams; a changed face points to denoise or wrong conditioning. Fixes are usually small: drop denoise to 0.25, raise mask_blur and tile_padding, enable seam_fix_mode, or run a FaceDetailer pass. Keep PNG output through the graph and only convert to JPEG at the very end. This one-minute review is the difference between an image that holds up at full resolution and one that visibly breaks down on a zoom.
Batch upscaling in ComfyUI
When you have a folder of keepers, ComfyUI can upscale them in series. Use a Load Image Batch node (from a utility pack) or a simple input directory loop to feed each image through your saved upscale graph, then auto-save the results. This is far more efficient than upscaling one at a time by hand. The smart pattern is the same as everywhere: generate many images at a modest size, cull to the best, then batch-upscale only those keepers through your two-pass graph. Batching the diffusion refine is VRAM-bound, so keep tiles small if you are processing a large queue overnight, and let it run unattended on your own machine with no cloud cost and no content filter in the way.
Bottom line
Use Upscale Image (using Model) for a fast deterministic enlargement, latent upscale plus a second KSampler pass when you want faithful added detail, and Ultimate SD Upscale for big sizes on limited VRAM. Keep denoise at 0.3, match the upscale model to your art style, tile to fit your card, and feed the original conditioning into every refine pass. The two-pass ESRGAN-then-refine recipe is the best general default, and saving your graph as a reusable workflow turns it into a one-click pipeline.
Frequently asked questions
What is the best way to upscale in ComfyUI?
For most people, the Ultimate SD Upscale custom node is the best balance. It tiles the image so it runs on limited VRAM, enlarges with an ESRGAN model, and refines each tile with a low-denoise diffusion pass for real detail. For a quick enlargement without added detail, use the Upscale Image (using Model) node instead.
Where do I install Ultimate SD Upscale in ComfyUI?
Install it through ComfyUI Manager by searching for Ultimate SD Upscale, then restart ComfyUI. The Ultimate SD Upscale node will appear under the upscaling category. You also need an ESRGAN upscale model in ComfyUI/models/upscale_models for the node to use.
What denoise should I use for the second KSampler pass?
Keep denoise between 0.3 and 0.4, with 0.3 as the default. That range adds genuine detail while preserving the face, pose, and anatomy. Going above 0.5 lets the model repaint too much, which can change identity or introduce duplicated features across tiles.
Why does my ComfyUI upscale show tile seams?
Seams appear when tiles do not blend smoothly. Increase mask_blur and tile_padding in the Ultimate SD Upscale node, enable seam_fix_mode set to Band Pass, or use larger tiles if your VRAM allows. Smaller tiles save memory but make seams more likely.
Can I upscale in ComfyUI on 8GB of VRAM?
Yes. Use the Ultimate SD Upscale node with tile_width and tile_height set to 512, and enable tiled VAE. Because it processes one tile at a time, an 8GB card can produce 4K output. The plain Upscale Image (using Model) node is also very light on VRAM.
Do I need different settings for anime versus photoreal in ComfyUI?
Mostly just the upscale model. Use 4x-AnimeSharp or RealESRGAN_x4plus_anime_6B with denoise around 0.25 for anime to keep flat color clean, and 4x-UltraSharp or Remacri with denoise 0.3 for photoreal. Refine with the checkpoint that originally generated the image.
What is the difference between latent upscale and pixel upscale in ComfyUI?
Pixel upscale (Upscale Image using Model) enlarges the final image with an ESRGAN model and adds no new detail. Latent upscale enlarges in latent space then runs a KSampler pass, so the diffusion model paints in new detail. Latent upscale needs a low denoise to stay faithful.
Is upscaling in ComfyUI censored for NSFW content?
No. ComfyUI runs entirely on your own hardware with your own models, so there is no content filter and nothing is uploaded. Every upscale workflow, including the diffusion refine passes, processes adult content exactly like any other image.
