Real-ESRGAN: upscale your images in local

#What an AI upscaler does

Conventional upscaling interpolates: it calculates intermediate pixels from neighboring pixels, producing a larger, blurrier image. A machine-learning upscaler does something else. It was trained to recover a sharp image from a degraded version, and it reconstructs what most resembles the original: textures, edges, grain. The difference in one sentence: interpolation doesn't create information; the model invents it. That's exactly what it's asked to do, which is why you need to know where not to use it.

Real-ESRGAN comes from a paper by Xintao Wang, Liangbin Xie, Chao Dong, and Ying Shan (Tencent ARC Lab), submitted to arXiv in July 2021 and presented at ICCV Workshops: « Training Real-World Blind Super-Resolution with Pure Synthetic Data ». Its abstract describes the idea: a model trained exclusively on synthetic data, with a model of “higher-order” degradations that better simulates real-world defects (blur, noise, compression), and a U-Net discriminator. “Blind” means the model doesn't need to know what degradation the image underwent. The repository has more than 36,000 stars.

#The models, and which one to choose

The project's catalog separates models for photos from models for illustrations, and this is the choice that has the greatest impact on the result. The anime variant is presented as optimized for this type of image, with a smaller network, and the project compares it with waifu2x. For a drawing, try it first: a photo model may texture areas of solid color that should remain smooth, so check the result on your image.

#Three ways to run it

The README describes three paths: an online demo, the portable ncnn executable, and the Python script. For regular local use, only the latter two matter.

#The exact commands

The portable executable is used from the command line. The help text lists the options: -i for input (file or folder), -o for output, -s for scale (2, 3, or 4), -n for the model, -t for tile size, -g to select the GPU, and -f for output format.

# Exécutable portable : photo agrandie ×4 avec le modèle généraliste
./realesrgan-ncnn-vulkan.exe -i input.jpg -o output.png -n realesrgan-x4plus

# Script Python : échelle arbitraire (ici ×3,5) avec amélioration des visages
python inference_realesrgan.py -n RealESRGAN_x4plus -i inputs --outscale 3.5 --face_enhance

The Python script provides the --outscale option: the model always performs a ×4 upscale, then the program resizes the result to the desired scale using an inexpensive resize operation. There is also --tile to split the image and save memory, and --fp32 for full precision, which becomes mandatory on a processor (see below).

In ComfyUI, upscaling models go in ComfyUI/models/upscale_models, and a loader node followed by one upscaling node per model applies them. For a desktop interface, the README lists several projects that bundle Real-ESRGAN, including Upscayl, free software for Linux, macOS, and Windows, with around 50,000 stars and an update in the past few days.

• ComfyUI: upscaling as the graph’s final node

#Use it effectively

1. 01
   Choose the model based on the image type

   Photo or illustration: this is the setting that changes the result the most, well before the upscaling factor. Always add -n to the command.
2. 02
   Don’t stack passes

   Upscaling twice in a row by ×4 produces plastic, not detail. One pass at the right factor is enough; if ×4 is too much, use the ×2 model or the scaling option.
3. 03
   Clean up before scaling up

   Light denoising beforehand prevents the model from treating noise as detail to reconstruct. With realesr-general-x4v3, the -dn option controls denoising strength to prevent an overly smooth result.
4. 04
   Reserve face_enhance for real faces

   The face_enhance option relies on GFPGAN and is intended only for real faces: the project's FAQ advises against using it on animation, where it needlessly consumes GPU memory.
5. 05
   Compare at 100%

   Judge an upscale at the pixel level, not from a thumbnail. Many spectacular results at small sizes look smooth and artificial up close.

#What size should you target: calculate before launching

A ×4 enlargement is useful only if the final size serves a specific purpose. Here is the necessary factor for each destination, based on a simple calculation: pixels = centimeters ÷ 2.54 × resolution in dots per inch, then factor = target long side ÷ starting long side.

Keep the principle in mind: target the useful size, not the maximum size. A 1,024 × 1,024 image enlarged ×4 becomes 4,096 × 4,096, or about 16.8 million pixels—sixteen times more than the original: that is sixteen times as much data to store, load, and edit, for a gain that is often invisible on screen. With the Python script’s --outscale option, you choose the exact scale instead of over-enlarging and then reducing.

#In an image-generation pipeline

For local generation, upscaling is the final step: generate at a resolution the card can support, then upscale, which uses less memory than generating directly at a large size. The native sizes of image models—for example, 512 × 512 for SD 1.5 or 1024 × 1024 for SDXL—are detailed in the Stable Diffusion guide. Then, ×2 upscaling on a 1024 × 1024 SDXL image produces 2048 × 2048 without running it through the diffusion model again.

• Stable Diffusion: versions, native resolutions, and licenses
• Generating images locally: the landscape

#What it makes up

The text

Enlarged small print turns into plausible but false characters. For a document, you need optical character recognition, not a magnifier.

Faces

An enlarged blurry face becomes a sharp face that is not exactly the same person. No identification use is acceptable.

The fine details

Fabric patterns, foliage, hair: the model produces a credible texture, not the original texture.

The drawbacks

A clearly visible compression artifact may sometimes be enlarged with the application instead of being erased.

#Troubleshooting: common errors

#Where the project stands in 2026

You have to be honest about its age. The latest released version, v0.3.0, dates from September 20, 2022, and the last commit to the main repository, from April 2, 2024, removes a continuous integration configuration file. The ncnn implementation, whose README states an MIT license, has not been updated since May 2024. That does not make the model bad: it does its job, it is small, and it runs on modest cards. But you cannot count on fixes for recent incompatibilities, such as the one with torchvision.

Among the alternatives, ComfyUI's README lists SeedVR2 and SUPIR among its supported models. SeedVR2 presents itself as one-step video restoration through adversarial diffusion post-training, while SUPIR targets photorealistic restoration of “in the wild” images. These are diffusion-based approaches: we do not have a reliable numerical comparison with Real-ESRGAN, and the risk of invented detail is at least as high. Read SUPIR's license, which GitHub classifies as “Other,” before commercial use. For most everyday photos and illustrations, Real-ESRGAN remains the best balance of simplicity, speed, and hardware requirements.

• ControlNet: control composition upfront
• The AI Images Kit
• Source: the official Real-ESRGAN repository
• Source: the research paper on arXiv
• Source: the ncnn-vulkan implementation

#FAQ