Image and video generation

Kandinsky 5.0 self-hosted: starts at 12GB VRAM, the 19B video model goes straight to H100

Kandinsky Lab shipped text-to-image, image editing, text-to-video and image-to-video in one November 2025 release, weights under MIT. This page works out the real VRAM budget for every variant, which card to rent, and what a clip actually costs.

Kandinsky · self-hosted

Kandinsky 5.0 comes from Kandinsky Lab (the generative team behind Sber AI and AIRI) and is the line that is actually maintained today. Code lives at github.com/kandinskylab/kandinsky-5, weights under the kandinskylab org on Hugging Face, model cards marked MIT. Three product lines: Image Lite at 6B for text-to-image and editing, Video Lite at 2B for 5s and 10s clips at 24fps, and Video Pro at 19B for 1280x720 text-to-video and image-to-video. Architecture is Flow Matching over a CrossDiT backbone — 50 blocks for Image Lite, 32 for Video Lite, 60 for Video Pro. Images are encoded with the FLUX.1-dev VAE, video with the HunyuanVideo 3D VAE. The tech report puts training scale at 500M+ images, 250M+ video scenes and roughly 150M curated editing pairs.

What decides your card size is not the 6B DiT — it is the text stack bolted in front of it. Kandinsky 5.0 uses Qwen2.5-VL 7B as its primary encoder (embedding size 3584) plus CLIP ViT-L/14. At 2 bytes per parameter in bf16: the 6B DiT is about 12GB, Qwen2.5-VL 7B about 15GB, CLIP and VAE roughly 1GB more — 28GB resident before you generate anything, which a 24GB card cannot hold. The repo answers with three switches: `--offload` swaps idle components to host RAM, `--qwen_quantization` drops the text encoder to NF4, and `--attention_engine` picks between Flash Attention 3, FA2, SageAttention and SDPA. The README states plainly that generation works on 12GB cards once offload is on. On the video side, NABLA sparse attention cuts training and inference time by roughly 2.7x at a 90% sparsity ratio.

So the rental logic is blunt. Evaluating the model or batching 1024x1024 images: RTX 3090 24GB at $0.193/GPU-hr or RTX 4090 24GB at $0.540/GPU-hr with offload plus NF4 is enough. Keeping the whole stack resident with no swapping, or training a LoRA: RTX A6000 48GB at $0.817/GPU-hr. Running the 19B Video Pro for HD clips: only the 80GB class is comfortable — A100 SXM4 80GB at $1.088/GPU-hr, or H100 SXM 80GB at $3.582/GPU-hr when the deadline matters, which is also the only place Flash Attention 3 runs at all. One clarification while you are choosing: if the tutorial you found is the Kandinsky 2.1 / 2.2 prior-plus-decoder pipeline, or Kandinsky 3.0 with its FLAN-UL2 encoder and Sber-MoVQGAN decoder, those still exist in diffusers as KandinskyV22Pipeline and Kandinsky3Pipeline, but 5.0 supersedes both and new projects should not start there. NexGPU has 1,175 verified rentable nodes and 2,498 GPUs across 51 countries and regions, metered per second and priced per hour, with no minimum, no setup fee and no quota request.

01 —

Kandinsky 5.0 variants and their VRAM math

Weight footprints computed at 2 bytes per parameter in bf16; latencies are the authors' measurements on H100 80GB (CUDA 12.8.1, PyTorch 2.8)

Version	Parameters	VRAM	Context	Notes
Kandinsky-5.0-T2I-Lite	6B (CrossDiT, 50 blocks)	DiT bf16 ~12GB; ~28GB fully resident with Qwen2.5-VL 7B (~15GB); repo says 12GB cards work with --offload	1024x1024 / 1280x768, 100 NFE	The main text-to-image model. Its stated differentiators are legible text rendering in-frame and Russian concept understanding. 13s per image on H100.
Kandinsky-5.0-I2I-Lite	6B	Same class as T2I Lite: ~12GB DiT plus ~16GB of encoders	1K resolution, image input plus text instruction	Instruction-driven editing and text-guided inpainting, trained on roughly 150M editing pairs. Ships as both sft and pretrain checkpoints.
Kandinsky-5.0-T2V-Lite-sft-5s / -10s	2B (CrossDiT, 32 blocks)	DiT bf16 ~4GB, but Qwen2.5-VL 7B still dominates the pipeline; 12GB class is reachable with offload	768x512, 5s or 10s at 24fps	The workhorse video model. 139s for a 5s clip on H100. The 10s variant is SD resolution only — do not expect HD from it.
Kandinsky-5.0-T2V-Lite-distilled16steps-5s	2B	Same as Lite, with NFE cut from 100 to 16	768x512, 5s at 24fps	Product of CFG distillation, TSCD and adversarial post-training. 35s per clip on H100 — the one to use for interactive previews and bulk shortlisting.
Kandinsky-5.0-T2V-Pro-sft-5s / I2V-Pro-sft-5s	19B (CrossDiT, 60 blocks)	DiT bf16 ~38GB; tight even on 80GB once encoders and activations land. Repo ships multi-GPU distributed inference	1280x720 HD at 5s; the 10s variant is SD	The quality tier. The README records a #1 open-source text-to-video placing on LMArena in December 2025. A 5s HD clip takes 1241s on H100.
Kandinsky 2.1 / 2.2 / 3.0 (superseded)	2.2 is a two-stage prior + decoder; 3.0 is a 3B UNet with FLAN-UL2	3.0 blows past 24GB in practice because of the FLAN-UL2 encoder and needs sharded loading	512 / 768 class	KandinskyV22Pipeline and Kandinsky3Pipeline still exist in diffusers, but new work should target 5.0 directly.

