Open Source Video Upscalers: video2x and Real-ESRGAN Setup

Yes, you can upscale video with open-source software, and the open source video upscaler stack has settled into two projects that cover almost every workflow. video2x (20,913 GitHub stars, AGPL-3.0) is the full pipeline: a GUI, a Windows installer, and batch processing that wraps several upscaling engines behind one interface^[1]. Real-ESRGAN (36,472 stars, BSD-3-Clause) is the restoration model most of those engines are built on, and it ships its own portable executables if you want the model without the framework^[2].

This guide covers what each one actually installs, which GPUs they run on (the answer is broader than NVIDIA), which model variants fit which footage, and where the honest limits are that push people back to a hosted API. All project facts come from the two repositories' own documentation, retrieved August 2026.

The open source video upscaler stack, and how the two projects relate

The relationship matters more than the comparison. video2x is a machine-learning video super-resolution and frame interpolation framework; Real-ESRGAN is one of the engines inside it. video2x 6.x supports Real-ESRGAN, Real-CUGAN, and RIFE through ncnn and Vulkan, plus Anime4K v4 and any custom MPV-compatible GLSL shader^[1]. So the practical question is rarely "video2x or Real-ESRGAN" in quality terms; it is whether you want the full video pipeline (extract, upscale, interpolate, reassemble) managed for you, or direct control of the model.

Two facts worth registering before installing anything:

The GPU requirement is Vulkan, not CUDA. video2x requires a GPU that supports Vulkan^[1], and Real-ESRGAN's portable builds run on Intel, AMD, and NVIDIA GPUs through the same ncnn-Vulkan implementation^[2]. The common belief that open-source upscaling needs an NVIDIA card is wrong for this stack.
The licenses point different directions. AGPL-3.0 on video2x carries obligations if you build it into a service you offer to others; Real-ESRGAN's BSD-3-Clause does not. For personal and internal work, neither gets in the way.

video2x: the full-pipeline route

video2x is the right entry point when the input is a video file and the desired output is a better video file, with nothing assembled by hand. The current 6.4.0 release is cross-platform for Windows and Linux, with a Qt6 GUI and a one-click Windows installer^[1].

What the framework handles for you:

Two processing modes: filtering (upscaling) and frame interpolation, so a 24 fps clip can come out both sharper and smoother^[1].
Engine choice per job: Anime4K v4 for speed on animation, Real-ESRGAN for photographic restoration, Real-CUGAN as the anime-tuned alternative, RIFE for interpolation^[1].
The video plumbing: frame extraction, per-frame inference, and reassembly with audio, which is exactly the part that goes wrong when scripting a model directly against a video file.

The trade is opacity and pace. A framework release moves slower than the models inside it, and when a job fails mid-clip, debugging happens at the framework's log level rather than yours.

Real-ESRGAN: portable executables and the Python route

Real-ESRGAN describes its goal as practical algorithms for general image and video restoration^[2], and its distribution reflects the "practical": prebuilt portable executables for Windows, Linux, and macOS that need no Python environment at all, running on Intel, AMD, and NVIDIA GPUs via ncnn-Vulkan^[2].

The details that matter for video work:

AnimeVideo-v3 is the video-specific model: a small model tuned for anime video, documented with its own comparisons in the repo^[2]. For animation footage it is the default pick, not the general x4plus model.
RealESRGAN_x4plus_anime_6B is the compact anime-image model when file size and speed matter^[2].
The Python inference script supports tiling^[2], which is the low-VRAM escape hatch: a frame too large for your GPU's memory gets processed in tiles instead of failing. Slower, but it completes.
Alpha channels, grayscale, and 16-bit images are handled by the same script^[2], which matters when the "video" job is really an image-sequence job from a VFX pipeline.

The trade going this direction: Real-ESRGAN alone processes frames, not videos. You own the ffmpeg extraction and reassembly, the audio track, and the frame-rate bookkeeping, or you put video2x back on top and are one abstraction up again.

What the free route actually costs

The software is free; the run is not. Per-frame inference occupies the GPU for the full duration of the job, a long clip at 4× is hours of occupancy on a consumer card, and tiled processing for low VRAM stretches it further. That cost is invisible until the third batch of the week, which is when the arithmetic against a hosted API becomes worth running: per-second API pricing starts at $0.002054/s for light enhancement and $0.044/s for dedicated Topaz upscaling^[3]^[4], and the break-even math against your own volume takes five minutes.

