Kandinsky 6.0 Pro 5s — GGUF & W4A8

Low-VRAM quantizations of Kandinsky 6.0 Pro 5s and Kandinsky 6.0 Pro Distilled 5s for ComfyUI.

This repository provides two quantization paths for the full Kandinsky 6 Pro audio/video models:

• W4A8 — native 4-bit weights / 8-bit compute through ComfyUI
• GGUF — selectable K-quants for reduced model size and memory requirements

Both the standard 50-step Pro model and the 10-step PiFlow Distilled Pro model are supported.

Status: Experimental / Not Fully Tested

These are fresh conversions of a newly released architecture. Tested configurations load and run, but broader hardware and workflow testing is still ongoing.

Required ComfyUI Nodes

The required node setup depends on whether you are using W4A8 or GGUF.

W4A8 Users

Use the official Kandinsky 6 ComfyUI nodes:

https://github.com/kandinskylab/kandinsky-6

These provide the Kandinsky sampler, text/image conditioning, video decoding, audio decoding, VAE handling, prompt beautification, and supporting workflow components.

W4A8 uses ComfyUI's native quantization support and does not require ComfyUI-GGUF.

GGUF Users

GGUF currently requires two RebelAI compatibility forks.

1. Kandinsky6_GGUF

https://github.com/RealRebelAI/Kandinsky6_GGUF

This is the Kandinsky-side GGUF-compatible node set.

It contains the Kandinsky FP32 casting fix required to properly dequantize packed GGUF tensors before Kandinsky's FP32 Linear operations.

Without this handling, packed GGUF storage can reach F.linear() directly and produce invalid matrix dimensions.

For GGUF users, install this instead of the standard Kandinsky6 node set.

git clone https://github.com/RealRebelAI/Kandinsky6_GGUF.git

Place it under:

ComfyUI/custom_nodes/

2. ComfyUI-GGUF-Rebel

https://github.com/RealRebelAI/ComfyUI-GGUF-Rebel

This is my ComfyUI-GGUF fork containing compatibility updates required by newer ComfyUI Linear operations.

It supports the newer calling convention including:

input_act
act_weight
act_eps
residual
residual_scale

Install it under:

ComfyUI/custom_nodes/

git clone https://github.com/RealRebelAI/ComfyUI-GGUF-Rebel.git

This fork is based on city96's original ComfyUI-GGUF:

https://github.com/city96/ComfyUI-GGUF

GGUF node setup summary

ComfyUI/custom_nodes/
├── Kandinsky6_GGUF/
└── ComfyUI-GGUF-Rebel/

For the GGUF models in this repository, both are currently required.

Do not install the official Kandinsky6 package alongside Kandinsky6_GGUF, as the Rebel fork is intended to provide the Kandinsky node set for the GGUF workflow.

Available Models

Kandinsky 6.0 Pro 5s

Kandinsky 6.0 Pro Distilled 5s

The distilled checkpoint is not simply the regular model with fewer steps. It uses its own PiFlow inference path and should be run with the distilled settings below.

W4A8

W4A8 stores compatible Linear weights at 4-bit while using an optimized 8-bit compute path.

Look for:

asym_w4a8_int8

in your ComfyUI startup log.

Compared with GGUF, W4A8 avoids repeatedly dequantizing packed GGUF tensors during many Linear operations and can therefore be substantially faster on supported hardware.

Sensitive or incompatible tensors are intentionally retained at higher precision.

Place W4A8 diffusion models in:

ComfyUI/models/diffusion_models/

Example:

ComfyUI/
└── models/
    └── diffusion_models/
        ├── Kandinsky-6.0-Pro-5s-W4A8.safetensors
        └── Kandinsky-6.0-Pro-distill-5s-W4A8.safetensors

GGUF

GGUF provides selectable quantization levels:

Q3_K_S
Q4_K_S

Lower quants reduce file size and memory requirements at the cost of additional quantization error. there are INT8s available on other repos for those with higher compute available.

Place GGUF diffusion models in the model directory used by your ComfyUI-GGUF loader, typically:

ComfyUI/models/unet/

or:

ComfyUI/models/diffusion_models/

depending on your workflow.

Again, the required GGUF node setup is:

https://github.com/RealRebelAI/Kandinsky6_GGUF

plus:

https://github.com/RealRebelAI/ComfyUI-GGUF-Rebel

Required Text Encoders

Kandinsky 6 uses:

Qwen2.5-VL 7B
+
CLIP-L

The optional Qwen prompt beautifier is not the actual Kandinsky conditioning encoder.