02 —

Pick a card by scenario: real NexGPU models and rates

Matched honestly against the VRAM math above

Running T2I Lite for generation and evaluation, accepting offload plus an NF4 text encoder
RTX 4090 24GB$0.540/GPU-hr
24GB holds the 12GB DiT with room for activations while the encoder swaps in and out under NF4 — the steadiest single-card image tier.
Long batch runs where cost matters more than per-image latency
RTX 3090 24GB$0.193/GPU-hr
Same 24GB for under twenty cents an hour, which usually beats H100 on cost per finished image in batch workloads.
Keeping the full stack resident with no offload, or training a rank-16 LoRA
RTX A6000 48GB$0.817/GPU-hr
48GB fits the 6B DiT and a bf16 Qwen2.5-VL simultaneously, removing swap overhead and letting LoRA training skip aggressive int8 quantization.
Video Pro 19B rendering 1280x720 HD clips
H100 SXM 80GB$3.582/GPU-hr
38GB of weights plus video activations needs the 80GB class, and Flash Attention 3 requires Hopper anyway. On a tighter budget, A100 SXM4 80GB at $1.088/GPU-hr runs the same job on FA2.

03 —

Get Kandinsky 5.0 running on NexGPU

Four steps from boot to first image; picking the PyTorch or ComfyUI image from the 2,000+ prebuilts skips environment setup entirely

01
Boot an instance and clone the repo
Pick a 24GB-or-larger card in the console, boot the PyTorch prebuilt image, and connect over SSH or Jupyter. Flash Attention 3 in the requirements only matters on Hopper — on Ada or Ampere install FA2 or fall back to SDPA.
```
git clone https://github.com/kandinskylab/kandinsky-5.git && cd kandinsky-5 && pip install -r requirements.txt
```
02
Take the diffusers shortcut to a first image
Kandinsky 5.0 landed in diffusers, so T2I Lite loads in a single from_pretrained call. The first run pulls the 6B DiT plus Qwen2.5-VL 7B — close to 28GB of weights — so check disk and bandwidth before you start.
```
python -c "import torch;from diffusers import DiffusionPipeline;p=DiffusionPipeline.from_pretrained('kandinskylab/Kandinsky-5.0-T2I-Lite',dtype=torch.bfloat16,device_map='cuda');p('a cat in a red hat, neon sign reads HELLO').images[0].save('out.png')"
```
03
Switch to the official CLI and turn on every memory switch
For video, or on a 12-16GB card, use the repo's test.py. `--offload` swaps idle components out, `--qwen_quantization` drops the text encoder to NF4, `--magcache` accelerates sampling, and `--attention_engine` selects the backend for your card. Note that Qwen2.5-VL's text context here is only 256 tokens, so an over-long prompt gets truncated — put the decisive description first.
```
python test.py --config ./configs/k5_lite_t2v_5s_sft_sd.yaml --prompt "A dog in a red hat" --offload --qwen_quantization --attention_engine=flash_attention_2
```
04
Wire up ComfyUI workflows, or move to fine-tuning
The repo ships ComfyUI custom nodes and four workflows (T2V, I2V, T2I, I2I). It needs two VAEs — flux_vae for the image branch and hunyuan_vae for video — placed in their respective folders under ComfyUI/models/vae/; misplacing them is a load failure, not a warning. For style LoRAs, SimpleTuner puts 24GB as the comfortable floor at rank 16 with full gradient checkpointing, and 16GB as possible only with an int8-quantized base and block-level offload. Leave the text encoder unquantized — Qwen2.5-VL is quantization-sensitive.
```
python test.py --config ./configs/k5_lite_t2i_sft_hd.yaml --prompt "A cat in a red hat with a label 'HELLO'" --offload
```

