Train a MOSS Image LoRA on 12 GB VRAM

Can you train a MOSS Image LoRA on a 12 GB GPU? Here is the short version.

Short answer: Yes, with kohya sd-scripts: ConvRot INT8 for the DiT and text encoder plus --blocks_to_swap 20-36 measured 5-7 GB in training. Text encoder outputs must be cached, and you need about 15 GB of system RAM. Since v0.12.2, adding --block_swap_h2d_only makes block swap about 20% faster (9.4 vs 11.7 s/step at ~7 GB on an RTX 3090, bf16, 1024px).

Exact VRAM data we have

kohya sd-scripts guide (1024px, batch 1, LoRA dim 16, AdamW, gradient checkpointing, text encoder outputs cached): ~13 GB training with bf16 DiT, ~9 GB with ConvRot INT8 DiT + text encoder, ~5-7 GB adding block swap (needs ~15 GB system RAM). v0.12.2's H2D-only block swap on an RTX 3090 (bf16, 1024px, batch 1, --blocks_to_swap 36): ~7 GB at 9.4 s/step vs 11.7 s/step with classic block swap. Caching text encoder outputs needs ~8.3 GB even in INT8, so 8 GB GPUs are not supported yet. Training the text encoder LoRA too: ~17 GB INT8, ~32 GB bf16. SimpleTuner ships 24, 32, 48, 80 and 144 GB recipes at 512px. ai-toolkit: ~15 GB at batch 2, 1024px, AdamW. kohya sd-scripts v0.12.3: --compile with --convrot_int8 runs at 3.35-3.47 s/it vs 3.95 s/it bf16 (1024px, RTX PRO 6000 at 250 W) with the INT8 VRAM savings. ai-toolkit Base config: ~10.5 GB at ~1.8 s/it on an RTX 5090

Memory-relevant settings

