AI Upscaling Locally: Real-ESRGAN, SUPIR, and ComfyUI Workflows Compared

📚 More on this topic: Stable Diffusion Locally · ComfyUI vs A1111 vs Fooocus · Flux Locally · VRAM Requirements

You have an image that’s too small. Maybe it’s a 512x512 Stable Diffusion output you want to print, an old family photo from a 2-megapixel camera, or a screenshot you need to blow up without it looking like a blurry mess.

AI upscaling solves this. Instead of stretching pixels (which just makes things blurry), neural networks predict what the missing detail should look like and fill it in. The results range from “good enough to post online” to “genuinely hard to tell from a native high-res photo.”

The catch: there are a dozen tools, three different approaches, and wildly different hardware requirements. Here’s what actually matters.

How AI Upscaling Works (30-Second Version)

Traditional upscaling (bicubic, Lanczos) interpolates between existing pixels. It’s fast and mathematically predictable, but it can’t create detail that isn’t there. A blurry face stays blurry, just bigger.

AI upscaling uses neural networks trained on millions of image pairs (low-res input, high-res target) to predict what detail should exist. There are two approaches:

GAN-based (Real-ESRGAN, ESRGAN): A single forward pass through a neural network. Deterministic — same input always produces the same output. Fast (1-10 seconds). The network learned texture patterns during training and applies them.

Diffusion-based (SUPIR, StableSR, ComfyUI workflows): Uses a Stable Diffusion model to generate new detail guided by the low-res image. Stochastic — each run produces slightly different output. Slower (30-300 seconds). Can create detail that’s more photorealistic because it’s literally running an image generator.

The practical difference: GAN-based upscalers sharpen what’s already there. Diffusion-based upscalers imagine what should be there. Both have trade-offs.

The Three Main Approaches at a Glance

Real-ESRGAN: The Workhorse

Real-ESRGAN is the default answer for “how do I upscale images locally.” It’s fast, runs on potato hardware, and produces good results on almost everything. The model has 16.7 million parameters, weighs ~67MB, and processes a 512x512 image in 2-6 seconds on a mid-range GPU.

The project has 34,500+ GitHub stars and is functionally complete. The last major release was in 2022, but it doesn’t need updates because the problem it solves is solved. The ecosystem around it (Upscayl, chaiNNer, ComfyUI nodes) is far more active than the core repo.

Which Model to Use

For photos, start with RealESRGAN_x4plus. For anime or illustration, use the anime_6B model. If you’re processing video, the animevideov3 model hits 65 fps at 640x480 on a V100.

Installation: Three Paths

Path 1: Upscayl (easiest — zero technical setup)

Upscayl is an Electron app that wraps Real-ESRGAN’s NCNN backend. Download, install, drag in an image, click upscale. It has 43,000+ GitHub stars — more than Real-ESRGAN itself.

• Works on Windows, macOS, and Linux
• Uses Vulkan, so it runs on NVIDIA, AMD, and Intel GPUs
• Includes multiple models (general, anime, ultrasharp, digital art)
• Batch processing built in
• Fully offline after install
• Limitation: requires a Vulkan-compatible GPU (no CPU fallback)

This is the right choice for photographers, artists, and anyone who doesn’t want to touch a terminal.

Path 2: pip install (Python scripting and automation)

pip install realesrgan

Or clone the official repo:

git clone https://github.com/xinntao/Real-ESRGAN.git
cd Real-ESRGAN
pip install basicsr facexlib gfpgan
pip install -r requirements.txt
python setup.py develop

Basic usage:

python inference_realesrgan.py -n RealESRGAN_x4plus -i input.jpg -o output/

Batch processing on a folder:

python inference_realesrgan.py -n RealESRGAN_x4plus -i /path/to/photos/ -o /path/to/output/

Key flags:

