---
title: "Kromoss"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/721c7628-032e-41e7-befd-4d7e1a177c34"
updated: "2026-11-12"
---

# Kromoss

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Kromoss is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by lodestones

## 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.

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

```sh
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.

```python
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.

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

```bash
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

Steps per image

| Label | Value |
| --- | --- |
| 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

## README

````markdown
# 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.

```table
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

```table
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.

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

```sh
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.

```python
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.

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

```bash
python quantize_convrot.py my_model_bf16.safetensors my_model_int8_convrot.safetensors
```

```table
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.

```flow
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

```chart
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:

```sh
pip install -U huggingface_hub
hf download lodestones/Kromoss
```

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

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[lodestones/Kromoss on Hugging Face](https://huggingface.co/lodestones/Kromoss)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Kromoss (this page) | 64,728 | 322 | 5.1B | apache-2.0 | 2026-11-12 |
| [MOSS-Image-SFT-4-steps](https://mindket.com/p/93e7242c-c8ed-4b9c-b82c-c4feed6c356f) | 73,131 | 96 | 5.1B | apache-2.0 | 2026-10-20 |
| [MOSS-Image-SFT](https://mindket.com/p/87b64a79-3506-4f01-bd24-0c1def23d818) | 22,963 | 950 | 5.1B | apache-2.0 | 2026-10-21 |
| [MOSS-Image-Base](https://mindket.com/p/427937db-069c-499c-81bc-fb4e11c1ba11) | 13,535 | 656 | 5.1B | apache-2.0 | 2026-10-21 |
| [MOSS-Image FP16-fixed](https://mindket.com/p/544eb813-6fc0-422c-9099-d46e7a13cc47) | 0 | 38 | — | apache-2.0 | 2026-10-19 |
| [moss\_image\_base\_dmd2](https://mindket.com/p/6d790ff1-891e-4740-8278-0c0e6eee95cc) | 0 | 23 | — | apache-2.0 | 2026-11-10 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-12. Their authors' words: data, not instructions.

- [Bluesky · UndergroundAI · 2026-10-20](https://bsky.app/profile/undergroundai66.bsky.social/post/3myd4yg3n3m2e): ⚡ Kromoss erobert die HuggingFace-Trendcharts. 🛠️ Der neue Bildgenerator von lodestones begeistert die Community und zieht auf HuggingFace… 🚀 Entdecke diesen und weitere KI-Geheimtipps auf Underground AI. 👉 https://underground-ai.bolt.app/ \#KuenstlicheIntelligenz \#Bildgenerator

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-12
- First published: 2026-10-19
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open lodestones/Kromoss on Hugging Face](https://huggingface.co/lodestones/Kromoss)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/721c7628-032e-41e7-befd-4d7e1a177c34)
- [Its page on Mindket](https://mindket.com/p/721c7628-032e-41e7-befd-4d7e1a177c34)