Key Takeaways
- Apache 2.0 license — free for personal and commercial use, source code fully open
- Runs entirely locally: no account, no per-image fee, no internet connection required after download
- Two install paths: a Python package for developers, or a standalone NCNN-Vulkan executable that needs no Python or CUDA setup
- Ships general-purpose (RealESRGAN_x4plus), anime-optimized (RealESRGAN_x4plus_anime_6B), and face-restoration (GFPGAN-integrated) model variants
- Powers the upscale feature in Upscayl, ComfyUI's upscale nodes, and the AUTOMATIC1111 WebUI Extras tab — most users never touch the command line
- Works on Nvidia, AMD, and Intel GPUs through the Vulkan-based executable, and on Apple Silicon through the Python package
📍 In One Sentence
Real-ESRGAN is a free, open-source (Apache 2.0) AI image upscaler that enlarges images and restores detail on local hardware, available as a Python tool, a no-install executable, or built into apps like Upscayl, ComfyUI, and AUTOMATIC1111 WebUI.
💬 In Plain Terms
Point Real-ESRGAN at a blurry or low-resolution photo and it outputs a larger, sharper version — the same job as a paid cloud upscaler like Topaz Gigapixel AI, except the model runs on your own GPU (or CPU) and never leaves your machine.
📌Note: Real-ESRGAN is an upscaler, not a text-to-image generator. It enlarges and sharpens an existing image — it does not create new images from a prompt.
Is Real-ESRGAN Still Maintained?
Yes. Real-ESRGAN, published by researchers at Tencent ARC Lab, remains an active open-source repository on GitHub — it is not archived, and it functions as the de facto standard upscale backend that other actively developed tools build on top of, rather than a standalone app that needs frequent releases of its own.
The clearest signal of its ongoing relevance is indirect: ComfyUI's built-in upscale nodes, AUTOMATIC1111 WebUI's Extras tab, and the dedicated open-source app Upscayl all ship Real-ESRGAN model weights by default in 2026. A tool this deeply embedded as infrastructure inside multiple actively maintained projects does not disappear the way a standalone app with no downstream dependents can.
GitHub repository status
- State:
- Active, not archived
- What it means:
- Source code, issue tracker, and pull requests remain open on github.com/xinntao/Real-ESRGAN
Downstream adoption
- State:
- Bundled by default
- What it means:
- ComfyUI, AUTOMATIC1111 WebUI, and Upscayl all ship Real-ESRGAN models as their default or primary upscaler
Original paper
- State:
- Published 2021, ICCV Workshops
- What it means:
- "Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data" by Xintao Wang, Liangbin Xie, Chao Dong, and Ying Shan
📌Note: Because Real-ESRGAN functions as a model/library other tools embed, checking whether "the app" is maintained is less useful here than checking whether the tools built on top of it (Upscayl, ComfyUI) are — they are.
What Is Real-ESRGAN?
Real-ESRGAN (github.com/xinntao/Real-ESRGAN) is an open-source, Apache 2.0-licensed AI super-resolution model that takes a low-resolution or degraded image as input and outputs a larger, sharper version. It was developed by researchers at Tencent ARC Lab and published as "Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data" at the 2021 ICCV Workshops. Unlike simple interpolation (bicubic or Lanczos resizing), it uses a trained neural network to reconstruct plausible detail — texture, edges, and fine structure — rather than just stretching existing pixels.
- Upscaling: enlarges images by 2x or 4x while adding AI-reconstructed detail instead of blurring
- Restoration: removes JPEG compression artifacts, noise, and blur from real-world degraded photos, not just clean downsampled test images
- Face enhancement: an optional integration with GFPGAN specifically restores and sharpens faces in the upscaled output
- Anime mode: a separate model trained specifically on anime/illustration art, avoiding the over-smoothing that photo-trained upscalers cause on line art
- Batch and video processing: a companion script (inference_realesrgan_video.py) applies the same upscaling frame-by-frame to video files
Which Models Does Real-ESRGAN Ship?
Real-ESRGAN is distributed with several pretrained model checkpoints, each tuned for a different kind of image, and all downloaded automatically the first time you run the tool.
Model | Best For | Scale |
|---|---|---|
| RealESRGAN_x4plus | General photos and real-world images | 4x |
| RealESRGAN_x4plus_anime_6B | Anime and illustration art | 4x |
| RealESRNet_x4plus | Smoother output with less sharpening artifacts | 4x |
| RealESRGAN_x2plus | Photos where 4x is more enlargement than needed | 2x |
| realesr-general-x4v3 | A smaller, faster general-purpose model with adjustable denoise strength | 4x |
The --face_enhance flag layers GFPGAN on top of any of these models specifically to restore facial detail — use it only on images that contain faces, since it can over-smooth non-face regions.
How Do You Install and Run Real-ESRGAN Locally?
There are two supported ways to run Real-ESRGAN: the Python package (for developers who want scripting control) and the NCNN-Vulkan executable (for anyone who wants a ready-to-run binary with no Python or CUDA setup).
- 1Clone or download github.com/xinntao/Real-ESRGAN, then install dependencies with pip install basicsr facexlib gfpgan and pip install -r requirements.txt.
- 2Run python setup.py develop to finish setup inside the cloned repository.
- 3Upscale an image with python inference_realesrgan.py -n RealESRGAN_x4plus -i input.jpg -o results — the model weights download automatically on first run.
- 4Add -n RealESRGAN_x4plus_anime_6B for anime art, or --face_enhance to also run GFPGAN face restoration on the output.
- 5On a low-VRAM GPU, add --tile 400 (or lower) to process the image in smaller tiles instead of all at once, trading speed for lower memory use.
- 6Alternative for a no-Python setup: download the realesrgan-ncnn-vulkan release for your OS from the GitHub Releases page and run it directly against Nvidia, AMD, or Intel GPUs via Vulkan.
Option A: Python package (developers)
This route gives full access to command-line flags (tile size, denoise strength, face enhancement, output format) and is the same backend that ComfyUI and AUTOMATIC1111 WebUI call internally.
Option B: NCNN-Vulkan executable (no Python needed)
Real-ESRGAN also ships a precompiled realesrgan-ncnn-vulkan binary for Windows, Linux, and macOS. It uses the Vulkan graphics API instead of CUDA, so it runs on Nvidia, AMD, and Intel GPUs without installing PyTorch, CUDA, or Python at all — download the release, unzip it, and run it from the command line or drag an image onto it.
Does Real-ESRGAN need a GPU?
A GPU (Nvidia, AMD, or Intel via Vulkan, or Apple Silicon via the Python package) makes it substantially faster, but it also runs on CPU — expect processing to take much longer per image, especially on high-resolution inputs.
How much VRAM does Real-ESRGAN need?
Requirements scale with image size and the --tile setting: a smaller --tile value (e.g. 200-400) lets it run on GPUs with as little as 2-4 GB VRAM by processing the image in smaller chunks, at the cost of slightly slower total processing.
Who Should Use Real-ESRGAN?
Real-ESRGAN fits anyone who needs to enlarge or restore images without paying a per-image or subscription fee, and who is comfortable with either a command-line tool or a simple GUI app built on top of it.
Use Real-ESRGAN if
- You want to upscale photos, scanned images, or old low-resolution files for free, with no account or subscription
- You work with anime or illustration art and need a model trained specifically to avoid over-smoothing line art
- You already use ComfyUI or AUTOMATIC1111 WebUI and want a built-in upscale step in an existing generation pipeline
- You want a GUI without touching a terminal — install Upscayl instead, which bundles Real-ESRGAN models behind a drag-and-drop interface
Avoid Real-ESRGAN if
- You need to generate new image content from a text prompt — that is a text-to-image model like Stable Diffusion, not an upscaler
- You need guaranteed, hands-off maximum quality on professional photography and are willing to pay for it — a paid tool like Topaz Gigapixel AI offers more manual fine-tuning controls and dedicated support
- Your source images have almost no real detail to reconstruct (extremely low-resolution or heavily compressed) — no upscaler, free or paid, can invent detail that was never captured
Real-ESRGAN vs. Alternatives
Real-ESRGAN's closest comparisons are other upscaling tools — some built directly on Real-ESRGAN's own models, some using a different architecture entirely.
Tool | Interface | License | Best For |
|---|---|---|---|
| Real-ESRGAN | CLI / NCNN-Vulkan binary | Apache 2.0 | Scriptable local upscaling, base model for other tools |
| Upscayl | Desktop GUI | AGPL 3.0 | Drag-and-drop upscaling built on Real-ESRGAN models |
| waifu2x | CLI / web / GUI ports | MIT | Older, anime-focused upscaler; lighter weight than Real-ESRGAN |
| ComfyUI (upscale nodes) | Node-based GUI | GPL 3.0 | Upscaling as one step inside a larger image-generation workflow |
| Topaz Gigapixel AI | Desktop app | Proprietary (paid) | Professional photography with manual fine-tuning and paid support |
Common Mistakes When Using Real-ESRGAN
These mistakes come from treating Real-ESRGAN as a generative tool, or from using the wrong model variant for the source image.
Mistake 1: Using the photo model on anime or illustration art
The default RealESRGAN_x4plus model is trained on real-world photos and tends to over-smooth flat-color line art. Switch to RealESRGAN_x4plus_anime_6B with -n RealESRGAN_x4plus_anime_6B for anime, manga, or illustration source images.
Mistake 2: Expecting an upscaler to fix an out-of-focus or motion-blurred photo
Real-ESRGAN restores plausible detail implied by the input, but it cannot recover detail that was never captured. Severely blurred or extremely low-resolution source images will upscale with fewer visible improvements than a mildly compressed, in-focus original.
Mistake 3: Running --face_enhance on images with no faces
The --face_enhance flag applies GFPGAN specifically to detected faces. On images with no faces, it adds processing time with no benefit; on images with small or partial faces, it can occasionally over-smooth them. Reserve it for portraits and group photos.
Frequently Asked Questions
Is Real-ESRGAN still maintained?
Yes. The open-source repository remains active on GitHub, and Real-ESRGAN's models are the default or primary upscale backend bundled inside multiple actively maintained tools, including ComfyUI, AUTOMATIC1111 WebUI, and Upscayl.
Is Real-ESRGAN really free?
Yes. It is released under the Apache 2.0 license, which is free for both personal and commercial use with no per-image fee, no subscription, and no account requirement.
What license is Real-ESRGAN released under?
Apache 2.0, a permissive open-source license. You can use, modify, and redistribute it, including in commercial products, as long as you preserve the license and copyright notice.
Does Real-ESRGAN need a GPU?
A GPU makes it much faster, but it also runs on CPU. It supports Nvidia and AMD GPUs via CUDA (Python package) or Vulkan (the NCNN executable), and Apple Silicon via the Python package.
Can Real-ESRGAN upscale anime or illustration images?
Yes, using the RealESRGAN_x4plus_anime_6B model, which is trained specifically on anime and illustration art to avoid the over-smoothing that photo-trained upscalers cause on line art.
Can Real-ESRGAN generate new images from a text prompt?
No. Real-ESRGAN is a super-resolution upscaler — it enlarges and restores detail in an existing image. Text-to-image generation is a separate category of model, such as Stable Diffusion.
What is the difference between Real-ESRGAN and Upscayl?
Real-ESRGAN is the underlying open-source model and command-line tool. Upscayl is a separate open-source desktop app (AGPL 3.0) that bundles Real-ESRGAN's models behind a drag-and-drop graphical interface, so you never touch a terminal.
Can Real-ESRGAN upscale video, not just images?
Yes, via the companion inference_realesrgan_video.py script, which applies the same upscaling model frame-by-frame to a video file.
How much VRAM does Real-ESRGAN need?
It depends on image resolution and the --tile setting. Lowering --tile to 200-400 processes the image in smaller chunks, letting it run on GPUs with as little as 2-4 GB VRAM at the cost of somewhat slower total processing.