What one image and one clip actually cost

The authors' H100 80GB measurements: 13s for a 1024x1024 image from T2I Lite, 35s for a 5s clip from the distilled Video Lite, 1241s for a 5s HD clip from Video Pro. Multiply straight through by NexGPU's H100 SXM 80GB rate of $3.582/GPU-hr. One image = 13 / 3600 x 3.582 = about $0.0129, so 100 images run about $1.29. One distilled clip = 35 / 3600 x 3.582 = about $0.035. One Video Pro 5s HD clip = 1241 / 3600 x 3.582 = about $1.24. There are no official latencies for consumer cards, but the arithmetic is yours to run: RTX 3090 24GB is $0.193/GPU-hr, so even if it were 10x slower than H100 and took 130s per image, that is 130 / 3600 x 0.193 = about $0.0070 — roughly half the H100 cost. Batch generation and deadline generation are two completely different bills. Storage is separate: keeping the full T2I Lite stack resident (12GB DiT + ~15GB Qwen2.5-VL + ~1GB CLIP and VAE, about 28GB) costs roughly 28 x 0.414 = $11.6 per month at the $0.414/GB-month median. Compute metering stops the moment the instance stops; storage keeps billing until you destroy it.

04 —

FAQ

What is the minimum VRAM to self-host Kandinsky 5.0?

The official README states generation works on 12GB cards with offload enabled — but that is bought by rotating components through VRAM, and it costs you speed. To keep the 6B DiT (about 12GB in bf16) resident with headroom for activations, 24GB is the practical floor; to also keep a bf16 Qwen2.5-VL 7B resident without swapping, you want 48GB. NexGPU rents all three tiers by the second: RTX 3090 24GB at $0.193, RTX 4090 24GB at $0.540, RTX A6000 48GB at $0.817. Prove it out on the cheap card first, then decide whether to scale up.

What license is Kandinsky 5.0 under, and can I use it commercially?

The kandinskylab model cards on Hugging Face and the GitHub repo are marked MIT, which is about as permissive as it gets — no open-source obstacle to commercial use. What matters is that this is a pipeline, not a single model: the Qwen2.5-VL text encoder, the FLUX.1-dev image VAE and the HunyuanVideo video VAE each carry their own terms, so read all three before shipping. Once you have cleared that, spin up your own NexGPU instance and run inference privately — your data never leaves your machine.

Are the Kandinsky 2.2 tutorials I found still usable?

They still run, but do not start new work there. 2.1 and 2.2 use a two-stage prior-plus-decoder design, and 3.0 swapped in a FLAN-UL2 text encoder with a Sber-MoVQGAN decoder; both are superseded by 5.0's Flow Matching and CrossDiT architecture, and diffusers keeps KandinskyV22Pipeline and Kandinsky3Pipeline mainly for backward compatibility. If you want to compare generations across generations, spin up two per-second-billed NexGPU instances and run them side by side for an hour — the whole comparison costs less than a coffee.

Why does my long prompt seem to have no effect?

The primary text encoder, Qwen2.5-VL, is configured here with a maximum text context of 256 tokens, so anything past that is truncated and the detail you wrote at the end never reaches the model. Put subject, composition and style up front and modifiers after. The other common trap is guidance: push past 7.0 and images tend to over-saturate and look burnt, while the recommended validation default is 5.0. Parameters like these want a sweep, and sweeping a grid on NexGPU's per-second billing is far cheaper than burning a night on one local card.

Is a single 80GB card enough for the 19B Video Pro?

A single 5s HD clip will run — about 38GB of bf16 weights leaves the rest for video latents and attention activations — but it is tight, which is why the repo ships multi-GPU distributed inference. The reference figure is 1241s for a 5s HD clip on H100 80GB. NexGPU lists H100 SXM 80GB at $3.582/GPU-hr and A100 SXM4 80GB at $1.088/GPU-hr, with up to 14 GPUs per node and 2,152GB max node VRAM, so scaling to multi-GPU does not mean changing platform.

What do I need to train a style LoRA on Kandinsky 5.0?

Using SimpleTuner's Kandinsky 5 image flow as the reference: rank 16 with full gradient checkpointing makes 24GB (3090 / 4090) the comfortable floor, while 16GB only works with an int8-quantized base model plus block-level offload, and you want 64GB of host RAM. Two details worth memorizing — do not quantize the text encoder, because Qwen2.5-VL is quantization-sensitive, and block-level group offload cannot be combined with enable_model_cpu_offload. An RTX A6000 48GB on NexGPU is $0.817/GPU-hr, so a four-hour run is 4 x 0.817 = about $3.27, and billing stops the second you stop the instance.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.