How to Run MOSS-Image in ComfyUI (Official Nodes, Step by Step)

MOSS-Image is a 5B-parameter open-source text-to-image model released on 2026-10-16 under Apache-2.0. Its strengths are long bilingual text rendering and JSON layout control. ComfyUI supported it on day one. This guide walks through the weights, the two install paths, the example workflow settings, and the fixes for the most common problems. If you want background first, read What is MOSS-Image or the model overview.

What do you need to run MOSS-Image in ComfyUI?

You need an NVIDIA GPU with CUDA, a current ComfyUI install, and three sets of weights: the MOSS-Image-SFT diffusion model, the Qwen3.5-9B text encoder, and the FLUX.2 VAE. The official repository lists Python 3.10 or newer and PyTorch 2.9 or newer. Official VRAM requirements have not been published.

Use the SFT checkpoint, not Base. The Hugging Face model card describes SFT as the checkpoint for everyday generation. Base is the raw pretrained model with no post-training, intended as a starting point for LoRA and fine-tuning.

The Comfy-Org repack splits the model into single safetensors files sized for ComfyUI:

Component	File	Size
Diffusion model (bf16)	`moss_image_sft_bf16`	10.2 GB
Diffusion model (int8)	`moss_image_sft_int8_convrot`	5.4 GB
Text encoder (int8)	`qwen3.5_9b_int8_convrot`	9.8 GB
Text encoder (w4a8)	`qwen3.5_9b_w4a8_gptq`	7.3 GB
VAE	`flux2-vae.safetensors`	340 MB

Pick one diffusion file and one text encoder file. The bf16 model plus int8 encoder is the largest combination; int8 model plus w4a8 encoder is the smallest. The text encoder and VAE are standard components. MOSS-Image reuses Qwen3.5-9B unchanged and takes its VAE from FLUX.2-klein-4B, so if you already have the FLUX.2 VAE you do not need a second copy.

Which install path should you use: ComfyUI core or the MOSS-Image plugin?

Use ComfyUI core if you want the smallest setup. Support was merged into ComfyUI core on release day in PR #17095 by Kijai (see the ComfyUI Wiki release note), so a normal ComfyUI update is enough. Use the "MOSS-Image" plugin from ComfyUI Manager if you want to load the Diffusers-format folder directly.

Path A: ComfyUI core

Update ComfyUI to a build that includes PR #17095 (anything released after 2026-10-16).
Download the Comfy-Org repack files listed above.
Load the example workflow from the ComfyUI Wiki model page or the repack repository.

This path uses the standard loader nodes you already know. No custom node install is needed.

Path B: ComfyUI Manager plugin

Open ComfyUI Manager, search for "MOSS-Image", and install the plugin.
Download the Diffusers repository OpenMOSS-Team/MOSS-Image-SFT from Hugging Face as a folder.
Add the MOSS-Image HF Loader node and point it at that directory.

This path is convenient if you also run the model through Diffusers and want one copy of the weights on disk. The trade-off is that you download the whole repository rather than picking one quantized file per component.

Where do the weight files go?

Place the diffusion model in ComfyUI/models/diffusion_models, the Qwen3.5-9B text encoder in ComfyUI/models/text_encoders, and the FLUX.2 VAE in ComfyUI/models/vae. Restart ComfyUI or refresh the node list so the loaders see the new files. These are the standard ComfyUI folders; no MOSS-specific directory is required.

If you take Path B, the Diffusers folder can live anywhere. The MOSS-Image HF Loader node takes a path, not a models-folder entry.

A quick check before you build anything: open each loader node and confirm the file name appears in the dropdown. A missing file is the most common reason the first run fails.

How do you build the text-to-image workflow?

The workflow is a standard flow-matching chain: load model, text encoder, and VAE; encode a positive and a negative prompt; set shift and skip-layer guidance; sample with Euler and the sgm_uniform scheduler; decode. The official example uses 1024 x 1024, 50 steps, CFG 3, shift 5 and skip layer 22.

Here are the values from the example workflow and the GitHub README:

Setting	Value	Notes
Resolution	1024 x 1024	Any aspect ratio; width and height must be multiples of 16
Steps	50	The README says 50 or more
CFG	3	Range 3.0-6.0; raise it for short prompts
Shift	5
Skip layer (negative branch)	22	22, 24 or 26 all work per the model card
Sampler	Euler	Flow-matching
Scheduler	sgm_uniform

The USERGUIDE recommends 1M, 1.5M or 2M pixel outputs. The model extrapolates from 0.25M (512 x 512) up to 4M (2K), but the sweet spot is 1024 x 1024 and nearby sizes.

Use this negative prompt from the USERGUIDE:

nsfw, worst quality, bad anatomy, watermark, jpeg artifact

