How much VRAM does LoRA training need?
What the trainers themselves say — ai-toolkit, kohya sd-scripts and musubi-tuner, OneTrainer, SimpleTuner, diffusion-pipe, fluxgym — for each model, with the settings behind every number.
Chroma1-HD from 8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 8 GB | stated minimum | Rank-16 LoRA, NF4 base (int4 ~11 GB, int8 ~16 GB, unquantised ~28 GB); realistic GPU minimum RTX 3090/4090 class “~8 GB VRAM with NF4 + bf16” | github.com → |
| OneTrainer | 8 GB | example run | Official preset for lodestones/Chroma1-HD: 512px, batch 2, transformer fp8, TE fp8, layer offload fraction 0.6 “See presets for VRAM settings, with 8GB, 16GB and 24GB presets being created for both Finetune and Lora” | github.com → |
| ai-toolkit | 24 GB | example run | Official example config (points to lodestones/Chroma, not HD): rank 16, batch 1, 512/768/1024, gradient checkpointing, 8-bit quantized base “train_lora_chroma_24gb.yaml” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
FLUX.1 [dev] from 8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| sd-scripts | 8 GB | stated minimum | --fp8_base, --blocks_to_swap 28, fp8 T5XXL recommended; table also: 24GB batch 2, 16GB batch 1 + swap, 12GB swap 16 + AdamW8bit, 10GB swap 22 “8GB VRAM: Use --blocks_to_swap 28, recommend fp8 format for T5XXL” | github.com → |
| SimpleTuner | 10 GB | stated minimum | Rank-16 LoRA; NF4 base ~9 GB (int8 ~18 GB, int4 ~13 GB, unquantised ~30 GB); lowest config 512px, batch 1, Lion8bit paged; 1024px needs >=12 GB. Guide example uses FLUX.1 Krea “the absolute minimum is a single 3080 10G” | github.com → |
| fluxgym | 12 GB | stated minimum | 12G preset: kohya sd-scripts backend, --fp8_base, Adafactor, --split_mode, train_blocks=single, gradient checkpointing, cached TE outputs; default 512px, rank 4 “Dead simple web UI for training FLUX LoRA with LOW VRAM (12GB/16GB/20GB) support.” | github.com → |
| OneTrainer | 12 GB | stated minimum | Wiki Flux page; no specific settings given (NF4/fp8 mentioned nearby); 8GB possible with GGUF “It is possible to train a Flux Lora on a GPU with 12GB of VRAM.” | github.com → |
| ai-toolkit | 24 GB | stated minimum | Historical README requirement (removed from README on 2026-03-31 in commit ad474e3); 8-bit quantized base, low_vram flag if GPU drives monitors “You currently need a GPU with at least 24GB of VRAM to train FLUX.1.” | github.com → |
| ai-toolkit | 24 GB | example run | Current official example config: rank 16, batch 1, 512/768/1024 buckets, gradient checkpointing, quantize: true (8-bit); README still points to this file “Copy the example config file located at config/examples/train_lora_flux_24gb.yaml” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
FLUX.2 [klein] 4B from 8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 8 GB | stated minimum | int8 base (~12 GB in bf16); 32GB+ system RAM; single 16GB GPU recommended “klein-4b: ~12GB: ~8GB: 32GB+” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
FLUX.2 [klein] 9B from 8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| OneTrainer | 8 GB | example run | Official preset for klein-base-9B: 512px, batch 2, transformer INT_W8A8, TE fp8, layer offload fraction 0.7, torch.compile on “#flux2 LoRA 8GB.json” | github.com → |
| SimpleTuner | 14 GB | stated minimum | int8 base (~22 GB in bf16); 64GB+ system RAM; single 24GB GPU recommended “klein-9b: ~22GB: ~14GB: 64GB+” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
HiDream-I1 (Dev) from 20 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 20 GB | stated minimum | Lowest config: int8-quanto or nf4-bnb base, 1024px, batch 1, Lion8bit paged, gradient checkpointing, tiny LoRA (rank 1) or LoKr factor 25; guide also says 24G is likely minimum without offload “The lowest VRAM HiDream configuration is about 20-22G:” | github.com → |
| diffusion-pipe | 24 GB | stated minimum | Needs block swapping or nf4 transformer (possible quality loss); 48GB (or 2x24GB pipeline parallel) without block swap “With enough block swapping you can train on a single 24GB GPU.” | github.com → |
| ai-toolkit | 35.2 GB | example run | Official example config (file named 48): base + TEs quantized, rank 32, batch 1, gradient checkpointing; not possible on single 24GB card per config “The settings here will take ~35.2GB of vram to train.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
HunyuanVideo (13B, original) from 24 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| musubi-tuner | 24 GB | stated minimum | Without --fp8_base (bf16 DiT); use --blocks_to_swap as needed; fp8_base lowers this but no figure given “If --fp8_base is not specified, 24GB or more VRAM is recommended.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
HunyuanVideo 1.5 from 24 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 24 GB | stated minimum | Rank-16 LoRA, full gradient checkpointing, 480p; 720p or larger batches: 48-80GB “Minimum: 24GB-32GB VRAM is comfortable for a Rank-16 LoRA with full gradient checkpointing at 480p.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Krea 2 (Turbo) from 16 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| OneTrainer | 16 GB | example run | Official preset (lowest Krea 2 preset): 512px, batch 2, transformer INT_W8A8, TE fp8, layer offload fraction 0.3, torch.compile “#krea2 LoRA 16GB.json” | github.com → |
| SimpleTuner | 18.1 GB | example run | Measured on H100 80GB: int8-torchao, 512px, batch 1, fused QKV, gradient checkpointing, compile off (1024px batch 1: 20.35 GiB; bf16 512px: 31.10 GiB) “int8-torchao: 512: 1: 0.535: 18.10 GiB” | github.com → |
| SimpleTuner | 24 GB | stated minimum | Reduced resolution or quantised; 48GB+ recommended for comfortable 512px “the realistic minimum: an NVIDIA GPU with at least 24GB VRAM for reduced-resolution or quantised experiments” | github.com → |
| diffusion-pipe | 24 GB | example run | fp8 diffusion model, rank 32, 512px “This configuration can train a rank 32 LoRA at 512 resolution with 24GB VRAM.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
LTX-2 (19B) from 13 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 13 GB | example run | Field report: RamTorch offload incl. text encoder, 480p, 17 frames, batch 2, AMD 7900XTX; int8 no offload ~29-30 GB; bf16 no offload ~48 GB “RamTorch (incl. text encoder): ~13 GB VRAM used on an AMD 7900XTX.” | github.com → |
| diffusion-pipe | 24 GB | stated minimum | Only LTX-2.3 supported (T2I/T2V, no audio); blocks_to_swap 46 (max), low resolution, short video, low rank; 'might barely fit' “with that, it might barely fit in 24GB VRAM if the resolution, video length, and LoRA rank are all low enough.” | github.com → |
| LTX-2 trainer (official, Lightricks) | 32 GB | stated minimum | t2v_lora_low_vram.yaml: INT8 (quanto) base, 8-bit text encoder, AdamW8bit, rank 16, batch 1, gradient checkpointing; 80GB+ for standard config “For GPUs with 32GB VRAM (e.g., RTX 5090), use the low VRAM config” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Qwen-Image from 12 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| musubi-tuner | 12 GB | stated minimum | 1024x1024, batch 1, bf16 mixed precision, gradient checkpointing, xformers, --fp8_base --fp8_scaled + --blocks_to_swap 45; 64GB RAM recommended. Table: none 42GB, fp8 30GB, +swap16 24GB “+ --blocks_to_swap 45|12GB” | github.com → |
| OneTrainer | 16 GB | example run | Official preset: 512px, batch 2, transformer fp8, TE fp8, layer offload fraction 0.5 (24GB preset uses 0.1) “#qwen LoRA 16GB.json” | github.com → |
| ai-toolkit | 24 GB | example run | Official example config: 3-bit (uint3) base with accuracy recovery adapter, fp8 TE, cached text embeddings, low_vram, rank 16, batch 1, gradient checkpointing “# 3bit is required for 24GB” | github.com → |
| diffusion-pipe | 24 GB | stated minimum | Example config: fp8 transformer, blocks_to_swap 8, rank 32, activation checkpointing, 640px dataset suggested, expandable_segments “You will need block swapping. See the [example 24GB VRAM config]” | github.com → |
| SimpleTuner | 24 GB | stated minimum | int2-quanto or nf4-bnb base, batch 1, gradient checkpointing, LoRA rank 1-8, 512-768px start; 40GB+ strongly recommended “A 24GB GPU is the absolute minimum, and even then you'll need extensive quantization and careful configuration.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Qwen-Image-Edit (2511) from 24 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 24 GB | stated minimum | int8/nf4 quantised base; validation resolution must be reduced (e.g. 768x768) on 24GB “GPU VRAM : 24 G minimum (with int8/nf4 quantisation) • 40 G+ strongly recommended” | github.com → |
| ai-toolkit | 32 GB | example run | Official example config: 3-bit (uint3) base with accuracy recovery adapter, fp8 TE, cached text embeddings, low_vram, rank 16, batch 1; same for Edit-2509 “# 3bit is required for 32GB” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
SDXL 1.0 from 5.8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| OneTrainer | 5.8 GB | example run | Community test (efhosci): fp8 weights, 1024px, batch 1, latent caching, SDP, gradient checkpointing; ~8.6 GB with fp16 weights “with resolution set to 1024 the VRAM usage peaked around 5.8 GB” | github.com → |
| sd-scripts | 8 GB | stated minimum | 1024px default; U-Net only, gradient checkpointing, cached TE outputs + latents, 8-bit optimizer or Adafactor, dim 4-8 for 8GB; 10GB recommended “The LoRA training can be done with 8GB GPU memory (10GB recommended).” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Stable Diffusion 1.5 from 2.8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| OneTrainer | 2.8 GB | example run | Community low-VRAM config (efhosci) on OneTrainer wiki: fp8 weights, batch 1, 512px, rank 16, SDP attention, gradient checkpointing, latent caching, AdamW8bit “With all above optimizations, the program maxed out around 2.8 GB while running.” | github.com → |
| OneTrainer | 6 GB | stated minimum | LoRA or embedding at 512px; general FAQ answer, no other settings given “SD1.5 LoRA or embedding with 512 resolution can be trained with just 6Gb.” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Stable Diffusion 3.5 Large from 13.9 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 13.9 GB | example run | int2-quanto base, rank-1 LoRA (config comment in SD3 guide, which targets SD 3.5 Large) “int2-quanto is pretty extreme and gets the whole rank-1 LoRA down to about 13.9GB VRAM.” | github.com → |
| ai-toolkit | 24 GB | example run | Official example config: rank 16, 1024px, batch 1, gradient checkpointing, 8-bit quantized base “train_lora_sd35_large_24gb.yaml” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Wan 2.1 T2V 1.3B from 12 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 12 GB | example run | 832x480, rank-16 LoRA, batch size 4 (measured figure, 'a bit more than 12G') “Rank-16 LoRA uses a bit more than 12G (batch size 4)” | github.com → |
| ai-toolkit | 24 GB | example run | Official example config named for 24GB: ~480p (632), 40 frames, rank 32, batch 1, quantized TE; filename is the only VRAM figure “train_lora_wan21_1b_24gb.yaml” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Wan 2.1 T2V 14B from 24 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| diffusion-pipe | 24 GB | example run | Example config: 512x512x81 videos, fp8 transformer, blocks_to_swap 32, rank 32, AdamW8bitKahan, unsloth activation checkpointing “train Wan 14b t2v on 512x512x81 sized videos (or varying aspect ratios of the same size), with 24GB VRAM.” | github.com → |
| ai-toolkit | 24 GB | example run | Official example config: ~480p (632), 40 frames, rank 32, batch 1, quantized base + TE, low_vram, text encoder unloaded (single trigger prompt only; captions need more VRAM) “This config should work on 24GB GPUs.” | github.com → |
| SimpleTuner | 24 GB | stated minimum | 832x480; no further settings given ('fiddle with the settings') “It'll fit in 24G, but you'll have to fiddle with the settings a bit.” | github.com → |
| musubi-tuner | 24 GB | stated minimum | 720x1280 images (not video), fp8 and block swap “training with 720x1280 images with 24GB VRAM” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Wan 2.2 I2V A14B from 16 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 16 GB | stated minimum | General Wan guide statement listed right after the Wan 2.2 I2V section; no settings given “a realistic minimum is 16GB or, a single 3090 or V100 GPU” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Wan 2.2 T2V A14B from 24 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| ai-toolkit | 24 GB | example run | Official example config (image training, num_frames 1): 4-bit (uint4) base with accuracy recovery adapter, fp8 TE, cached text embeddings, low_vram, rank 32, 512-1024px “# required for 24GB cards. You must do either unload_text_encoder or cache_text_embeddings but not both” | github.com → |
| musubi-tuner | 24 GB | stated minimum | Same Wan doc statement as Wan 2.1 (Wan 2.2 14B supported): 720x1280 images, fp8 + block swap “training with 720x1280 images with 24GB VRAM” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Z-Image (base) from 8 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| OneTrainer | 8 GB | example run | Official preset for Tongyi-MAI/Z-Image: 512px, batch 2, transformer fp8, TE fp8, layer offload fraction 0.6, torch.compile; De-Turbo 8GB preset also exists “#z-image LoRA 8GB.json” | github.com → |
| SimpleTuner | 10 GB | stated minimum | Same guide ('Z-Image [base / turbo]'): rank-16 LoRA with NF4 base ~10-12 GB, 512px, batch 1 “~10–12G VRAM when quantising to NF4 + bf16 base/LoRA weights” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →
Z-Image Turbo from 10 GB
| Trainer | VRAM | Type | Settings and quote | Source |
|---|---|---|---|---|
| SimpleTuner | 10 GB | stated minimum | Guide covers base + turbo (example trains Turbo): NF4/int8 base, 512px, batch 1, Lion8bit paged, gradient checkpointing; rank-16 NF4 ~10-12 GB, int8 ~16-24 GB, bf16 ~32-40 GB “the absolute minimum is a single 3080 10G (with aggressive quantisation/offload)” | github.com → |
reported Figures as stated by each trainer's own documentation or official example configs, read 2026-09-25. “Stated minimum” = the docs call it a minimum; “example run” = a config or measured run at that size. They differ a lot because of settings: an 8-bit or 4-bit base model, block swapping and lower resolution all cut memory. All models →