Best Kromoss ComfyUI Workflow for 16 GB GPUs: INT8 + 8-Step DMD2 LoRA Setup

Kromoss showed up on Hugging Face on October 19, 2026, and within a week it had passed 21,000 downloads and climbed into the top 15 of Hugging Face’s trending models. It comes from lodestones, the person behind Chroma, and it’s a full fine-tune of OpenMOSS’s MOSS-Image-Base. On October 24 the repo added an official ComfyUI workflow. Most of the questions I see now are practical ones: which files do I download, will it fit on a 16 GB card, and how do I get the 8-step turbo mode working without grey noise? This guide answers those, with the setup I’d use on my RTX 5080 16 GB.

What Is Kromoss?

To understand Kromoss you first need its base model. MOSS-Image is OpenMOSS’s 5B single-stream diffusion transformer, announced on October 16, 2026. It reads prompts with a full Qwen3.5-9B language model, generates in the FLUX.2 latent space, and supports prompts of up to 4K tokens, text rendering and JSON bounding-box layouts. I covered the base family in my MOSS-Image ComfyUI guide. This article only covers what’s different about Kromoss.

The Kromoss model card describes it as “a full fine-tune of MOSS-Image-Base at 1024 px”. The released checkpoint is update 11000 of the fine-tune (EMA weights), trained on 704k images. The repo’s commit history shows lodestones pushing a new checkpoint every few hours between October 19 and 20: updates 2000, 4000, 5000, 7000, 9000 and then 11000. That matters later when you read complaints about early versions, because many of those were about checkpoints that have since been replaced.

Kromoss also ships with two 8-step turbo LoRAs distilled from MOSS-Image-Base:

• 8-steps-dmd2-lora.safetensors is the recommended one. It’s the DMD LoRA, trained further with DMD2’s GAN stage against real images. According to the card it has “slightly more contrast and detail, and the best PartiPrompts score.”
• 8-steps-dmd-lora.safetensors is the plain data-space DMD distillation.

Both are fp32, rank 128 / alpha 128, use kohya-style keys, and weigh 1.19 GB each. The license is Apache 2.0, the same as the OpenMOSS base.

Kromoss vs MOSS-Image-SFT: Why Bother?

If you already have MOSS-Image-SFT working, it’s fair to ask why you’d download another 10 GB. There are three practical reasons:

1. The turbo LoRAs work on the INT8 file. The Kromoss card says the kromoss_int8_convrot file “drops in for the int8 Comfy-Org file and works with the LoRAs.” On a 16 GB card this is the main reason to use Kromoss: you get 8-step generation without having to hold the 10.2 GB bf16 transformer in VRAM.
2. It’s a different “taste”. Kromoss is a separate fine-tune of Base, not a tweak of SFT. Whether you prefer its look is subjective, so test it before you replace SFT in your workflows.
3. It’s a drop-in. The repo uses the same layout as MOSS-Image-SFT, and kromoss_bf16.safetensors replaces moss_image_sft_bf16.safetensors in the Comfy-Org workflows without any other change.

Here’s how the options compare, using only the published figures:

Option	Transformer file	Default steps / CFG	Turbo LoRA on INT8?	License
MOSS-Image-SFT (Comfy-Org)	bf16 10.2 GB / int8 5.4 GB	50 / 3 (template ships 25 / 2.5)	Earlier SFT 8-step adapters: bf16 only	Apache 2.0
Kromoss full	bf16 10.2 GB / int8 5.4 GB	50 / 3	n/a	Apache 2.0
Kromoss + 8-step DMD2 LoRA	same + 1.19 GB LoRA	8 / 1 (4 also works)	Yes, per the model card	Apache 2.0
Kromoss GGUF (molbal)	Q4_K_M 3.35 GiB to Q8_0 5.31 GiB	50 / 3 in the supplied workflow	Not documented	Apache 2.0

Which Files to Download for a 16 GB GPU

Neither lodestones nor OpenMOSS publish an official VRAM requirement for Kromoss, so I’m not going to make one up. What we do have is exact file sizes, and ComfyUI works in stages. It loads the text encoder, encodes your prompt, then can offload the encoder before the transformer samples. That means the encoder and transformer don’t both need to fit in VRAM at the same time.