• --tile 256 — process in tiles to reduce VRAM usage (default: 0, no tiling)
• --face_enhance — apply GFPGAN face enhancement
• --outscale 2 — output at 2x even using a 4x model
• --ext png — force PNG output

Requires NVIDIA GPU with CUDA for the PyTorch version.

Path 3: NCNN portable binary (AMD/Intel GPUs, no Python)

Download pre-built executables from Real-ESRGAN-ncnn-vulkan releases. No Python, no CUDA, no setup. Unzip and run:

./realesrgan-ncnn-vulkan -i input.jpg -o output.png -n realesrgan-x4plus

This uses Vulkan, so it works on AMD Radeon, Intel Arc, and even Apple Silicon through MoltenVK. It’s 1.5-3x slower than the PyTorch/CUDA version on NVIDIA hardware, but it’s the only option for non-NVIDIA GPUs (besides Upscayl, which wraps the same NCNN backend).

VRAM Requirements

Real-ESRGAN is lightweight. With tiling, it runs on practically anything:

Using fp16 (default). All figures approximate with RealESRGAN_x4plus.

If you have 4GB VRAM: Use --tile 128. You can upscale anything up to 4K input.

If you have 8GB VRAM: Use --tile 400. Comfortable with most inputs.

If you have 12GB+: You can often run --tile 0 (no tiling) for inputs up to 1024px.

Smaller tiles mean more processing passes and a slight chance of visible seams at tile boundaries, but Real-ESRGAN’s default 10px tile overlap handles this well in practice.

Where Real-ESRGAN Falls Short

Text. It rebuilds letterforms as shapes, and that rebuild can drift. Small text (below ~12px in the input) gets particularly mangled — letter spacing changes, corners round off, serifs mutate. The result looks clean at a glance and wrong when you zoom in.

Already-clean high-res images. If your source is already decent quality, Real-ESRGAN may add subtle texture hallucination: inventing skin pores, fabric weave, or grass patterns that weren’t there.

Severely degraded photos. Old, noisy, heavily compressed images expose the limits of a single-pass GAN. Real-ESRGAN will sharpen the noise right along with the image. That’s where SUPIR takes over.

SUPIR: The Quality King

SUPIR (Scaling Up to Excellence) works differently from Real-ESRGAN. Instead of a lightweight GAN, it uses SDXL, a 2.6-billion-parameter diffusion model, as a generative prior. It also integrates LLaVA (a vision-language model) to auto-caption your image and use that caption to guide restoration.

What this means in practice: SUPIR understands what’s in your image and generates appropriate detail. It knows skin texture looks different from metal, fabric weave differs from concrete, and tree bark has a specific pattern. On a badly degraded photo, the difference between SUPIR and Real-ESRGAN output is immediately obvious.

The trade-off is cost. SUPIR needs 12GB+ VRAM, takes 30-60 seconds per image, and has a more complex install process. It’s not for batch processing 500 vacation photos. It’s for the 10 images that matter most.

When SUPIR Actually Wins

• Old family photos: Low-res scans from film cameras where faces are 20x20 pixels. SUPIR reconstructs plausible facial features that Real-ESRGAN just blurs.
• Heavy JPEG compression: Images that have been saved and re-saved until they’re artifact soup. SUPIR’s diffusion process can work around compression damage.
• Nature and landscape: Foliage, grass, water — SUPIR generates individually distinguishable detail elements where Real-ESRGAN produces uniform textures.
• Portrait detail: Skin pores, individual hairs, eye reflections at 4x+ upscale.

When to Skip SUPIR

• Text or documents. SUPIR scores 34.6% OCR accuracy on upscaled text — worse than basic bicubic interpolation at 40.6%. It literally generates incorrect characters.
• Anime or illustration. Trained on photographs, SUPIR adds unwanted grain and micro-texture to flat color areas. Use Real-ESRGAN’s anime model instead.
• Already-clean images. SUPIR’s generative nature can over-process, adding texture that wasn’t originally there.
• Batch work. At 30-60 seconds per image, processing 500 photos would take hours.

