Train a MOSS-Image LoRA With KohakuMoss: 6 GB VRAM Guide and ComfyUI Export

MOSS-Image came out on October 16, 2026, and three days later it already had a serious training tool. KohakuMoss is a trainer for LoRAs, LyCORIS adapters and full fine-tunes of MOSS-Image, written by KohakuBlueleaf, the developer behind LyCORIS. It runs adapter training on GPUs with as little as 6 GB of VRAM and exports adapters that load in ComfyUI’s standard LoRA loader with no extra nodes. This guide covers what KohakuMoss can do, the hardware tiers, how to install it on Windows and Linux, how to prepare a dataset, a sensible first training run, exporting to ComfyUI, and the license term that catches people out.

What Is KohakuMoss?

KohakuMoss is an open source training framework built specifically for MOSS-Image, the 5B diffusion transformer from OpenMOSS that uses Qwen3.5-9B as its text encoder. If you have not set up MOSS-Image yet, start with my MOSS-Image in ComfyUI guide, because you will want a working generation workflow to test your LoRAs.

Its author, KohakuBlueleaf, created LyCORIS, the library behind LoCon, LoHa and LoKr adapters that most Stable Diffusion and FLUX trainers use. That pedigree shows in the feature list:

• Adapters through LyCORIS: LoRA, LoCon, LoHa, LoKr, DoRA, OFT, BOFT, GLoRA, IA3, DyLoRA and T-LoRA. Dropout, LoRA+, merged or bypass forwards and layer targeting presets are settings, not separate scripts.
• Full fine-tuning: Muon combined with AdamW, plus EMA, following the recipe in the MOSS technical report.
• Memory tricks: block checkpointing, weight streaming, activation offload, gradient offload and optimizer states in system RAM.
• Precision options: bf16 where supported, fp16 on older cards (with a fix for residual overflow), fp8 and MXFP8 compute on RTX 40 and 50 series (sm89 and newer), and int8 or fp8 weight-only quantization for the frozen base.
• Data loaders: kohya-style folders, jsonl, parquet, webdataset and native shards, with resolution bucketing.
• ComfyUI export: adapters saved in ComfyUI’s own MOSS-Image key layout.

Version 0.1.0 was published to PyPI on October 18, 2026. It is very new, so expect rough edges and frequent updates.

Train on Base or SFT?

KohakuMoss supports both MOSS-Image-Base and MOSS-Image-SFT. OpenMOSS describes Base as the checkpoint for fine-tuning and LoRA training, and SFT as the curated model for everyday generation. The usual approach, which OpenMOSS’s own guide points to, is:

• Train on Base for styles and concepts you want to apply broadly, then load the LoRA on SFT for generation.
• Train on SFT if you want your LoRA to match SFT’s look exactly and you only ever generate with SFT.

OpenMOSS also advises keeping the text encoder frozen during post-training, which is what adapter training does by default.

A community full fine-tune called Kromoss was also released on October 19 in bf16 and INT8 with an 8-step DMD LoRA, which shows full fine-tunes of MOSS-Image are already happening.

Hardware Requirements and VRAM Tiers

The 6 GB tier works because of caching. Normally every training step runs your caption through the 9B text encoder and your image through the VAE. If you encode everything once ahead of time and save the results, the text encoder never has to sit in VRAM during training. In the author’s RTX 5090 benchmark the resident text encoder took 15.6 GiB on its own, so caching makes a huge difference on small cards.

Other requirements:

• Python 3.10 or newer.
• CUDA 12.6 or newer, or an Intel Arc driver (Intel Arc is supported).
• Windows: Visual Studio Build Tools.
• Older NVIDIA cards (sm70 and sm75, such as the V100 and RTX 20 series): the full CUDA toolkit, for nvcc.
• fp8 and MXFP8 compute: RTX 40 series or newer (sm89+). My RTX 5080 qualifies.
• Multi-GPU training (DDP, FSDP2 and pipeline modes): Linux only.

Plan for plenty of system RAM too, especially if you use offloading profiles: 32 GB is a sensible minimum for adapter training, and full fine-tunes on 24 GB cards keep master weights in host memory, so 64 GB or more is wise.

Install KohakuMoss on Windows and Linux

1. Install the prerequisites: Python 3.10+, an up-to-date NVIDIA driver with CUDA 12.6+ support, and on Windows the Visual Studio Build Tools with the C++ workload.
2. Create a virtual environment so KohakuMoss does not clash with your ComfyUI Python:

   python -m venv kohakumoss-env
   # Windows
   kohakumoss-envScriptsactivate
   # Linux
   source kohakumoss-env/bin/activate

