NanoVSR

Towards Real-Time Video Super-Resolution on Edge Devices

Accepted to ECCV 2026

4× video super-resolution with NanoVSR-644k — 27.2 FPS on a Jetson Orin NX (25 W).

NanoVSR is a scalable, fully convolutional video super-resolution (VSR) architecture built for resource-constrained edge devices. It performs 4× upscaling with:

• a bidirectional recurrent design with direct additive propagation (no channel concatenation, lower memory bandwidth);
• reparameterizable multi-branch blocks (3×3 + 1×1 + identity) that collapse into a single stream of plain 3×3 convolutions at inference — no custom CUDA ops, natively ONNX/TensorRT compatible;
• spatio-temporal alignment learned implicitly via a two-stage progressive training curriculum (short Vimeo-90K sequences → long REDS sequences), with no explicit optical flow.

The baseline NanoVSR-644k reaches 28.64 dB PSNR on REDS4 at 27.20 FPS on an NVIDIA Jetson Orin NX 16GB (25 W); the scaled NanoVSR-1.7M reaches 29.15 dB at 19.58 FPS.

Try it live

Upload your own low-resolution clip (or try the built-in REDS4 example) in the interactive Gradio demo — no setup required.

Model files

All checkpoints in this repo store the multi-branch (training) topology and perform 4× upscaling. Loading code (utils.load_model) automatically reparameterizes them into the fused, deploy-ready form. Runtime is ms/frame for a 180×320 input on an H100 (FP32); FPS is measured on Jetson Orin NX 16GB (25 W) with TensorRT FP16, 180×320 input, T=15.

PSNR/SSIM: RGB for REDS4, Y-channel for Vid4 and Vimeo-90K-T.

How to use

The model definition lives in the GitHub repo; this Hub repo only hosts the pretrained weights. Clone the code, then load a checkpoint straight from the Hub with huggingface_hub:

git clone https://github.com/filippawlicki/nanovsr.git
cd nanovsr
pip install -r requirements.txt huggingface_hub

from huggingface_hub import snapshot_download
from utils import load_model

# fetches just this checkpoint + config.json (not the other three variants)
repo_dir = snapshot_download(repo_id="filippawlicki/nanovsr",
                              allow_patterns=["config.json", "nanovsr_644k.pth"])
model = load_model(f"{repo_dir}/nanovsr_644k.pth", device="cuda")  # reparameterizes into deploy form automatically

# model(x) expects x: [B, T, 3, H, W] float in [0, 1], genuinely low-res (e.g. 180x320-270x480)
# and returns [B, T, 3, H*4, W*4]

Or upscale a video end-to-end with the bundled demo script:

python demo.py --checkpoint nanovsr_644k.pth --input my_clip.mp4 --compare

See the GitHub README for training, evaluation, and ONNX/TensorRT export instructions.

Training data

Two-stage curriculum: 7-frame Vimeo-90K sequences for the first 50k iterations, then 30-frame REDS sequences until 150k total, with 256×256 GT patches, Charbonnier loss, and cosine-annealed LR. Evaluated on REDS4, Vid4, and Vimeo-90K-T (held out from training).

Intended use & limitations

• Designed for genuinely low-resolution input (the paper operates on 180×320 and 270×480 frames) — feeding already-HD video defeats the purpose and will be slow/memory-hungry.
• Fixed 4× upscaling factor.
• Trained on real-world camera footage (REDS, Vimeo-90K); may not generalize to synthetic, animated, or heavily compressed/artifacted sources outside that distribution.

Citation

@misc{pawlicki2026nanovsr,
      title={NanoVSR: Towards Real-Time Video Super-Resolution on Edge Devices},
      author={Filip Pawlicki and Marcel Kańduła and Marcin Pucek and Kamil Dobies},
      year={2026},
      eprint={2607.10495},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2607.10495},
}

License

Released under the MIT License.