How to train a MOSS Image LoRA

Which trainers support MOSS Image (OpenMOSS, ~5B, Apache 2.0), how much VRAM you need, and settings that work. Every row links to its source.

MOSS Image likeness recipe (LoKr)

Source	AI Toolkit Discord, Oct 23 2026
Trainer	ai-toolkit
Base model	MOSS Image Base
Network	LoKr, rank 4
Timesteps	sigmoid, high-noise bias
VRAM	~10.5 GB at ~1.8 s/it on an RTX 5090 (Base config)
Optimizer	automagic3 with min_lr 2e-5-3e-5, weight_decay 1e-5 (LR reaches the floor around step 600); ai-toolkit's automagic4 (Oct 23) keeps the LR off the floor on its own
Differential guidance	off (better likeness without it)
EMA	0.99 works (3,000 steps on 30 images)
Steps	about 3,000
Dataset	40-100 images; 100-200 gives the best likeness
Blocks	keep block 22 in training
Style LoRAs	visible by step 300-900
Captions	plain natural-language captions work

MOSS Image character recipe that works

Source	AI Toolkit Discord, Oct 20 2026
Trainer	ai-toolkit
Base model	MOSS Image Base
Quantization	transformer and text encoder in 8-bit ConvRot
Network	LoKr, factor 8
Optimizer / LR	AdamW 8-bit, 1e-4
Weight decay	5e-5
Schedule	shift timesteps
EMA	on, 0.99
Batch	2, gradient accumulation 2
Differential guidance	On, scale 3
Resolution	512
Dataset	100 images reached the same likeness as 25 images, with much more flexibility

Trainer support

Trainer	Status
ai-toolkit	supported (SFT + Base, Oct 16; edit training Oct 17)
OneTrainer	unknown
musubi-tuner	unknown
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)

VRAM

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

Known-good settings

