Kromoss

Kromoss

Generates images from text with a full fine-tune of MOSS-Image-Base at 1024 px, plus two 8-step turbo LoRAs. A drop-in replacement for MOSS-Image-SFT, for diffusers and ComfyUI users.

Made by lodestones on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Kromoss takes MOSS-Image-Base and trains all of its weights further at 1024 px. It shares the architecture, inference pipeline, Qwen3.5-9B text encoder and FLUX.2 small decoder VAE of MOSS-Image-SFT, so it replaces that model directly. The repository also ships two 8-step turbo LoRAs.

Who it suits: It suits people who generate images with diffusers or ComfyUI and want a MOSS-Image variant, with a faster 8-step option when speed matters.

Industry | Who uses it | How they use it | Example
Creative | Image makers in ComfyUI | Load the single files and a turbo LoRA | Render a picture in 8 steps instead of 50
Software | Developers using diffusers | Swap it in for MOSS-Image-SFT | Reuse an existing pipeline with a new model
Research | Teams working on fine-tunes | Convert their own transformer folder to a single file | Make a ComfyUI file from a custom fine-tune

People who need a pure text rendering model can skip it, since the card shows image examples and gives no text-rendering claims.

Where to use it:

• Python with the diffusers library on a CUDA GPU
• ComfyUI, which has native support for MOSS-Image in its current master
• Windows, macOS or Linux, where you can download the files with Python

Use case | Who | What they get back
Standard generation | Image makers | 1024 px pictures at 50 steps with CFG 3
Fast generation | Image makers | Pictures at 8 steps with CFG 1 using a turbo LoRA
Low-memory use | ComfyUI users | An int8 file of 5.4 GB that works with the LoRAs

How to set it up: You need these first:

• Python 3.10 style environment with the pip packages below
• A CUDA GPU, since the quick start moves the pipeline to cuda
• ComfyUI, if you prefer the single files

1. Install the Python packages with the pip command below.
2. Download the repository files with the Hugging Face tool.
3. Run the quick start script, or place the single files in the ComfyUI folders the card lists.

pip install "diffusers>=0.38" "transformers>=5.3" "accelerate>=1.10" "safetensors>=0.6" "Pillow>=10"

pip install -U huggingface_hub
hf download lodestones/Kromoss

How to use it: Run the quick start script for 1024 px images. The transformer and text encoder use bfloat16, while the VAE and the initial noise use float32. For ComfyUI, load the main file in Load Diffusion Model, and add a turbo LoRA with LoraLoaderModelOnly at strength 1.

import torch
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "lodestones/Kromoss",
    custom_pipeline="pipeline_moss_image",
    trust_remote_code=True,
    torch_dtype={"default": torch.bfloat16, "vae": torch.float32},
)
pipe.scheduler = type(pipe.scheduler).from_config(pipe.scheduler.config)
pipe.to("cuda")

image = pipe(
    "a tabby cat holding a sign that says KROMOSS",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.0,
    uncond_skip_layers=[22],
    generator=torch.Generator("cpu").manual_seed(42),
).images[0]
image.save("kromoss.png")

The card also ships two scripts that need only torch and safetensors. The first converts a MOSS-Image transformer folder into a single ComfyUI file, and the second makes an int8 file from a bf16 single file.

python convert_to_comfy.py path/to/transformer my_model_bf16.safetensors

python quantize_convrot.py my_model_bf16.safetensors my_model_int8_convrot.safetensors

Tool | What it does
kromoss_bf16.safetensors | The main bf16 file for Load Diffusion Model
kromoss_int8_convrot.safetensors | An int8 version of 5.4 GB
8-steps-dmd2-lora.safetensors | The recommended 8-step LoRA, with a bit more contrast and detail
8-steps-dmd-lora.safetensors | An 8-step LoRA from data-space DMD distillation
convert_to_comfy.py | Converts a diffusers transformer folder to one file

Example: You ask for a tabby cat with a sign reading KROMOSS, at 1024 by 1024 with 50 steps and CFG 3. The script saves the picture as a PNG file named kromoss.png. With a turbo LoRA you can ask for 8 steps and CFG 1.

For newcomers and experts: A fine-tune is an existing model trained a bit more on new pictures. A first small thing to try is the quick start script with its sample prompt.

The turbo LoRAs were distilled from MOSS-Image-Base and transfer to Kromoss. The recommended one continues the DMD run with DMD2's GAN stage against real images. The int8 file uses ConvRot W8A8 with a Hadamard rotation that ComfyUI rebuilds at load time. The card says this checkpoint is update 11000 of the fine-tune, with EMA weights and 704k training images.

Start from MOSS-Image-Base
Fine-tune it at 1024 px
Distill 8-step turbo LoRAs
Run in diffusers or ComfyUI

Good to know:

• Size: 5.1B parameters per Hugging Face, about 10.2 GB in BF16 and about 2.5 GB at 4-bit, as an estimate
• Versions: Hugging Face lists 2 quantized versions made by other people
• Turbo LoRAs: both are fp32 with rank 128 and alpha 128, and the DMD run used 12000 updates before 3000 more with DMD2

Title: Steps per image
Standard run: 50 steps
With an 8-step LoRA: 8 steps

• License: apache-2.0
• Cost to run: none named, no API key or account
• Data it reaches: it downloads model files from Hugging Face, and the quick start runs the pipeline code with trust_remote_code set to True
• Not for: negative prompts with the turbo LoRAs, since the card says they run at CFG 1 with no negative branch

On Hugging Face, 13 November 2026

• Task: text to image
• Library: diffusers
• Parameters: 5.1B
• Weights: about 10.2 GB in BF16; about 2.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 64,728
• Likes: 322
• License: apache-2.0
• Languages: en
• Based on: OpenMOSS-Team/MOSS-Image-Base
• Quantized versions: 2
• Tags: diffusers, safetensors, moss-image, text-to-image

Links

• Model: https://huggingface.co/lodestones/Kromoss
• Files: https://huggingface.co/lodestones/Kromoss/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download lodestones/Kromoss

Then follow the usage in its model card. Nothing in this kit runs by itself.