3. Install the package from PyPI. KohakuMoss ships install helpers that detect your driver and pick the matching PyTorch build, so follow the install section of the GitHub README for the exact command for your platform. The package name is kohakumoss.
4. Run the doctor:

   kohakumoss-doctor

   It reports anything missing, such as build tools or a mismatched CUDA version, and tells you how to fix it.

5. Download the MOSS-Image weights you want to train on (Base or SFT) from the OpenMOSS Hugging Face repos.

Prepare Your Dataset

KohakuMoss reads the dataset formats most people already have:

• kohya-style folders: images with matching .txt caption files. If you have trained SDXL or FLUX LoRAs with kohya_ss or OneTrainer, your folders should work.
• jsonl or parquet: one row per image with a path and caption.
• webdataset and native shards: for large datasets.

It handles resizing, aspect ratio bucketing and cropping for you, and uses token batching so steps stay even across mixed resolutions.

Captioning tips specific to MOSS-Image:

• Match how you will prompt. MOSS-Image understands both natural language and booru-style tags. If you will prompt with tags, caption with tags in the recommended order: quality, score, meta, year, character, series, artist, then general tags.
• Use a trigger word for characters and products, placed at the start of each caption.
• Caption what changes, not what is constant. For a style LoRA, describe the content of each image and let the shared style be learned. For a character LoRA, describe clothing, pose and background so the model does not bake them into the character.
• Quality over quantity. 20 to 50 sharp, varied images is a good start for a character or product. Styles benefit from more.

Generate a Config for Your GPU

Rather than editing a long config file by hand, start with the config generator:

kohakumoss-config
# or step by step:
kohakumoss-config wizard

The wizard asks about your GPU, adapter type, dataset and weights, then writes a checked config. Under the hood it picks one of four named memory profiles, from speed to minimal, out of a catalog of 240 tuned combinations. There are also fixed recipes such as lora_24g_bf16 that you can extend with any setting.

Every KohakuMoss script is a KohakuEngine script with settings at module level and layerable presets, so once you have a working config it is easy to copy it and change one thing at a time.

If you are on 6 to 8 GB, enable offline latent and text caching in the wizard. It adds a one-time encoding pass before training, then every step is lighter and faster.

Your First LoRA: A Sensible Starting Run

The author’s published example is a small rank 8 LoRA with an fp8 base, 100 steps and about 20,000 tokens per step, using the ckpt-ring4-actoff profile at about 12 to 13 GB on an RTX 4090. That is a smoke test, not a finished LoRA, but it is the right way to start: confirm the whole pipeline works end to end before spending hours on a real run.

A practical path:

1. Smoke test: rank 8 LoRA, 100 steps, your dataset, default learning rate from the wizard. Export and load it in ComfyUI to make sure everything connects.
2. Real run: rank 16 to 32 LoRA (the author’s benchmarks use rank 32 at 1 megapixel), enough steps to see each image many times, and checkpoints saved regularly.
3. Compare checkpoints: export several saved steps and test them with the same seed and prompt. Pick the earliest one that captures your subject without overcooking.

KohakuMoss does not publish recommended learning rates or step counts beyond these examples, so let the wizard set the defaults and tune from there.

LoRA, LoKr, DoRA or Full Fine-Tune?

If you are new to training, use plain LoRA. Switch to LoCon or LoKr for art styles once you are comfortable.

Training Speed by GPU

The author’s benchmark uses a rank 32 LoRA at 1 megapixel with the balanced profile:

KohakuMoss: MOSS-Image LoRA training speedSamples per second, rank 32 LoRA at 1 MP, balanced profile. Higher is faster.RTX 5090, cached1.14 /sRTX 5090, no cache1.01 /sRTX 4090, cached0.73 /sRTX 4090, no cache0.49 /sRTX 3090, cached0.39 /sRTX 3090, no cache0.31 /sCached = latents and text embeddings pre-computed. Source: KohakuMoss benchmarks via ComfyUI Wiki.

Peak memory per step stayed near 6.6 GiB in most of these runs. Caching gives the biggest boost on the RTX 4090, about 50 percent. To put the numbers in context, at 0.73 samples per second a 40-image dataset trained for 50 epochs (2,000 samples) takes about 45 minutes on a 4090. Kernels are tuned per card, so your numbers will vary.

Export and Use Your LoRA in ComfyUI