sd-scripts: fp8_base is not supported for MOSS Image; use --convrot_int8 (and --convrot_int8_text_encoder) instead
SimpleTuner recipes: rank-32 LoRA, LR 1e-4, REPA, 4,000 steps, 512px-area training; validate at 50 steps, CFG 3, 1024px
ai-toolkit low_vram + cache_text_embeddings could OOM at startup because the text encoder stayed on the GPU; fixed in ai-toolkit on Oct 17, so update first
Standard LoRA recipe that trains well on Base: LoRA on attention + MLP, rank 32, alpha 32, AdamW LR 1e-4 (betas 0.9/0.95, weight decay 0.01), grad clip 1.0, cosine schedule with 100 warmup steps and min multiplier 0.1, bf16, text encoder and VAE frozen, ~1 MP (1024²) with aspect ratio kept, no min-SNR
Low-VRAM ai-toolkit LoKr on Base: rank 4 LoKr, 8-bit quantization, low VRAM on, text encoder fully offloaded, transformer 50% offloaded
sd-scripts v0.12.2 H2D-only block swap: add --block_swap_h2d_only to --blocks_to_swap (needs --gradient_checkpointing; optional --block_swap_ring_size, default 2, and --use_pinned_memory_for_block_swap). MOSS Image LoRA on an RTX 3090 at 1024px, batch 1, 36 blocks swapped: 9.4 s/step instead of 11.7 (~20% faster) at ~7 GB VRAM. LoRA only, not full fine-tuning
sd-scripts v0.12.3: --compile now works with --convrot_int8. 1024px, batch 1, grad accumulation 4 on an RTX PRO 6000 at 250 W: 5.02 s/it INT8 without compile, 3.47 s/it with compile, 3.35 s/it with the faster INT8 backward, vs 3.95 s/it bf16, keeping the INT8 VRAM savings. Extra INT8 GEMM autotune configs roughly double kernel throughput on the RTX 3090 (~4% on Blackwell forward). Also fixes compile graph breaks on Python below 3.12. Not in a release yet
Kromoss int8 ConvRot single file (~5.4 GB) runs in ComfyUI on smaller GPUs; its convert_to_comfy.py turns your own MOSS Image diffusers fine-tune into a ComfyUI single file
ai-toolkit "no module named fla" (flash-linear-attention) in Docker: fixed Oct 19, so pull the latest version and update dependencies; prompt encoding at batch size above 1 also got faster the same day
ComfyUI v0.42.1 fixes crashes in the MOSS Image template workflow; ComfyUI master adds MOSS RoPE scaling (ScaleRope node) for higher resolutions and a MOSS color/depth control node
Character LoRA with progressive resolution in ai-toolkit: 768px for the first ~60% of steps, then 1024px, ~5,000 steps total, LR 5e-4 with automagic3 and min_lr at half the LR, sigmoid timesteps, 100-200 dataset images for strong likeness
ComfyUI master (Oct 22, PR #17296) loads MOSS Image edit LoRAs: feed the reference images through the stock ReferenceLatent node and set reference_latents_method to match how the LoRA was trained: index_timestep_zero (default, ai-toolkit edit training with kv_cache), index_timestep_zero_joint (ai-toolkit with kv_cache: false), index_timestep_zero_frame0 (chinoll/Moss-Image-Edit) or index (references at the image's timestep). The experimental Text Encode MOSS-Image Edit node also passes references to the vision tower as in ai-toolkit training. References are cached once per run (826 to 457 ms/step at 1024px with a 1 MP reference) and work alongside the color/depth control node
ai-toolkit MOSS Image Base config: ~10.5 GB VRAM at ~1.8 s/it on an RTX 5090
RTX 5090 at 512+768 buckets: batch 4 fits and trains better than batch 6, which hits the VRAM limit; with the transformer in nvfp4, a batch-4 run uses about 18 GB
MOSS-Image-heal (KBlueLeaf): full finetune of OpenMOSS-Team/MOSS-Image-Base with a healed residual stream (largest stream value 3,083 vs base 58,411; stream RMS 7.5x lower; every weight within 64x its tensor RMS vs 349 base outliers). Probe metrics: flow loss 0.4289 vs 0.4280, velocity cosine 0.9983. Transformer only; text encoder, tokenizer, VAE and scheduler from official Base. Apache-2.0. ComfyUI: moss_image_heal_bf16/fp16/int8_convrot.safetensors

Trainers that support MOSS Image

ai-toolkit: supported (SFT + Base, Oct 16; edit training Oct 17)
kohya sd-scripts: supported (v0.12.3, Oct 26; LoRA incl. ConvRot INT8 with --compile, H2D-only block swap, truncated_logit_normal timesteps)
SimpleTuner: supported (v4.10.0, Oct 17; Base/SFT incl. edit LoRAs)
DiffSynth-Studio: supported (Oct 20; Base and SFT)
KohakuMossTrainer: supported (LoRA/LyCORIS + full finetune; from ~6-8 GB)

Other tiers: 16 GB · 24 GB · MOSS Image overview

Where to rent a 12 GB+ GPU

Cheapest 12 GB+ cards (2026-10-20 08:06 UTC) from RunPod and Vast.ai. Prices move constantly; see the live price table.

GPU	VRAM	RunPod community $/hr	Vast.ai cheapest $/hr
RTX 3060	12 GB	—	$0.04
Tesla V100	16 GB	$0.19	$0.08
RTX 3090	24 GB	$0.22	$0.12
RTX 5060 Ti	16 GB	—	$0.14
Tesla V100S	32 GB	—	$0.14
RTX A5000	24 GB	$0.16	—

Sources

FAQ

Is 12 GB enough to train a MOSS Image LoRA?

Yes, with kohya sd-scripts: ConvRot INT8 for the DiT and text encoder plus --blocks_to_swap 20-36 measured 5-7 GB in training. Text encoder outputs must be cached, and you need about 15 GB of system RAM. Since v0.12.2, adding --block_swap_h2d_only makes block swap about 20% faster (9.4 vs 11.7 s/step at ~7 GB on an RTX 3090, bf16, 1024px).

What is the cheapest 12 GB+ GPU to rent?

See the table above and the live price page.

Weekly newsletter: new models, trainer releases, cheapest GPUs. Subscribe

Data updated 2026-10-20. Disclosure: RunPod and Vast.ai links are referral links; ImageLoRA may earn a commission at no cost to you. unknown = no data yet. · Raw data (JSON) · llms.txt