MOSS-Image-Base 8-step data-space DMD

MOSS-Image-Base 8-step data-space DMD

A work-in-progress distillation of MOSS-Image-Base that draws an image in 8 steps with no guidance, shipped as a LoRA and a data-space sampler. For people experimenting with fast text to image sampling.

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: This is a distilled version of OpenMOSS-Team's MOSS-Image-Base text to image model, with 5.1B parameters. The base model needs 50 steps and a guidance scale of 3. This one gets down to 8 network evaluations with no guidance, using data-space DMD. The card calls it a work in progress.

Who it suits: Image-generation tinkerers and researchers who want faster sampling from MOSS-Image-Base and are comfortable loading adapters or writing a custom sampler.

Industry | Who uses it | How they use it | Example
Research | ML researchers | Study data-space DMD and few-step distillation | A test of fewer steps from the trained prefixes
Software | Developers | Speed up image generation in a ComfyUI or Python pipeline | A LoRA loader set to strength 1
Art | Image makers | Generate images faster with the stock sampler | A draft at 4 to 8 steps
Design | Designers | Iterate quickly on prompts | A set of variations from one prompt

If you want a finished, easy-to-use model, you can skip it, since the card describes work in progress that needs care with precision.

Where to use it:

• ComfyUI, with a LoRA loader on the stock MOSS-Image-Base transformer
• Python with diffusers, using the base repository's pipeline code
• Windows, macOS or Linux with Python, for downloading the files

Use case | Who | What they get back
Fast sampling with a LoRA | Image makers | Images in 4 to 8 steps with guidance at 1
Data-space sampling | Researchers | The training-time sampler with its own loop
Adapter experiments | Developers | A rank 128 LoRA to apply to the base model

How to set it up:

• Python, to run the Hugging Face download tool
• The MOSS-Image-Base model, which supplies the text encoder, tokenizer and VAE
• Room for about 20.3 GB of F32 weights, or about 2.5 GB at 4-bit as an estimate

1. Install the Hugging Face hub tools with pip.
2. Download the repository with the hf command.
3. For the recommended route, load lora.safetensors on the stock base transformer.
4. Sample with the flow-matching Euler sampler, shift 5, guidance 1 and 4 to 8 steps.

pip install -U huggingface_hub
hf download lodestones/MOSS-Image-Base-8-steps-dmd

How to use it: The card recommends the LoRA alone with the standard sampler, and says nothing else in the repository is needed for that. The data-space sampler mirrors how the model was trained: starting from fixed noise, it refines its own clean estimate step by step.

from safetensors.torch import load_file
ds = load_file("dataspace.safetensors")            # latent_mix.Q [128, 128], step_codes [8]
Q, codes = ds["latent_mix.Q"].cuda(), ds["step_codes"].cuda()
z = torch.randn(1, 128, H // 16, W // 16, device="cuda")   # fp32
x0 = torch.zeros_like(z)
for r in range(8):                            # fewer steps also work (each prefix is trained)
    x = z + torch.einsum("oc,bchw->bohw", Q, x0)
    v = transformer(x, codes[r], prompt_embeds, prompt_mask).sample.float()
    x0 = z - v
# decode x0 with the release VAE (BN denormalize + 2x2 unpatchify)

Tool | What it does
lora.safetensors | fp32 LoRA, rank 128, for the recommended route
time_embedding.safetensors | fp32 replacements for the step embedder and two modulation biases
generator.safetensors | The same tensors in a single file, plus Q and the step codes
dataspace.safetensors | Holds the latent_mix.Q matrix and the 8 step codes

Example: You load lora.safetensors on the base transformer in ComfyUI at strength 1, set guidance to 1 and choose 8 steps. You type a scene description, and the model returns an image in a fraction of the base model's steps.

For newcomers and experts: Start with the LoRA route and 8 steps, since it needs nothing else from the repository. Treat the data-space sampler as an experiment for people who want to read the code.

Precision matters. The distillation change is smaller than bf16 rounding, so the transformer folder must be loaded and run in fp32 with no autocast, or most of the distillation is lost. For fast bf16 inference, keep the base bf16 transformer and apply the adapter files without merging them.

Load the base transformer
Apply lora.safetensors
Set guidance to 1
Sample 4 to 8 steps
An image comes out

Good to know:

• License: Apache 2.0
• Cost to run: none named
• Data it reaches: downloads files from Hugging Face, then runs on your own machine
• Not for: bf16 loading of the data-space transformer, which the card says discards most of the distillation
• Limits: the card calls this a work in progress

On Hugging Face, 13 November 2026

• Library: diffusers
• Parameters: 5.1B
• Weights: about 20.3 GB in F32; about 2.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 33,911
• Likes: 70
• License: apache-2.0
• Based on: OpenMOSS-Team/MOSS-Image-Base
• Tags: diffusers, safetensors

Links

• Model: https://huggingface.co/lodestones/MOSS-Image-Base-8-steps-dmd
• Files: https://huggingface.co/lodestones/MOSS-Image-Base-8-steps-dmd/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download lodestones/MOSS-Image-Base-8-steps-dmd

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