Hugging Face has added native support for Nunchaku Lite 4-bit checkpoints to Diffusers, allowing compatible diffusion models to run through standard pipelines without a separate inference engine or local CUDA compilation. The integration is designed to reduce GPU memory use while also accelerating the most computationally demanding parts of image generation.

Developers can load a pre-quantized Nunchaku Lite repository through Diffusers’ existing from_pretrained() interface. The model repository retains the normal Diffusers structure, while a quantization configuration tells the library which linear layers to replace with SVDQuant or AWQ runtime layers before loading the checkpoint. CUDA kernels are downloaded from the Hugging Face Hub through the kernels package when first required.

Nunchaku Lite uses two kernel families. svdq_w4a4 runs major attention and multilayer perceptron projections with 4-bit weights and activations, paired with a small 16-bit low-rank correction. The awq_w4a16 path uses 4-bit weights and 16-bit activations for memory-bound or precision-sensitive normalization and modulation projections.

In a benchmark reported by Hugging Face, a quantized ERNIE-Image-Turbo pipeline generated a 1,024-by-1,024 image in about 1.7 seconds on an RTX 5090, with peak GPU memory use of about 12 GB. The article compared that result with roughly 24 GB for the BF16 pipeline. These figures are Hugging Face’s reported test results, not an independent benchmark across multiple systems.

Lower Memory Without Losing Speed

Modern text-to-image diffusion transformers can require 20 GB to 30 GB of VRAM when loaded in BF16 precision, leaving many models beyond the capacity of consumer graphics cards. Existing weight-only quantization methods can cut memory requirements, but they usually restore weights to higher precision during computation, which may provide little or no latency improvement.

Nunchaku’s W4A4 approach addresses both sides of that constraint by performing core transformer calculations with low-precision weights and activations. Hugging Face says the Lite integration provides about a 30% speed increase while retaining the memory reduction associated with Nunchaku checkpoints. Easier loading could also broaden testing and deployment because teams can keep using standard Diffusers pipelines and repositories.

SVDQuant Moves Into Standard Pipelines

Nunchaku is based on SVDQuant, a quantization method created for diffusion transformers whose weights and activations contain large outliers. The method moves activation outliers into the weights, represents the hardest portion of each weight matrix through a small 16-bit low-rank branch, and quantizes the remaining residual to four bits.

The original Nunchaku inference engine uses architecture-specific features such as fused attention projections and fused MLP kernels. Those optimizations can deliver higher performance, but each new model family may require dedicated engineering. Nunchaku Lite instead patches compatible linear modules inside a stock Diffusers model, trading some speed for broader and simpler integration.

The release also points developers to the companion diffuse-compressor toolkit, which can quantize additional architectures and package the results as regular Diffusers repositories. Diffusers already supports other quantization backends, including bitsandbytes, GGUF, torchao and Quanto, but most of those options primarily reduce weight storage.

“No custom pipeline class or separate inference engine is needed, and there is nothing to compile locally.”

— Hugging Face’s technical announcement

Performance Varies Across GPU Generations

It is not yet clear how closely the reported speed and memory results will carry across other diffusion architectures, image sizes, sampling settings and GPUs. The supplied material does not provide independent benchmark results, a full model-by-model comparison or detailed image-quality measurements for every available checkpoint.

Hardware support also differs by format. NVFP4 checkpoints require NVIDIA Blackwell hardware, including RTX 50-series, RTX PRO 6000 and B200 GPUs. Users of earlier GPU generations must use INT4 variants, and the source does not give equivalent performance figures for every supported device.

More Checkpoints and Architectures

Developers can now test available Nunchaku Lite repositories through recent Diffusers releases and compare them with BF16 or other quantized versions on their own hardware. The next measure of adoption will be the number of ready-to-use checkpoints published for additional architectures and the quality of real-world benchmarks across GPUs.

Hugging Face’s diffuse-compressor workflow also creates a route for model maintainers to quantize and publish their own compatible repositories. Future work is likely to focus on wider architecture coverage, kernel support and narrowing the performance gap between the flexible Lite implementation and the architecture-specific Nunchaku engine.

Key Questions

What changed in Diffusers?

Diffusers can now load Nunchaku Lite checkpoints directly through its normal model-loading interface. Compatible pipelines no longer require a custom pipeline class or a separate Nunchaku runtime.

How does Nunchaku Lite reduce memory use?

Its main transformer layers use 4-bit weights and activations, while a small 16-bit low-rank correction handles difficult outlier information. Other sensitive layers can use AWQ with 4-bit weights and 16-bit activations.

Does 4-bit inference make generation faster?

Hugging Face reports about a 30% speed increase for Nunchaku Lite, but performance will vary with the model, GPU, kernel format and generation settings. The original Nunchaku engine can remain faster because it uses model-specific fused operations.

Which GPUs support the new checkpoints?

NVFP4 requires NVIDIA Blackwell GPUs, including RTX 50-series, RTX PRO 6000 and B200 hardware. INT4 checkpoints are the stated option for earlier NVIDIA GPU generations.

Can developers quantize their own diffusion models?

Hugging Face says the companion diffuse-compressor toolkit can quantize new architectures and publish them as standard Diffusers repositories. Actual compatibility and performance depend on the architecture and available kernels.

Source: Hugging Face