This repository contains a compact OrbitQuant transformer-component artifact for the source Diffusers model listed above. It is intended to be loaded into the original pipeline, not used as a standalone Diffusers pipeline repository.

OrbitQuant is a calibration-free post-training quantization method for image and video diffusion transformers. This artifact keeps the text encoders, VAE, embeddings, timestep MLP, and final heads in the source precision by default and replaces the transformer linear projections with OrbitQuant modules.

Usage

Install OrbitQuant and the Hugging Face runtime dependencies:

pip install "orbitquant[hf,kernels]>=0.6.0"

The optimized native kernel package is provisioned automatically at first model load: OrbitQuant derives the runtime variant (torch minor and CUDA version for CUDA, the torch stable ABI for CPU, plus OS and architecture), downloads the matching prebuilt wheel from the OrbitQuant kernels release with checksum verification, and caches it under ~/.cache/orbitquant/kernels. Without a matching variant, CUDA inference falls back to the Triton packed path. Run orbitquant kernels-install to provision explicitly. For ComfyUI, the ComfyUI-OrbitQuant node pack provisions the same kernels from its install hook.

Download this model repository as an OrbitQuant artifact, then load the source Diffusers pipeline with the quantized component patched in:

python

import torch
from diffusers.utils import export_to_video
from huggingface_hub import snapshot_download
from orbitquant import load_quantized_pipeline_from_artifact

artifact_id = "WaveCut/Wan2.1-T2V-1.3B-Diffusers-OrbitQuant-W4A4"

artifact_dir = snapshot_download(artifact_id, repo_type="model")
pipe = load_quantized_pipeline_from_artifact(
    artifact_dir,
    torch_dtype=torch.bfloat16,
    runtime_mode="auto_fused",
)
pipe.enable_model_cpu_offload(device="cuda")

frames = pipe(
    prompt="A cinematic shot of a small robot walking through a neon market",
    height=480,
    width=832,
    num_frames=81,
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]
export_to_video(frames, "wan-orbitquant.mp4", fps=16)

Convert the source checkpoint on load

For a safetensors source checkpoint, OrbitQuant can row-stream the denoiser into packed weights through the normal Diffusers loader. Use sequential offload by replacing the final call with pipe.enable_sequential_cpu_offload().

python

import torch
import orbitquant
from diffusers import DiffusionPipeline
from orbitquant import (
    OrbitQuantConfig,
    build_diffusers_pipeline_quantization_config,
)

qconfig = build_diffusers_pipeline_quantization_config(
    OrbitQuantConfig(target_policy="auto"),
    components="transformer",
)
pipe = DiffusionPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    quantization_config=qconfig,
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()

runtime_mode="auto_fused" is the default optimized runtime. On CUDA, the kernels extra provides the Triton packed fallback; a locally built native CUDA package is preferred automatically when installed. On MPS, build and install the native Metal package from the OrbitQuant source tree. See the OrbitQuant runtime instructions. Use runtime_mode="dequant_bf16" only as an explicit compatibility/debug reference path.

Native Settings

Use these settings when comparing this artifact against the BF16 source model or the visual assets below:

Setting	Value
Pipeline	`WanPipeline`
Resolution	`832x480`
Frames	`81`
Inference steps	`50`
Guidance scale	`5.0`
Export FPS	`16`
Output	video
Scope	paper video target

Validation Status

Native BF16-vs-OrbitQuant comparison: included when the visual matrix below is present.
Release-grade VBench metrics: not included in this artifact.
The model card reports artifact-level validation status only.

Native Validation Evidence

The compact benchmark summary records native BF16-vs-OrbitQuant evidence for the comparison matrix below. Detailed per-sample generation records are retained outside this compact artifact.

Evidence	Value
Comparison matrix	`assets/video_generation_comparison_matrix.webp`
Paired prompt/seed count	`1`
BF16 source generated samples	`1`
BF16 source generated frames	`81`
BF16 source nonempty outputs	`1`
OrbitQuant generated samples	`1`
OrbitQuant generated frames	`81`
OrbitQuant nonempty outputs	`1`

Quantization

Method: orbitquant
Bits: W4A4
Runtime mode: auto_fused
Activation kernel backend: auto
Activation normalization epsilon: 1e-10
Quantization device: cuda
Weight quantization backend: triton_cuda
Target policy: wan
AdaLN policy: int4_rtn_group64_bf16_activation
AdaLN group size: 64
AdaLN group-size note: paper default.
Rotation: rpbh
Rotation seed: 0
Block size: paper
Block size policy: largest_power_of_two_dividing_dim
Codebook: lloyd_max
Codebook version: 2
Quantized transformer modules: 300
AdaLN INT4 modules: 0
Skipped modules: 6
Calibration data: none
Text encoders and VAE: left in source precision by default

Visual Comparison

The following assets are stored in this artifact and compare the BF16 base generation against the OrbitQuant generation with the same prompt and seed.

assets/video_generation_comparison_matrix.webp

Source

Model: Wan-AI/Wan2.1-T2V-1.3B-Diffusers
Revision: 0fad780a534b6463e45facd96134c9f345acfa5b
Source license: apache-2.0
OrbitQuant paper: https://arxiv.org/abs/2607.02461

Artifact Files

model.safetensors: packed OrbitQuant/INT4 module tensors.
quantization_config.json: serialized OrbitQuant runtime settings.
orbitquant_manifest.json: source provenance, policies, module lists, and checksums.
orbitquant_codebooks.safetensors: Lloyd-Max codebooks.
orbitquant_rotations.safetensors: deterministic RPBH rotation metadata.

Limitations

This is a transformer-component artifact; load it into the source pipeline as shown above.
Guaranteed on-the-fly bounded-memory conversion requires a safetensors source checkpoint. Unknown architectures have structural coverage only and require policy inspection plus quality validation.
CUDA and MPS auto_fused inference requires a packed matmul kernel and fails loudly when the required kernel is unavailable. The explicit dequant_bf16 reference mode materializes dequantized weights before BF16 matmul.
Quality depends on the source model and bit setting. Very low-bit settings can degrade prompt following or visual detail.