The clean division of labor most teams land on: open source for iterating on a restoration until it looks right (unlimited reruns, zero marginal cost), the API for the batch that follows (the batch pipeline in Python is about 80 lines). The failure mode to avoid is scripting a fragile local farm to process a monthly volume that would cost $25 hosted.

A ten-second test, step by step

Whichever tool you install, the first run should be a trimmed test segment, not a full clip. The sequence that saves the most wasted GPU-hours:

Cut ten seconds from the worst-looking part of the footage; a clean section will pass any upscaler and tell you nothing.
Pick the engine by content, not by benchmark screenshots: photographic footage to Real-ESRGAN's general models, animation to AnimeVideo-v3 or Anime4K, and interpolation only if the delivery format actually needs the higher frame rate^[1]^[2].
Run at 2× before trying 4×. Doubling resolution is usually safe; quadrupling from low-quality source invents detail that drifts on faces and text.
Compare on the target screen at 100% zoom, paused on motion. Temporal shimmer and tile seams hide at thumbnail size.
Time the run and extrapolate. Ten seconds of processing time multiplied by your real backlog is the honest cost of the free route, and the number that decides whether the batch stays local.

Picking between them in practice

Install video2x when the job is "make these video files better" and you want a GUI, an installer, and engine choice without plumbing. Animation-heavy workloads especially: Anime4K and Real-CUGAN live natively there^[1].

Go direct to Real-ESRGAN when you need the portable executable on a machine without Python, are processing image sequences rather than container files, need tiling to fit VRAM, or are embedding restoration into your own pipeline where AGPL is a problem and BSD is not^[2].

Skip both when the footage is already clean and just needs resolution for a delivery spec; that is the boring, cheap job hosted enhancement tiers exist for^[4].

FAQ

Can I upscale videos using open-source software?

Yes. video2x gives you a full GUI pipeline with a Windows installer and Linux support, wrapping Real-ESRGAN, Real-CUGAN, RIFE, and Anime4K engines^[1]; Real-ESRGAN alone ships portable executables for Windows, Linux, and macOS^[2]. Free, local, and private; the costs are GPU time and setup effort.

Do I need an NVIDIA GPU for video2x or Real-ESRGAN?

No. This stack runs on Vulkan through ncnn: video2x requires a Vulkan-capable GPU^[1], and Real-ESRGAN's portable builds explicitly support Intel, AMD, and NVIDIA GPUs^[2]. CUDA-only is a myth here, though NVIDIA cards remain the most tested path.

Which model should I use for anime footage?

Real-ESRGAN's AnimeVideo-v3 for video, or the compact x4plus_anime_6B for images^[2]. Inside video2x, Anime4K v4 is the fast option and Real-CUGAN the quality-focused anime alternative^[1]. Photographic footage stays on the general Real-ESRGAN models.

What if my GPU runs out of memory?

Use tiling. Real-ESRGAN's inference script has tile options that split each frame into pieces the GPU can hold^[2]. The run gets slower and very aggressive tiling can seam on gradients, but it turns "out of memory" into "finished late."

Can I use these tools commercially?

Real-ESRGAN's BSD-3-Clause license is permissive, including commercial use^[2]. video2x is AGPL-3.0^[1]: fine to use commercially in-house, but embedding it in a service you distribute or host for others triggers copyleft obligations worth a real legal read.

When is a hosted API cheaper than running these locally?

When volume is steady and the per-run tinkering is over. Hosted enhancement starts around $0.12 per minute of footage^[4]; if your GPU would be occupied for hours to save a few dollars, or the batch needs to run unattended, the API route wins. Iteration-heavy restoration work stays local.

Running your first upscale

Start with ten seconds of your worst footage, run it through Real-ESRGAN's portable executable with the model that matches the content, and judge on the target screen before committing hours of GPU time. If the result holds and the volume is occasional, this open source video upscaler stack is genuinely all you need; if the batch keeps growing, keep the local setup for look-development and let the arithmetic decide where the volume runs.

References

k4yt3x. video2x — README: supported engines, modes, platforms, and requirements (v6.4.0). Retrieved August 2026 from github.com/k4yt3x/video2x
Xintao Wang et al. Real-ESRGAN — README: portable executables, model variants, inference options. Retrieved August 2026 from github.com/xinntao/Real-ESRGAN
reAPI. Topaz Video Upscaler — model page with live per-second pricing. Retrieved August 2026 from reapi.ai/models/topaz-video-upscaler
reAPI. Enhance Video 1.0 — model page with live per-second pricing. Retrieved August 2026 from reapi.ai/models/enhance-video-1-0