KohakuMoss can save four kinds of output: a LyCORIS file, a merged model, a Diffusers transformer, or a ComfyUI-format adapter. For ComfyUI:

1. Choose the ComfyUI-format adapter export. It writes keys in ComfyUI’s MOSS-Image layout, including the q/k/v repacking ComfyUI expects.
2. Copy the file to ComfyUI/models/loras/.
3. Add a standard LoraLoaderModelOnly (or Load LoRA) node between your MOSS-Image model loader and the sampler.
4. Start at strength 1.0 and lower it if the effect is too strong.

No third-party node or conversion step is needed, and you can export from any saved checkpoint, not only the final step.

One caution: the community 4-step rapid-moss adapter loads in fp32 at runtime and warns against merging into bf16 weights. Stacking your own LoRA with it has not been documented yet, so test your LoRA with the standard 25 to 50 step workflow first.

The KohakuMoss License

KohakuMoss uses the KohakuMoss License 1.0, which is Apache 2.0 plus one extra rule: any derivative work, package, product or service built on the KohakuMoss code must include “Kohaku” in its name.

Your outputs are not affected. Models, LoRAs and images you make with KohakuMoss can be named and licensed however you like. The rule only matters if you fork or repackage the trainer itself.

Your LoRA also inherits the terms of the base model. The MOSS-Image code is Apache 2.0, and the ComfyUI repack is tagged Apache 2.0, but check the original OpenMOSS model card before selling a LoRA or using it commercially.

Troubleshooting

Install fails on Windows with a compiler error

Install Visual Studio Build Tools with the “Desktop development with C++” workload, open a new terminal and run kohakumoss-doctor again.

Errors about nvcc on an RTX 20 series or V100

sm70 and sm75 cards need the full CUDA toolkit installed, not just the driver.

fp8 options are missing or fail

fp8 and MXFP8 compute need an RTX 40 series or newer card. On older GPUs use bf16 or fp16 with int8 weight-only quantization for the base.

Out of memory on 8 GB or less

Rerun kohakumoss-config and choose the minimal profile, turn on offline latent and text caching, lower the rank, and use an fp8 or int8 frozen base.

LoRA has no effect in ComfyUI

Make sure you exported the ComfyUI-format adapter, not the raw LyCORIS file, and that it is applied to the MOSS-Image model, not a different checkpoint.

Multi-GPU mode will not start on Windows

Multi-GPU training is Linux only for now. Use WSL2 or a Linux machine.

FAQ

Can I really train a MOSS-Image LoRA on 6 GB VRAM?

Yes, for adapters, if you build the latent and text caches offline first. Full fine-tuning needs 24 GB.

Does KohakuMoss work on AMD?

The documented targets are NVIDIA with CUDA 12.6+ and Intel Arc. AMD is not listed.

Can I use my existing kohya dataset?

Yes. KohakuMoss reads kohya-style folders of images with matching caption text files.

Will a MOSS-Image LoRA work with FLUX or Klein?

No. LoRAs are tied to the model architecture they were trained on. They only work with MOSS-Image checkpoints.

How long does training take?

It depends on dataset size and steps. At the author’s benchmark speeds, 2,000 samples takes about 30 minutes on an RTX 5090, 45 minutes on a 4090 with caching, and around 85 minutes on a 3090 with caching.

Can I sell LoRAs I train?

KohakuMoss’s naming rule does not apply to your outputs. Commercial use depends on the MOSS-Image license, which is Apache 2.0 for the code and repack, so check the official model card.

Final Thoughts

KohakuMoss turned MOSS-Image from an interesting new model into one you can actually customise, three days after launch and on hardware as small as a 6 GB card. Install it in its own virtual environment, let kohakumoss-doctor and kohakumoss-config handle the setup, run a quick 100-step smoke test, then train a proper rank 16 to 32 LoRA and export it straight into ComfyUI. Given how fast the MOSS-Image ecosystem is moving, check the GitHub repo for updates before each new training run.

Related guides:

• MOSS-Image in ComfyUI: Files, Settings, Layout JSON and 4-Step LoRAs
• Bria Fibo 2.0 in ComfyUI, an 8B model that edits as well as generates.
• FLUX 3 Image Klein in ComfyUI
• Comfy Agent Guide

Sources

• ComfyUI Wiki: KohakuMoss, MOSS-Image LoRA training with ComfyUI export
• GitHub: KohakuBlueleaf/KohakuMossTrainer
• OpenMOSS: MOSS-Image user guide
• ComfyUI Wiki news (Kromoss full fine-tune, October 19)