Component	File	Size	Folder
Transformer (INT8, my pick)	kromoss_int8_convrot.safetensors	5.41 GB	models/diffusion_models/
Transformer (bf16)	kromoss_bf16.safetensors	10.16 GB	models/diffusion_models/
Text encoder (smallest)	qwen3.5_9b_w4a8_gptq.safetensors	7.34 GB	models/text_encoders/
Text encoder (INT8)	qwen3.5_9b_int8_convrot.safetensors	9.75 GB	models/text_encoders/
Text encoder (bf16)	qwen3.5_9b_bf16.safetensors	19.3 GB	models/text_encoders/
VAE	flux2-vae_small.safetensors	250 MB	models/vae/
Turbo LoRA	8-steps-dmd2-lora.safetensors	1.19 GB	models/loras/

The transformer, LoRA and VAE come from lodestones/Kromoss. The two smaller text encoders are only in Comfy-Org/MOSS-Image, because the Kromoss repo only includes the 19.3 GB bf16 encoder. Don’t download that one for a 16 GB card. It’s larger than your VRAM, so ComfyUI would have to stream it from system RAM every time you change the prompt.

For my RTX 5080 I’d use INT8 Kromoss with the W4A8 encoder. That’s about 14.2 GB on disk including the LoRA and VAE, and the largest single file is 7.3 GB. The official kromoss_simple_workflow.json uses the same W4A8 encoder, which suggests lodestones considers it good enough. If you have 64 GB of system RAM and want the best prompt encoding, the INT8 encoder (9.75 GB) is a reasonable step up. I’d still plan for at least 32 GB of system RAM, since offloaded models live there.

You can download everything with the Hugging Face CLI:

pip install -U "huggingface_hub[cli]"
cd ComfyUI/models

# Kromoss transformer (INT8) + DMD2 turbo LoRA + small VAE
hf download lodestones/Kromoss diffusion_models/kromoss_int8_convrot.safetensors --local-dir ./_kromoss
hf download lodestones/Kromoss 8-steps-dmd2-lora.safetensors --local-dir ./loras
hf download lodestones/Kromoss vae/flux2-vae_small.safetensors --local-dir ./_kromoss
move _kromoss\diffusion_models\kromoss_int8_convrot.safetensors diffusion_models\
move _kromoss\vae\flux2-vae_small.safetensors vae\

# Smaller text encoder from the Comfy-Org repack
hf download Comfy-Org/MOSS-Image text_encoders/qwen3.5_9b_w4a8_gptq.safetensors --local-dir ./_comfyorg
move _comfyorg\text_encoders\qwen3.5_9b_w4a8_gptq.safetensors text_encoders\

The --local-dir option keeps the repo’s subfolder structure, which is why the files are moved afterwards. These move commands are for Windows. On Linux, use mv with forward slashes.

Install Kromoss in ComfyUI Step by Step

1. Update ComfyUI to v0.42.0 or Newer