VRAM Requirements

For ComfyUI (kijai wrapper) tile size tuning:

System RAM: 32GB recommended. Below 32GB causes instability.

How to Run SUPIR

Option A: ComfyUI (recommended)

The kijai/ComfyUI-SUPIR node pack (2,200 stars, actively maintained) is the easiest path:

1. Install via ComfyUI Manager — search “SUPIR” and click install
2. Download the SUPIR model (v0Q for photos, v0F for conservative output) — ~2.7 GB pruned fp16
3. Place it in your ComfyUI models/checkpoints/ folder
4. Load a SUPIR workflow from Civitai or OpenArt

The multi-node design gives you control over every parameter: model precision, tile sizes, step count, prompts, and negative prompts.

Option B: Standalone (MonsterMMORPG enhanced fork)

Furkan Gozukara maintains an enhanced fork with one-click installers for Windows and Linux, 8GB VRAM support, and batch processing. This is the most maintained practical distribution.

The official repo from Fanghua-Yu has installation issues: conflicting dependencies, unclear model download paths, and YAML configs that need manual editing. Use the enhanced fork instead.

Model downloads (minimum ~10GB disk):

• SUPIR checkpoint (v0Q or v0F): ~2.7 GB (pruned fp16)
• SDXL base model: ~6.9 GB
• LLaVA (optional): ~13 GB additional

SUPIR’s Gotchas

It hallucinates. Without a good prompt, SUPIR can generate entirely wrong content. I’ve seen examples where a bus stop roof turned into something resembling an airplane wing. Always provide a descriptive prompt and a negative prompt (“blurry, low quality, noise, artifacts”).

Non-commercial license. SUPIR requires written permission from the authors for commercial use. If you’re upscaling images for a client, this matters.

No AMD GPU support. SUPIR is NVIDIA-only (CUDA). The PyTorch base theoretically supports ROCm, but nobody has documented a working setup with SUPIR’s Flash Attention and xFormers dependencies.

ComfyUI Upscale Workflows: Stay in Your Pipeline

If you’re already generating images in ComfyUI, upscaling within your workflow makes the most sense. Generate an image, upscale it, save the result. No exporting, no separate tool.

ComfyUI has four upscaling methods, each with different quality/speed/VRAM trade-offs.

Method 1: ESRGAN Model Upscale (Fast, Simple)

Load a pre-trained upscale model and run your image through it. No diffusion, no prompts, no sampling steps.

Nodes needed: Load Upscale Model → Upscale Image (Using Model) → Save Image

Popular models (place .pth files in models/upscale_models/):

VRAM: 2-6 GB. Speed: 5-6 seconds on an RTX 4090.

This is functionally identical to running Real-ESRGAN standalone, but it stays in your ComfyUI workflow.

Method 2: Latent Upscale + KSampler (Built-In Hires Fix)

Uses only built-in ComfyUI nodes — no custom nodes required.

1. Generate at base resolution with a KSampler
2. Pass the latent output through a Latent Upscale node (2x)
3. Feed it into a second KSampler at low denoise (0.3-0.5)
4. VAE decode only at the end

The advantage: everything stays in latent space, skipping a VAE decode/encode cycle. This saves time and avoids quality loss from repeated VAE operations.

Settings:

• Denoise 0.3-0.4 = conservative, preserves original
• Denoise 0.5 = adds noticeable new detail
• Denoise 0.6+ = aggressive, risk of hallucination — always provide a prompt

VRAM: 4-6 GB (SD 1.5) or 8-10 GB (SDXL). Speed: 15-30 seconds depending on step count.

Method 3: Ultimate SD Upscale (Tiled Diffusion Upscale)

The Ultimate SD Upscale custom node processes your image tile-by-tile through the diffusion model. It first upscales with an ESRGAN model, then slices the result into tiles and re-renders each one through img2img at low denoise.