A lower-memory W4A8 conversion of the full Qwen2.5-VL encoder is included:

Kandinsky6-Qwen2.5-VL-7B-FULL-W4A8-ALL.safetensors

Place it in:

ComfyUI/models/text_encoders/

This is the complete Qwen2.5-VL model including the visual tower.

CLIP-L is still required separately.

Supporting Models

Kandinsky 6 generates synchronized video + audio, so the diffusion transformer alone is not enough.

Official Kandinsky repository:

https://github.com/kandinskylab/kandinsky-6

Video VAE

Kandinsky uses the HunyuanVideo-based VAE expected by the Kandinsky node set.

Follow the Kandinsky model layout for the video VAE and its supporting files.

Audio VAE + Vocoder

Kandinsky also requires MMAudio and BigVGAN.

MMAudio VAE

Source:

https://huggingface.co/hkchengrex/MMAudio

Required file:

v1-44.pth

Place it here:

ComfyUI/models/audio_vae/v1-44.pth

BigVGAN Vocoder

Source:

https://huggingface.co/nvidia/bigvgan_v2_44khz_128band_512x

Required files:

bigvgan_generator.pt
config.json

Place them here:

ComfyUI/models/audio_vae/bigvgan_vocoder/

Final layout:

ComfyUI/
└── models/
    └── audio_vae/
        ├── v1-44.pth
        └── bigvgan_vocoder/
            ├── bigvgan_generator.pt
            └── config.json

Make sure these files exist before starting a long generation.

Kandinsky can finish the expensive diffusion stage and then fail during audio decoding if the required audio models are missing.

Recommended Settings

Kandinsky 6.0 Pro 5s

Steps: 50
CFG: 5.0
Audio VAE scaling: 0.5302
FPS: 24

Default target geometry:

864 × 480
5 seconds

MagCache can be used with the regular Pro checkpoint.

Kandinsky 6.0 Pro Distilled 5s

Scheduler: PiFlow
Steps: 10
CFG: 1.0
Audio VAE scaling: 0.417
MagCache: OFF
FPS: 24

Do not run the distilled model using the regular Pro 50 steps / CFG 5 workflow.

It is specifically distilled around the 10-step PiFlow inference path.

Low-VRAM Testing

Kandinsky 6 Pro is still a very large model even after quantization.

For initial testing:

240 × 240
21 frames

Regular Pro:

50 steps
CFG 5.0

Distilled Pro:

10 PiFlow steps
CFG 1.0
MagCache OFF

For a slightly larger visual test:

352 × 352
21 frames

Resolutions divisible by 16 are preferred.

Protect Long Generations

For longer runs, placing a Save Latent node directly after the Kandinsky sampler is recommended:

Kandinsky6Sampler
        │
        ├── Save Latent
        │
        └── Decode / Audio / Video Output

If video or audio decoding fails afterward, this can prevent losing the expensive sampled latent.

Full Pro vs Distilled

The distilled checkpoint is the obvious starting point when generation speed matters.

Original Models

Kandinsky 6.0 Pro 5s

https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers

Kandinsky 6.0 Pro Distilled 5s

https://huggingface.co/kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers

Refer to Kandinsky Lab's original repositories for original model licensing, research information, architecture details, and upstream usage guidance.

Credits

Kandinsky Lab
Original Kandinsky 6 models and ComfyUI integration
https://github.com/kandinskylab/kandinsky-6

city96
Original ComfyUI-GGUF
https://github.com/city96/ComfyUI-GGUF

RealRebelAI — Kandinsky6_GGUF
Kandinsky-side GGUF compatibility
https://github.com/RealRebelAI/Kandinsky6_GGUF

RealRebelAI — ComfyUI-GGUF-Rebel
GGUF loader compatibility for current ComfyUI
https://github.com/RealRebelAI/ComfyUI-GGUF-Rebel

Comfy-Org / comfyanonymous
ComfyUI and native quantization infrastructure

Kijai and contributors
W4A8 / ConvRot work used throughout the ComfyUI quantization ecosystem

MMAudio / hkchengrex
https://huggingface.co/hkchengrex/MMAudio

NVIDIA BigVGAN
https://huggingface.co/nvidia/bigvgan_v2_44khz_128band_512x

Quantizations and Kandinsky GGUF compatibility work by RealRebelAI.

Notes

These are quantized derivatives of the original Kandinsky Lab models.

Quantization can change output quality and behavior compared with the original full-precision checkpoints.

Results may vary significantly by GPU, ComfyUI version, attention backend, offloading configuration, resolution, frame count, and quantization level.

Experimental / Not Fully Tested.