Learns fast
Tokenizer loading bug fixed same day (Oct 16) in ai-toolkit; update before training
SFT variant: stripe artifacts, no fix yet
sd-scripts: fp8_base is not supported for MOSS Image; use --convrot_int8 (and --convrot_int8_text_encoder) instead
sd-scripts: --timestep_sampling sigma --weighting_scheme logit_normal --logit_mean -1.09 --logit_std 0.95 --discrete_flow_shift 1.0 approximates pre-training; simpler alternative: --timestep_sampling shift --discrete_flow_shift 3.0. Since v0.12.3, --timestep_sampling truncated_logit_normal --logit_mean -1.09 --logit_std 0.95 --discrete_flow_shift 1.0 reproduces MOSS Image's pre-training schedule exactly and is what the MOSS docs recommend (extra args --timestep_cutoff, default 0.95, and --timestep_uniform_ratio, default 0.01)
sd-scripts example: LR 1e-4 constant at network_alpha 1 (lower LR if you raise alpha)
SimpleTuner recipes: rank-32 LoRA, LR 1e-4, REPA, 4,000 steps, 512px-area training; validate at 50 steps, CFG 3, 1024px
Edit/reference LoRAs: SimpleTuner model_flavour sft-edit or base-edit with matching target and reference folders; ai-toolkit also trains Base and SFT as edit models
Base LoRA with ai-toolkit defaults (adamw8bit, shift timesteps, rank 32) gives a good style by ~1,500 steps; Base-trained LoRAs also work on SFT
Try a higher LoRA rank than usual for plain LoRA (smaller hidden size than Krea 2); for likeness, LoKr rank 4 works well (see the recipe above)
Full fine-tunes on small datasets collapse after a few epochs; use LoRA unless you have a very large dataset
ComfyUI "lora key not loaded": ai-toolkit now saves unfused q/k/v LoRA keys (Oct 17); use the Comfy-Org MOSS files to fix it
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
Inference: an SFT LoRA at ~0.6 strength with the Base model at 30 steps, CFG 3 works well; 8-step DMD LoRAs exist for SFT and Base but can weaken LoRA effect
Base DMD2 speed LoRA is final (update 3000, Oct 20): stock Euler, 4-8 steps, CFG 1
Testing your LoRA's likeness: skip Kromoss and turbo/DMD speed LoRAs, use 50 steps, CFG 2 and LoRA strength ~1.5, and generate at 1.5 MP or more (2-3 MP is best)
OpenMOSS user guide: keep the text encoder frozen when training on MOSS Image Base
OpenMOSS user guide, captioning: an LLM prompt that returns JSON with long, medium and short captions; recommended captioners are Gemma 4, Qwen 3.5 27B or Qwen 3.5 35B-A3B with thinking mode on
OpenMOSS user guide, Base inference: 50+ steps, CFG 3 (3-6 for short prompts), shift 5, Euler sampler
Using the whole JSON caption output as the caption works well; ai-toolkit accepts .json caption files
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
A Krea 2 config pasted straight into MOSS Image gives poor results; start from MOSS-specific settings
sd-scripts v0.12.2: cache several caption variants per image (for example the long, medium and short captions) and pick one at random each step; before, only the first was kept
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: per-subset timestep offsets now work with logit_normal sampling (positive = more noise)
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
sd-scripts: if you train the text encoder LoRA, don't cache text encoder outputs; older LoRA command examples in the docs did both (fixed in v0.12.2)
Kromoss: Apache 2.0 full fine-tune of Base that fixes Base's blurriness; drop-in for SFT files and workflows (50 steps, CFG 3), with an 8-step turbo LoRA (8 steps, CFG 1, euler/simple) and, since Oct 20, an 8-steps DMD2 LoRA (8 steps, 4 also works, CFG 1, strength 1). Still being updated (update 11000 on Oct 20). v1.0 is also on Civitai (same file as on Hugging Face). Kromoss DMD LoRA v1 that works: strength 0.4, CFG 3, 32 steps
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
RoPE scaling for high-res MOSS works best at partial strength; an experimental hi-res reference LoRA using depth/color maps reaches ~8K without duplicated subjects
If SFT feels stiff: extract SFT as a LoRA and apply it to Base at ~0.5 strength
SimpleTuner: LoKr training with torch.compile needs LyCORIS 4.1.3, which SimpleTuner requires since Oct 20
Character LoRAs reach near-photoreal likeness around 3,000 steps; smaller datasets ~2,000, very large datasets ~5,000
Train character LoRAs on Base for good results
Ostris-style edit training gives slightly better results but is about 3x slower to train and to run
Multi-character LoRAs blend faces in close-ups with several characters
ai-toolkit auto-caption downloads a 30+ GB captioner that runs out of memory on a 12 GB GPU; caption your dataset separately on small cards
DiffSynth-Studio trains MOSS Image Base and SFT since Oct 20 and publishes an 8-step SFT TurboLoRA (DiffSynth-Studio/MOSS-Image-SFT-TurboLoRA) and a 3.5-bit EntroPack quant that runs in about 4 GB (DiffSynth-Studio/MOSS-Image-EntroPack)
Likeness on Base in ai-toolkit: LoKr rank 4, sigmoid timesteps, high-noise bias. Most runs are done by 3,000 steps on 40-100 image datasets, and they come out better without differential guidance. EMA 0.99 at 3,000 steps on 30 images also works
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
automagic3 drops the learning rate fast on MOSS Image (it hits the floor around step 600). Set min_lr to 2e-5-3e-5 and weight_decay to 1e-5, or use ai-toolkit's automagic4 (Automagic V4, experimental, Oct 23): its LR controller settles at a fixed point (step_target, default 0.1), so the LR doesn't drift to the floor
Don't exclude block 22 when training for likeness
Style LoRAs learn fast: the style shows by step 300-900
Base renders weak faces and bodies for small, distant people in wide shots. It works best when the subject fills the frame, so plan your dataset and test prompts that way
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
Moss-Image-Edit (chinoll): an instruction-edit LoRA for MOSS Image Base or SFT (colors, outfits, lighting, seasons, style), up to 4 reference images, with single- and multi-reference ComfyUI workflows
ComfyUI-Moss-Image-Edit-Native runs chinoll's Moss-Image-Edit and akhaliq's MOSS-Image-Edit-HQ (armV3, weights/armV3/armV3.safetensors) on ComfyUI's native MOSS-Image (v0.42+). Use the converted chinoll file from PedroMarinhoDev/Moss-Image-Edit-ComfyUI. Defaults from 300+ test edits: LoRA strength 1.0 (lower redraws the scene instead of editing), CFG 5 for chinoll and 3 for HQ, skip layer guidance on layer 22, 30 steps euler/simple, empty negative, references and output in the same ~1 MP bucket, and SFT rather than Base (both LoRAs were trained on SFT). chinoll keeps faces closest; HQ is best at text but overpaints fine structures
ComfyUI master (Oct 25, PR #17338) lowers peak MOSS memory a bit
ai-toolkit MOSS Image Base config: ~10.5 GB VRAM at ~1.8 s/it on an RTX 5090
Likeness comes out best with 100-200 dataset images
MOSS is very dataset-sensitive: settings that work on one dataset often don't carry over to another, so test on yours
Plain natural-language captions work for MOSS Image
ComfyUI master (Oct 23, PR #17320): Text Encode MOSS-Image Edit has image_strength (0 ignores references, 1 unchanged, above 1 emphasizes them). Each reference adds ~150 vision tokens, which used to outweigh the prompt; lower it if the prompt gets ignored
ai-toolkit (Oct 23, commit 7861f92): MOSS VAE decode is no longer forced to no_grad; update if you train through the VAE decode
MOSS-Image-Alpha-LoRA (paralaif, proof of concept): text-to-image with a real alpha channel for MOSS SFT. End the prompt with ', isolated on a transparent background' and decode with the RGBA VAE from trmz/flux2-klein-alpha. Trained on 39 images in ~40 minutes on a 16 GB GPU
Kaloscope style adapters (heathcliff01): separate style conditioning by artist name, weighted blends or a reference image for MOSS Image Base and Krea 2 Raw/Turbo; needs its own ComfyUI nodes
In the ComfyUI MOSS Image template, raise CFG from 2.5 to 3-4 before judging a LoRA; at 2.5 a good LoRA can look broken
Pose and action LoRAs: the high LR that suits character LoRAs makes them rigid and copies the dataset people; use a lower LR, or train one LoRA per pose
Large datasets need only about 1 epoch: ~950 images at gradient accumulation 4 (~250 steps) trains well, and 2 epochs overtrains
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
If automagic drives the LR too low, start from a higher LR or switch to Prodigy
Validation images are expensive with the text encoder fully offloaded: 20 of them slow a run from 5 s/it to 30 s/it, so keep validation prompts few
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
KohakuMossTrainer trains MOSS-Image Base/SFT adapters with every LyCORIS algorithm plus full finetune, on Windows and Linux, from 6 GB cards to multi-GPU; a style LoRA at rank 8 on an RTX 4090 with aggressive offload uses about 12-13 GB at ~0.85 images/s (v0.1.0, Oct 18)

General tips

Gated Hugging Face models: click 'Agree and access' on each model page, or you'll get 403 errors
Steps scale with dataset size (steps = epochs x images at batch 1)
A safe start: LoKr with auto rank (~64), batch/grad accumulation 4
Leave out of your captions whatever you want burned into the LoRA; caption what should stay changeable
ai-toolkit dataset folder weights let you train the same images with long, medium and short captions in separate folders
ai-toolkit supports validation loss, which shows when a run stops improving
In ai-toolkit, Cache text embeddings works for basically every model and frees the text encoder from VRAM and RAM
Prefer int8 convrot over qfloat8 quantization in ai-toolkit: better quality at the same memory
Gradient accumulation and batch size don't scale the learning rate in ai-toolkit; a bigger batch needs about 1.5-2.5x the steps

Where to rent a GPU

See cheapest GPU to train a LoRA (RunPod, Vast.ai).

Sources

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

Data updated 2026-10-20. RunPod and Vast.ai links are referral links. unknown = no data yet. · Raw data (JSON) · llms.txt