RelayVSR X4: int8 / W6A8 / W4A8 Wan quants for ComfyUI

Pre-quantized Wan checkpoints for RelayVSR's original 4x model (kopper/RelayVSR), so it runs on 16 GB and 24 GB cards at full H3 resolution (1280x704 in, 2560x1408 out), and faster than full precision. They are made for the RelayVSR nodes in ComfyUI-MAINodes (relayvsr/README.md), which run RelayVSR through LightX2V in its own Python.

Where the originals live: RelayVSR is by kopperx. Code, paper, project page and demo are on github.com/kopperx/RelayVSR; its "Model Weights" link is kopper/RelayVSR, which holds the original X4 wan.safetensors and flash.safetensors without a model card of its own. lightx2v/RelayVSR_X2 is the LightX2V team's separate native-2x retrain, not the source of these files.

Use the X4 model even for 2x output: it computes at 4x and resizes, and on our clips it was clearly better than the native X2 model.

Pick by card

Download one Wan file plus flash.safetensors into ComfyUI/models/relayvsr/RelayVSR/. On the RelayVSR • X2 / X4 Settings node set variant = X4, output_scale = 2, execution_mode = single GPU, and vram = the matching tier (or auto, which picks the best tier your card fits from the files present).

Measured on one RTX 5090: a 3 s (73-frame) MiniMax-H3 clip, 1280x704 -> 2560x1408, the node's default faithful quality preset, no offload for the quantized tiers. "Peak" is nvidia-smi. The 16 GB tiers ran under a PyTorch memory cap that leaves room for the CUDA context and a desktop on a 16 GB card. Drift is PSNR between the frames and the full-precision output; above ~45 dB the difference is invisible. On five 3 s clips scored against ground truth (2x from half resolution), every tier scored the same as full precision (35.9-36.0 dB overall, 34.3-34.5 dB on a mustache crop).

Memory is set by resolution, not clip length: most of it is Wan's key/value cache over four keyframes (19.6 GiB in bf16 at this size), which the tiers store as Hadamard-rotated int8 / int4 at run time. That is why smaller weights alone would not take a 12 GB card to this resolution.

Pixels

Frame 36 of the test clip, 1:1 crops of the 2560x1408 outputs (top: the input upscaled with plain Lanczos).

Mustache, 2x nearest-neighbour zoom

Mustache, 1:1

Shelf, 1:1

Full frame (full precision, shown at half size)

What's in the files

The 300 linear layers of Wan's 30 blocks are quantized with comfy-kitchen 0.2.40; everything else (norms, biases, modulation tables, input and output layers) is unchanged bf16, and the original checkpoint metadata is kept, plus a relayvsr_quant entry.

• wan_int8_convrot: W8A8 ConvRot (256-wide Hadamard groups, per-channel int8 weights, int8 activations).
• wan_w6a8 / wan_w4a8: comfy-kitchen grouped W6A8 / W4A8 (6- / 4-bit weights, int8 activations).
• flash.safetensors: RelayVSR's Flash model, byte-identical to kopper/RelayVSR (re-hosted so one repo has a full set).

Made from wan.safetensors (sha256 638acb6a...2eb98) with relayvsr/tools/quantize_wan.py in ComfyUI-MAINodes. Checksums: SHA256SUMS. The files load only through the MAINodes RelayVSR worker (the quantized tensors are not in LightX2V's own quant layout).

Credits and license

RelayVSR by kopperx (GitHub: code, paper links, project page, demo, paper, project page, original weights), built on Wan 2.2 and FlashVSR; inference via LightX2V; quantized kernels from comfy-kitchen.

These are derived (quantized) weights, released under Apache-2.0, the license the RelayVSR project states for itself. The original weight repository does not carry its own license field; if its authors publish different terms for the weights, those apply. Quantized by MATLOWAI.