RelayVSR X4 Quants

RelayVSR X4 Quants

Pre-quantized Wan checkpoints for RelayVSR's 4x video upscaler, so it runs in ComfyUI on 16 GB and 24 GB graphics cards at 2560x1408 output, for video editors and restorers.

Made by MATLOWAI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This repository holds smaller versions of the Wan checkpoints for RelayVSR's original 4x video upscaling model. The smaller files let it run on 16 GB and 24 GB graphics cards at 1280x704 in and 2560x1408 out, and faster than full precision. Their job is to feed the RelayVSR nodes of the ComfyUI-MAINodes pack.

Who it suits: ComfyUI users with a mid-range graphics card who want to upscale video will find it fits. It also suits people who restore old footage and want output at higher resolution.

Industry | Who uses it | How they use it | Example
Video editing | Editors | Upscale short clips inside a ComfyUI workflow | Raising a 1280x704 clip to 2560x1408
Footage restoration | Archivists | Sharpen low-resolution footage with a 4x model | Restoring an old short clip
AI video workflows | ComfyUI users | Add an upscaling stage on a 16 GB or 24 GB card | A pipeline that ends with upscaling
Research | Graphics engineers | Compare quantization tiers against full precision | Reading the card's drift scores

If your card has under 16 GB, you can skip it, since the card says smaller weights alone do not get a 12 GB card to this resolution.

Where to use it:

• ComfyUI, with the RelayVSR nodes from ComfyUI-MAINodes
• A graphics card with 16 GB or 24 GB of memory
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Upscale a clip | Editors | A 2560x1408 video made from a 1280x704 one
Fit a smaller card | 16 GB card owners | The same task with the W6A8 or W4A8 file
Speed up a run | 24 GB card owners | A faster run with the int8 file

How to set it up: You need ComfyUI with the MAINodes RelayVSR nodes and a graphics card that suits one of the files. The source gives no install command for the nodes.

• ComfyUI with ComfyUI-MAINodes
• A 16 GB or 24 GB graphics card
• Python with pip, to download the files

1. Install the Hugging Face hub package.
2. Download the repository's files.
3. Copy one Wan file plus flash.safetensors into the folder shown below.
4. Open the RelayVSR settings node in ComfyUI and set its options.

pip install -U huggingface_hub
hf download MATLOWAI/RelayVSR-X4-Quants

ComfyUI/models/relayvsr/RelayVSR/

Card | Wan file | Size | Time per 3 s clip
32 GB, full precision | wan.safetensors from the original repository | 10.1 GB | 28.4 s
24 GB or more | wan_int8_convrot.safetensors | 5.2 GB | 22.0 s
16 GB | wan_w6a8.safetensors | 4.2 GB | 23.0 s
16 GB, more headroom | wan_w4a8.safetensors | 3.0 GB | 22.8 s

How to use it: Open the RelayVSR X2 / X4 Settings node and set variant to X4. Set output_scale to 2, execution_mode to single GPU, and vram to the tier that matches your card, or to auto. For a 2x result the card still picks X4, since the model works at 4x internally and then scales down.

Tool | What it does
variant | Picks the X4 model
output_scale | Sets the output size, 2 in the card's example
execution_mode | Set to single GPU
vram | Picks the memory tier, or auto picks the best fit

Example: You have a 16 GB card and a 3 second clip at 1280x704. You place wan_w6a8.safetensors and flash.safetensors in the folder, set vram to the 16 GB tier and run. The card measured about 23 seconds for such a clip on an RTX 5090.

For newcomers and experts: Video upscaling makes a clip larger and sharper. A good first step is to match the file to your card using the table, then upscale one short clip.

Quantization touches only the linear layers across Wan's 30 blocks, 300 in all. Norms, biases and the other parts keep bf16. Most of the memory goes to the key and value cache, which the tiers store as rotated int8 or int4, so smaller weights alone would not suffice. Against full precision, the drift scores are 53.1, 47.0 and 44.3 dB, and the card says differences above about 45 dB are invisible. Only the RelayVSR worker from MAINodes can open these files.

You place one Wan file and flash.safetensors in the folder
The RelayVSR node loads them through LightX2V
Your 1280x704 clip is upscaled at 4x
Output comes back at 2560x1408 or resized

Title: Time per 3 s clip on one RTX 5090, in seconds
Full precision: 28.4 seconds
int8 ConvRot: 22.0 seconds
W6A8: 23.0 seconds
W4A8: 22.8 seconds

Good to know:

• License: apache-2.0, as listed on Hugging Face
• Cost to run: none named, apart from a graphics card with 16 GB or more
• Data it reaches: the video files you feed into ComfyUI, and the source names no web or account access
• RelayVSR is by kopperx, built on Wan 2.2 and FlashVSR
• Not for: loading outside the MAINodes RelayVSR worker, since the quantized layout differs from LightX2V's own
• Timings come from one RTX 5090 and a 3 second clip

On Hugging Face, 13 November 2026

• Task: video to video
• Library: comfyui
• Downloads in the last 30 days: 0
• Likes: 7
• License: apache-2.0
• Based on: kopper/RelayVSR
• Tags: comfyui, video-super-resolution, upscaling, relayvsr, quantized, int8, video-to-video

Links

• Model: https://huggingface.co/MATLOWAI/RelayVSR-X4-Quants
• Files: https://huggingface.co/MATLOWAI/RelayVSR-X4-Quants/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download MATLOWAI/RelayVSR-X4-Quants

Then follow the usage in its model card. Nothing in this kit runs by itself.