Key settings:

• Tile size: 512px for SD 1.5, 1024px for SDXL
• Tile padding: 64-128px (more = smoother seams, slower)
• Denoise: 0.3-0.5
• Seam fix mode: “Half Tile + Intersections” for best results (slower)

VRAM: 4-6 GB (SD 1.5) or 8-12 GB (SDXL). Speed: 1-8 minutes depending on tile count and model.

This method produces higher quality than pure ESRGAN because the diffusion model is actively generating new detail in each tile. The tile-based approach means your VRAM only needs to handle one tile at a time.

Method 4: ControlNet Tile + Ultimate SD Upscale (Maximum Quality)

Combining ControlNet Tile with Ultimate SD Upscale produces the best upscale quality you can get in ComfyUI without SUPIR.

ControlNet Tile feeds the color and structure of each tile as a conditioning input, so the diffusion model stays close to the original composition while adding fine detail. Without it, the model can drift, especially on faces and text.

Setup:

1. Install Ultimate SD Upscale and ControlNet nodes
2. Download TTPLanet_SDXL_Controlnet_Tile_Realistic for SDXL workflows
3. Set ControlNet strength to 0.9, denoise to 0.3-0.4

VRAM: 10-14 GB (ControlNet adds ~1.5-2 GB). Speed: 5-10 minutes.

Flux Upscale Workflows

For Flux users, the Flux.1-dev-Controlnet-Upscaler from Jasper AI is a dedicated ControlNet trained for upscaling with Flux. It conditions the Flux model on a low-res input and generates high-res output with realistic micro-texture.

• Set strength to 0.6 (lower = more creative, higher = closer to original)
• GGUF Q4_K_M variant works on 8-12 GB VRAM
• Full model needs 12-24 GB+

Batch Processing in ComfyUI

For batch upscaling, use the ESRGAN model-only method. At 5-6 seconds per image, you can process hundreds in a reasonable time. Reserve the diffusion-based methods (Ultimate SD Upscale, ControlNet Tile) for hero images where quality matters most.

ComfyUI’s queue system handles batches natively. Drop a folder of images into a Load Image batch node and let it run.

The Free Topaz Gigapixel Alternative Question

If you searched “free Topaz Gigapixel alternative,” here’s the honest answer.

Topaz went subscription-only in September 2025 — $29/month or $149/year. The perpetual licenses that used to cost $99 are gone. Reddit was not happy.

What Topaz does that free tools don’t:

• Face recovery that reconstructs eyes, skin, and hair from pixelated blobs
• Combined denoise + sharpen + upscale in one pass
• Lightroom/Photoshop plugin integration
• Polished batch workflow with before/after preview

What free tools do just as well (or better):

• Clean 2-4x upscaling of decent-quality photos (Real-ESRGAN)
• Anime and illustration upscaling (Real-ESRGAN anime model)
• Maximum quality photo restoration (SUPIR matches or exceeds Topaz)
• Full pipeline automation (ComfyUI, chaiNNer)

The practical verdict: For clean photos where you just need more pixels, Upscayl (free) gets you 90% of Topaz quality. SUPIR can match or beat Topaz on heavily degraded photos but demands a beefier GPU and more setup time. Topaz earns its subscription for professional photographers doing volume work with the Lightroom plugin.

Other Free Tools Worth Knowing

chaiNNer deserves a closer look. It’s a free, node-based image processing app (think ComfyUI but for general image processing, not just Stable Diffusion) that supports PyTorch, NCNN, ONNX, and TensorRT backends. You can load any model from OpenModelDB, chain operations like denoise → upscale → color correct → sharpen, and batch process entire folders. If you want flexibility without the Stable Diffusion overhead, this is the tool.

VRAM Requirements: Everything in One Table

Quality Comparison: When Each Method Wins

Which One Should You Use?