Prompts can be up to 4096 tokens. For a full explanation of each value, see MOSS-Image recommended settings.

How does the MOSS-Image Layout Prompt node work?

The MOSS-Image Layout Prompt node turns drawn boxes into the JSON layout format the model reads. You draw regions with Create Bounding Boxes, give each region a label and a caption, add text for text regions, and the node emits the JSON that goes into the positive prompt.

The JSON uses bbox_format: "yxyx" ([y_min, x_min, y_max, x_max]) and bbox_coord_space: "abs_centralized", which means absolute pixels with the origin at the canvas centre. On a 1024 x 1024 canvas, coordinates run from -512 to +512. Labels are text, character or object.

Layout JSON is marked experimental by the authors, but the paper reports it beats natural-language prompts in human preference tests. Because the prompt is the layout, you can edit one caption or one box and regenerate without any image conditioning. The full schema is on the Layout JSON spec page.

What first prompt should you test?

Start with the example OpenMOSS ships in its own README and model card: a sticky note on a refrigerator with three handwritten Chinese lines. The paper surface is plain, so any text error is obvious, and you can compare your output with the official sample. Real line breaks in the prompt become line breaks on the note.

A wide view of a refrigerator beside a kitchen counter with a fruit bowl. A small sticky note on the refrigerator door is handwritten in Chinese:
记得买牛奶和鸡蛋！
牛奶两盒，鸡蛋一打。
顺便带一袋面包。

What to look for: all three lines present, in order, with no extra or missing characters. If you get that at CFG 3 and 50 steps, the install is correct. Then swap in an English line to compare, and try the same text through the Layout Prompt node with one text box per line.

You can also try this prompt in the MossImage generator on the home page to compare results.

How do you fix common problems?

Most problems fall into two groups: running out of memory, and text that comes out wrong. Memory issues are solved with the smaller weight files or a smaller canvas. Text issues are solved with higher CFG, more steps, and quoting the exact string in the prompt.

Out of memory

Switch to moss_image_sft_int8_convrot (5.4 GB) and qwen3.5_9b_w4a8_gptq (7.3 GB).
Reduce the canvas. 1M pixels is the recommended floor for quality; 512 x 512 still works if you only need a test.
The official Gradio app offers three modes (GPU resident, component offload, sequential offload). ComfyUI handles offloading itself, but the same principle applies: fewer resident components, less VRAM.

The project has not published a VRAM figure, so test rather than assume.

Garbled or missing text

Raise CFG toward the top of the 3.0-6.0 range. Short prompts in particular need higher CFG.
Use more steps. Fifty is the minimum, not a target.
Put the literal text in quotes and describe where it sits and how it looks.
Use \n to control line breaks instead of hoping the model wraps where you want.
Chinese long text is slightly weaker than English. The paper reports 92.4 on Chinese long text versus 97.1 on English, because the training captions are mostly English.

Washed-out or inconsistent details

Turning off skip-layer guidance makes images look more photographic, but the USERGUIDE warns that details may break. Leave skip layer 22 on for text work.

Training your own LoRA

Train on the diffusion model only. The text encoder is frozen in the official model and should stay frozen; fine-tuning it breaks the mapping the DiT learned.

Can you make MOSS-Image faster with few-step LoRAs?

Yes, with community LoRAs. Within days of release, the community published a 4-step "rapid-moss" LoRA and an 8-step DMD LoRA. Both load through the standard LoRA loader. They are not official releases, and the project has not published inference speed numbers, so treat them as experiments.

Why they exist: the Base model has no distillation, so it needs 50 or more steps with CFG 3. That is slow. Few-step LoRAs trade some quality for speed. For text-heavy work, check the output carefully; text rendering is the first thing to degrade when you cut steps.

The SFT model page lists adapters and fine-tunes under the model tree. As of 2026-10-20 it showed 16 adapters and 14 fine-tunes.

What are the alternatives to ComfyUI?

If ComfyUI is not your tool, MOSS-Image also runs through the official Gradio app, a Diffusers pipeline, SGLang, vLLM-Omni, and a hosted Hugging Face Space. There is no official hosted API as of 2026-10-20.

Gradio app. Included in the GitHub repository. Has the three memory modes described above.
Diffusers. Requires diffusers 0.38 or newer and transformers 5.3 or newer:

from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "OpenMOSS-Team/MOSS-Image-SFT",
    custom_pipeline="pipeline_moss_image",
    trust_remote_code=True,
)

SGLang. Day-0 support; see docs.sglang.io.
vLLM-Omni. Day-0 support; the vLLM recipe covers the Base model.
Hugging Face Space. The official demo runs in a browser with nothing to install.

ComfyUI remains the best choice if you want the Layout Prompt node and visual control over every setting.