Native MOSS-Image support arrived in ComfyUI v0.42.0 (PR #17095 by kijai), released on October 18, 2026 UTC. v0.42.1 then fixed “some crashing issues a few users experienced when running the MOSS image template workflow.” I’d use the latest release, which was v0.42.5 when I wrote this. On the Windows portable build, run update\update_comfyui.bat. On a git install:

cd ComfyUI
git pull
pip install -r requirements.txt

Kromoss doesn’t need any custom nodes. Every node in the official kromoss_simple_workflow.json is tagged comfy-core, including ResolutionSelector, ModelAttentionBackend and SeedNode.

2. Load the Official Workflow and Re-point the Loaders

Download kromoss_simple_workflow.json and drag it onto the ComfyUI canvas. It was added on October 24, and it’s the workflow lodestones linked when people asked how the showcase images were made. The file names saved in it don’t match the files in the repo, so open each loader and pick your actual files:

• UNETLoader is saved with kromoss_bf16_11000.safetensors. Switch it to kromoss_int8_convrot.safetensors (or kromoss_bf16.safetensors).
• CLIPLoader: qwen3.5_9b_w4a8_gptq.safetensors, type moss_image. If the type isn’t moss_image, the encoder won’t produce what the model expects.
• VAELoader is saved with flux2-vae.safetensors, while the model card lists flux2-vae_small.safetensors. Both are FLUX.2 VAEs from Comfy-Org. I’d follow the card and use the small one.
• LoraLoaderModelOnly: 8-steps-dmd2-lora.safetensors, strength 1.

One more catch: the Note inside the workflow says to put the DMD2 LoRA in models/vae/. That’s a typo. The model card’s table says models/loras/, and that’s the only folder LoraLoaderModelOnly reads from.

The 8-Step DMD2 Workflow (My Default)

This is the official workflow’s graph, and the one I’d use for everyday work on a 16 GB card:

UNETLoader (kromoss_int8_convrot)
  └─ LoraLoaderModelOnly (8-steps-dmd2-lora, strength 1.0)
       └─ ModelAttentionBackend (optional)
            └─ KSampler
CLIPLoader (qwen3.5_9b_w4a8_gptq, type moss_image)
  ├─ CLIPTextEncode (positive prompt)
  └─ CLIPTextEncode (empty negative)
EmptyFlux2LatentImage (1024 x 1024)  ─► KSampler
KSampler ─► VAEDecode (flux2-vae_small) ─► SaveImage

KSampler settings from the card and the workflow’s Note:

Setting	Value	Why
Steps	8 (4 also works)	The LoRA was distilled to hit this step count
CFG	1.0 (1.1 if you need a negative prompt)	At CFG 1 ComfyUI skips the negative pass, which roughly halves the work per step
Sampler / Scheduler	euler / simple	Matches the flow-matching Euler setup the LoRA was trained against
Denoise	1.0	Plain text-to-image
Resolution	1024 x 1024, multiples of 16	Kromoss was fine-tuned at 1024 px
Skip layer guidance	Off	The card’s settings table lists “none (no negative branch)” for LoRA mode

Three rules from the card that matter more than they seem:

• Use one LoRA at a time. Don’t stack DMD and DMD2.
• Don’t merge the LoRA into the bf16 weights. lodestones explains that “the delta is close to bf16’s rounding step,” so merging can erase much of what the LoRA does. In ComfyUI the LoRA loader applies it unmerged, so the normal node is fine.
• The workflow’s ModelAttentionBackend node is set to comfy kitchen attention. If it gives you an error on your build, try bypassing it. As the name suggests, it selects the attention implementation rather than changing the weights.

How much faster is it? I haven’t timed Kromoss on my own card yet, so I won’t give you a number for the RTX 5080. One public same-prompt comparison on X listed Kromoss at 20 s and Kromoss 8-step at 11 s on the poster’s hardware (which they didn’t name). The relative gap is the useful part. 8 steps without CFG is far less work than 50 steps with CFG, but text encoding, VAE decoding and model loading don’t get faster, so you won’t see a 6x speed-up.

The 50-Step Full-Quality Workflow

Once a turbo seed gives me a composition I like, I’d re-run the same prompt and seed on the full model for the final image. Kromoss uses the same reference settings as MOSS-Image-Base:

• Remove or bypass LoraLoaderModelOnly.
• Steps 50, CFG 3, Euler, shift 5.
• Skip layer guidance on the negative branch at layer 22. In ComfyUI the Comfy-Org MOSS template does this with the core SkipLayerGuidanceDiTSimple node set to layer 22.
• Add a real negative prompt. The OpenMOSS user guide recommends worst quality, bad anatomy, watermark, jpeg artifact, plus nsfw if you want to filter that out.

The easiest way to build this is to open the Comfy-Org MOSS-Image: Text to Image template and replace moss_image_sft_int8_convrot with kromoss_int8_convrot. The template defaults to 25 steps, CFG 2.5 and er_sde, which is a faster draft setting. For final renders I’d move it back to the 50 / 3 settings above.

The OpenMOSS guide also notes that turning skip layer guidance off makes images “look very realistic” but can make details collapse. Try that switch if you want a photographic look.

GGUF Option for 8 to 12 GB Cards

If you’re on a smaller card, molbal/Kromoss-GGUF has Q4_K_M (3.35 GiB), Q6_K (4.24 GiB) and Q8_0 (5.31 GiB), plus two ConvRot-based quants that only work with the comfyui-gguf-reboot loader (UnetLoaderGGUFDynamicVRAM). Its supplied workflow uses the 50-step / CFG 3 / sgm_uniform / layer-22 reference settings with the W4A8 encoder and the small VAE.

Before you pick GGUF on a 16 GB card, read the Kromoss discussion thread. When someone asked for a Q4_K_M version, two users replied that the INT8 file plus the W4A8 encoder is the better choice. One said GGUF is “slower and worse quality,” and another said to “just use the int8 and comfy manages the memory swapping.” Q8_0 is barely smaller than the 5.4 GB INT8 file, so on 16 GB I’d stick with INT8.

Prompting Tips That Carry Over From MOSS-Image

Kromoss uses the same text encoder and pipeline, so the OpenMOSS prompt guidance still applies:

• Write in English when you can. OpenMOSS says English has the most training data.
• Tags work too. The recommended tag order is Quality → Score → Meta → Year → Character → Series → Artist → General.
• Control text line breaks yourself. Put \n or real line breaks inside the quoted text you want rendered.
• Layouts are JSON. MOSS’s bounding-box format uses "bbox_format": "yxyx" and absolute pixel coordinates centred on the canvas, so a 1024 x 1024 image runs from -512 to +512 on both axes. OpenMOSS still calls this experimental.

Here’s a prompt I’d start with to test text rendering in 8-step mode:

A cozy roadside chai stall at dusk in Punjab, warm tungsten bulbs, steam rising
from a brass kettle, a hand-painted wooden sign above the counter reading
"JOLLY CHAI\nSince 1998", shallow depth of field, 35mm photograph

Troubleshooting: Grey Noise, Blur and Errors

“AttributeError: ‘NoneType’ object has no attribute ‘dtype’” in KSampler

In discussion #4, a user got this error when loading the INT8 file. The fix that worked was to stop using a third-party “moss-image diffusion loader” custom node and switch to ComfyUI’s core Load Diffusion Model (UNETLoader). The INT8 ConvRot format depends on ComfyUI rebuilding the Hadamard rotation when it loads the file, which the core loader does.

Grey or Noisy Output

Another user in the same thread got a grey, noisy image with the default loader, and nobody posted a confirmed fix. Based on how the model is built, I’d check these in order: ComfyUI is v0.42.x, CLIPLoader type is moss_image, the VAE is a FLUX.2 VAE (not a FLUX.1 or SDXL VAE), the latent node is EmptyFlux2LatentImage, and if the LoRA is active then CFG is 1 with 8 steps. Running 50 steps with the LoRA still loaded, or 8 steps without it, doesn’t match either documented setup.

Backgrounds Look Too Blurry

The most active thread (discussion #3) was about heavy background blur. lodestones replied “try the latest one i just updated” and posted sharper examples, then linked the simple workflow on October 24. If you downloaded Kromoss on October 19, re-download it, because the repo now holds update 11000.

Vertical Colour Stripes

This is a MOSS-Image-SFT issue, but OpenMOSS’s README lists a community fix: MOSS-Image-SFT-DeBand LoRAs. If you see banding, it’s worth a try. I haven’t seen anyone confirm it works with Kromoss, so test it on a fixed seed first.

Honest Verdict: Who Should Use It

Community feedback is mixed, and I’d rather you hear that from me now than find out after a 14 GB download. On October 19, one early user on X said Kromoss quality was “quite bad” compared with MOSS and that SFT at 15 to 20 steps was the better trade-off. That was about an early checkpoint. In a later Hugging Face discussion, another user said the current version still doesn’t fix anatomy, “especially hands.” Others are happy with the 8-step turbo mode, and a free Kaggle notebook workflow for “Kromoss Turbo” was shared on October 24 (UTC).

My take: if you want fast drafts on a 16 GB card, INT8 Kromoss + DMD2 at 8 steps is the most VRAM-friendly MOSS-family turbo setup available right now, because the turbo LoRA officially works on the INT8 file. For hands-heavy portraits I’d keep MOSS-Image-SFT installed as well, and compare the two on the same seeds. If you want to train your own style instead, see my KohakuMoss LoRA training guide. lodestones also ships convert_to_comfy.py and quantize_convrot.py in the repo, so your own MOSS fine-tunes can be converted to the same ComfyUI single-file and INT8 formats.

Download the Kromoss 8-Step ComfyUI Workflow

Here is the official Kromoss workflow from lodestones, set up for the INT8 + 8-step DMD2 route in this guide. The loaders point at kromoss_int8_convrot.safetensors and flux2-vae_small.safetensors, and the note now says the LoRA goes in models/loras/. Nodes, links and sampler settings are the same as the original.

Download the Kromoss 8-Step ComfyUI Workflow (.zip)

What is inside the zip:

• Kromoss_8Step_DMD2_16GB.json: ComfyUI workflow in the normal canvas (UI) format. Drag it onto the canvas.
• README.txt: model files with download links and folders, custom nodes and setup steps.

Requirements:

• No custom nodes: every node is part of ComfyUI core. Update ComfyUI to the latest version first.
• 8-steps-dmd2-lora.safetensors in ComfyUI/models/loras/ (download)
• flux2-vae_small.safetensors in ComfyUI/models/vae/ (download)
• kromoss_int8_convrot.safetensors in ComfyUI/models/diffusion_models/ (download)
• qwen3.5_9b_w4a8_gptq.safetensors in ComfyUI/models/text_encoders/ (download)

Model weights are not included. Every node and link in these files was checked against the current ComfyUI source and the node packs listed above.

FAQ

Is Kromoss a new model or a LoRA?

It’s a full fine-tune of MOSS-Image-Base, so it’s a complete 5B transformer checkpoint (10.2 GB bf16 or 5.4 GB INT8), not a LoRA. The repo also includes two separate 8-step turbo LoRAs.

Can Kromoss run on a 16 GB GPU?

There’s no official VRAM figure. The file sizes suggest the INT8 transformer (5.4 GB) with the W4A8 text encoder (7.3 GB) suits 16 GB cards, because ComfyUI can offload the encoder before sampling. That’s also the combination the official workflow uses with the W4A8 encoder, and community replies recommend INT8 + W4A8 for lower-VRAM cards.

Which LoRA should I use, DMD or DMD2?

The card recommends 8-steps-dmd2-lora.safetensors. It has the best PartiPrompts CLIP score of the three Base variants listed (27.59, vs 27.53 for DMD and 27.19 for 50-step Base) and slightly more contrast and detail. Use only one at a time, at strength 1.

Can I use a negative prompt in 8-step mode?

Not at CFG 1, because ComfyUI ignores the negative branch there. The official workflow’s Note suggests CFG 1.1 if you need a negative prompt. Keep it short, since the LoRA was trained for no-CFG sampling.

Can I use Kromoss images commercially?

Kromoss is released under Apache 2.0, the same license as OpenMOSS’s MOSS-Image weights, and Apache 2.0 allows commercial use. You’re still responsible for what you generate, so check the license file in the repo yourself.

Does Kromoss support MOSS’s JSON layout prompts?

The GGUF card says Kromoss accepts natural-language prompts, tags and JSON layouts, and the model keeps MOSS-Image’s text encoder and pipeline. lodestones doesn’t document layout quality for the fine-tune, so I’d compare it with SFT on your own layouts.

Sources

• lodestones/Kromoss model card (files, settings, LoRAs, PartiPrompts scores)
• kromoss_simple_workflow.json (official ComfyUI workflow, added October 24, 2026)
• Kromoss community discussions (#3 blur, #4 INT8 error, #5 vs SFT)
• Comfy-Org/MOSS-Image (text encoders, VAEs, templates)
• ComfyUI releases (v0.42.0 MOSS-Image support, v0.42.1 fixes)
• OpenMOSS/MOSS-Image on GitHub and the user guide
• molbal/Kromoss-GGUF
• AI Search on X: Kromoss announcement post
• non-stop-slop on X: 21-model comparison timings