You just want to upscale some images and don’t care about Stable Diffusion: → Install Upscayl. Download it, drag in your images, click upscale. Done.

You use ComfyUI and want upscaling in your pipeline: → Add an ESRGAN model node (4x-UltraSharp or RealESRGAN_x4plus) to your workflow for fast upscales. For hero images that need maximum quality, build a ControlNet Tile + Ultimate SD Upscale workflow.

You have damaged old photos you want to restore: → Use SUPIR through ComfyUI (kijai nodes) or the MonsterMMORPG standalone installer. Budget 30-60 seconds per image and 12GB+ VRAM.

You want to automate upscaling in a Python script: → pip install realesrgan and use the Python API. Or use the NCNN binary for shell scripts.

You have an AMD or Intel GPU: → Upscayl (Real-ESRGAN NCNN with Vulkan) or chaiNNer (NCNN backend). Diffusion-based methods need either NVIDIA CUDA or AMD ROCm on Linux.

You want maximum quality and have a 24GB GPU: → SUPIR for photos. ControlNet Tile + Ultimate SD Upscale for SD/Flux-generated images. Use SUPIR for the difficult restorations, ControlNet Tile for everything else.

You process hundreds or thousands of images: → Real-ESRGAN CLI with batch folder processing. At 3-6 seconds per image on an RTX 3060, 1,000 images take about an hour.

Getting Started: Your First Upscale in 5 Minutes

Fastest path (any GPU):

1. Download Upscayl for your OS
2. Install and open it
3. Click “Select Image” or drag one in
4. Choose “General Photo (Real-ESRGAN)” model
5. Select 4x upscale
6. Click “Upscale”

That’s it. Your image will be 4x larger with AI-generated detail in about 10-20 seconds.

Fastest path (NVIDIA GPU, command line):

pip install realesrgan
python -m realesrgan -i photo.jpg -o photo_upscaled.png -n RealESRGAN_x4plus -s 4

Fastest path (AMD/Intel GPU, command line):

1. Download Real-ESRGAN-ncnn-vulkan for your OS
2. Extract the archive
3. Run:

./realesrgan-ncnn-vulkan -i photo.jpg -o photo_upscaled.png -n realesrgan-x4plus

Start with Real-ESRGAN. If the quality isn’t enough, damaged photos, portraits that need facial detail, then invest the setup time in SUPIR or ComfyUI ControlNet Tile workflows. Most people never need to go past step one.

Prices and tool versions current as of March 2026. Topaz pricing reflects the subscription model introduced September 2025.

---
seo:
  title: "AI Upscaling Locally: Real-ESRGAN, SUPIR, and ComfyUI Workflows Compared | InsiderLLM"
  meta_description: "Real-ESRGAN runs on 4GB VRAM in 5 seconds. SUPIR needs 12GB but beats Topaz quality. Free upscaling tools compared with VRAM tables and install commands."
  slug: "ai-upscaling-locally-real-esrgan-supir-comfyui"
  primary_keyword: "ai upscaling locally"
  secondary_keywords: ["real-esrgan guide", "supir upscaling", "comfyui upscale workflow", "free topaz gigapixel alternative", "upscayl"]
  internal_links:
    - topic: "ComfyUI vs A1111 vs Fooocus"
      anchor_text: "ComfyUI vs A1111 vs Fooocus comparison"
    - topic: "Flux Locally Complete Guide"
      anchor_text: "Flux locally guide"
    - topic: "Stable Diffusion Getting Started"
      anchor_text: "Stable Diffusion locally"
    - topic: "VRAM Requirements"
      anchor_text: "VRAM requirements table"
  image_alt_texts:
    - "Comparison of Real-ESRGAN, SUPIR, and ComfyUI upscaling quality on the same photo"
    - "VRAM requirements chart for AI upscaling methods"
    - "Upscayl interface showing before and after AI upscale"
    - "ComfyUI workflow for ControlNet Tile upscaling"
---