OpenMOSS has open-sourced MOSS-Image, a 5-billion-parameter text-to-image model that can render text, follow JSON layouts with bounding boxes, and read prompts up to 4,000 tokens long. According to the official GitHub repository, the team announced MOSS-Image-Base and MOSS-Image-SFT on October 16, 2026, with code and weights public under Apache 2.0. The SFT checkpoint on Hugging Face was trending a day later with more than 230 likes.
If you follow open image models, this lands in a busy month. We have covered FLUX.3 Image Klein, the 8-step Qwen-Image-2.1-Turbo, Halcyon, trained without language pretraining and Sperid Iris, a pixel-space model with no VAE. MOSS-Image's pitch is different: precise control over where things go.
TL;DR: the questions people ask first
| Question | Answer |
|---|---|
| What is it? | A 5B text-to-image model family from OpenMOSS: Base and SFT |
| Release date | October 16, 2026, per the GitHub README |
| License | Apache 2.0 for weights and pipeline code, per the model card |
| Headline features | Layout control, text rendering, 4K-token prompts, anime and photoreal styles, easy fine-tuning |
| How do I run it? | Diffusers with a custom pipeline, a Gradio app, or a ComfyUI plugin |
| Hardware | NVIDIA GPU with CUDA, PyTorch 2.9 or later; no VRAM figure published |
| Benchmarks? | None on the pages we read |
| Is layout control stable? | The user guide calls it experimental |
What exactly did OpenMOSS release?
Two checkpoints share one architecture and one inference pipeline. MOSS-Image-Base is the foundation model. The user guide is explicit about its status: as a base model it has "not undergone any post-training or distillation of inference parameters such as CFG," because the goal is to preserve the training information and make it easier for the community to train LoRAs. That also means you need sensible sampling settings to get good output.
MOSS-Image-SFT is the base model after supervised fine-tuning on curated data. The model card shows a before-and-after on a whiteboard prompt and says SFT "produces clearer text grouping and a more organized whiteboard layout." That is a qualitative example, not a measured score.
The repository lists six highlights: layout control, strong text rendering, long-prompt support up to 4K tokens, versatile styles including anime and photorealism, easy fine-tuning, and a compact 5B backbone. A seventh line is unusual: the team says the model was trained on heterogeneous, non-default GPU platforms. The README gives no hardware names or training-cost figures, so treat that as a stated direction rather than a measured advantage.
Noise resolving into a clean image in a few panels, illustrating how a diffusion transformer like MOSS-Image generates pictures
How do I run MOSS-Image?
The model card asks for Python 3.10 or later, an NVIDIA GPU with CUDA, and PyTorch 2.9 or later. Then install the libraries:
pip install "diffusers>=0.38" "transformers>=5.3" "accelerate>=1.10" "safetensors>=0.6" "Pillow>=10"
The minimal Diffusers call loads a custom pipeline, which means trust_remote_code=True. Read the pipeline code before you run it on a machine that holds anything sensitive:
import torch
from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained(
"OpenMOSS-Team/MOSS-Image-SFT",
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(
prompt,
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]
The transformer and text encoder run in bfloat16, while the VAE and the initial noise stay in float32. The bundled VAE is the FLUX.2 small decoder, which the card notes explicitly, and the team thanks the Diffusers, Qwen and FLUX teams in its acknowledgements.
For a point-and-click route, the repo includes a Gradio app (pip install -e '.[ui]' then python gradio_app.py --model OpenMOSS-Team/MOSS-Image-Base). It has three memory modes: GPU resident, component offload, and a slower sequential fallback for cards that run out of memory. For ComfyUI, search for MOSS-Image in ComfyUI Manager; the README says integration into the official ComfyUI repository is still in progress.
Which sampling settings does it want?
Defaults on the card are a flow-matching Euler sampler, 50 steps, CFG 3, shift 5, and no negative prompt. The unusual setting is negative-branch layer skipping at layer index 22 (zero-based). Guidance therefore costs two transformer forwards per step, but the unconditional pass skips a layer, which the user guide says improves image quality. Layers 22, 24 and 26 can all help; turning skipping off gives a more realistic look but "may also cause some details to collapse."
Other recommendations from the user guide:
- Resolution: 1M, 1.5M or 2M total pixels works best; the model extrapolates from 0.25M (512 by 512) to 4M (2K). Dimensions in the Python API must be multiples of 16.
- Steps: best results at 50 or more.
- CFG: 3.0 is generally enough for long prompts; try 3.0 to 6.0, higher for short prompts.
- Language: English has the most training data, but Chinese and other languages work.
- Negative tags: the team found "nsfw, worst quality, bad anatomy, watermark, jpeg artifact" effective.
- Tag order for anime-style prompts: quality, score, meta, year, character, series, artist, general.
What is layout control, and why does it matter?
Most text-to-image models take a sentence and decide placement themselves. MOSS-Image also accepts a JSON object. The summary.caption describes the overall scene and style. Each entry in items has a label (such as text or object), a caption, optional text for words that must be rendered, and a bbox.
{
"summary": {
"meta": ["poster"],
"canvas": "single",
"caption": "A minimalist travel poster with a cream background, a blue mountain illustration, and the title EXPLORE at the top."
},
"items": [
{"label": "text", "caption": "Large dark-blue uppercase title centered at the top.", "text": "EXPLORE", "bbox": [-416, -384, -288, 384]},
{"label": "object", "caption": "A flat blue mountain illustration in the lower center.", "bbox": [-192, -288, 384, 288]}
],
"bbox_coord_space": "abs_centralized",
"bbox_format": "yxyx"
}
Boxes are ordered as y-min, x-min, y-max, x-max, in absolute pixels measured from the canvas center, with x growing to the right and y growing downward. On a 1024 by 1024 canvas, each axis runs from minus 512 to plus 512. OpenMOSS says it chose absolute coordinates over the relative ones used in some recent work because it believes they suit different resolutions and aspect ratios better. That claim is the team's belief; the repository does not show a comparison.
A key sliding into a lock, illustrating precise control over where text and objects land in a generated image
The practical upside is editing. Because the layout is plain JSON, you can change a text string, rewrite an element caption, or drag a box, then regenerate. The README says layouts "can also support controlled editing and user-friendly layout tools." For posters, slides, packaging mockups and UI concepts, where a headline must sit in one place, that is more useful than hoping a prompt lands right.
The catch is authoring effort. The user guide admits that native layout support "also makes the models more difficult to use." OpenMOSS offers two answers. A training-free approach pairs a tuned skill with an LLM for basic layout planning, and a second approach fine-tunes an open LLM as a layout enhancer, marked "stay tuned."
What is the prompt enhancer skill?
The repository ships skills/moss-image-prompt-enhancer, a skill folder you drop into an agent's skills directory. You invoke $moss-image-prompt-enhancer with an image idea, the output you want (a detailed caption or a spatial Layout prompt) and canvas dimensions. A bundled script converts pixel-coordinate drafts into compact JSON with integer centered coordinates. It does not call any image-generation service.
The card says it is designed for GPT-6-family agents with local file and Python tools. If you are new to the format, our guide to what agent skills are explains how a skill folder works. The paste-back step is manual: you copy the compiled result into MOSS-Image's positive prompt and generate with the same dimensions.
Can I fine-tune it?
This is the other pitch. The user guide recommends Base for LoRA work and gives specific advice: keep the text encoder frozen and do not fine-tune it. It also reports that simple SFT can enable features such as GIF generation and reference-based generation in the Base model, with more promised. A few-step distillation (it names DMD) is described as in progress, which would matter for speed because 50 steps with two forwards each is slow next to the 8-step Qwen-Image-2.1-Turbo.
For captioning your own training data, the guide shares a recaptioning prompt that returns JSON with long, medium and short captions, watermark boxes and border flags. It recommends Gemma 4, Qwen 3.5 27B or Qwen 3.5 35B-A3B as the captioning model with thinking mode on, and says an agentic captioning pipeline can reach high accuracy. Those are the authors' tips, drawn from their own experiments.
How does it compare with other open image models?
Honestly: we cannot say yet. The model card and README front page publish side-by-side images, not benchmark tables, and we did not independently run it. The table below stays on what each source states.
| Model | Size | License per its card | Selling point |
|---|---|---|---|
| MOSS-Image | 5B | Apache 2.0 | JSON layout control, text rendering, 4K-token prompts |
| FLUX.3 Image Klein | 5.6B | see our guide | Open weights, compact size |
| Qwen-Image-2.1-Turbo | 7B | Qwen Research License | 8-step sampling, editing |
| Halcyon | see our post | see our post | Trained without language pretraining |
The licensing difference is the practical story. Qwen's recent image checkpoints use a research license, as we noted in our Qwen-Image-2.1-Turbo guide, while MOSS-Image states Apache 2.0, the simplest license for building a product. The one dependency to check is the FLUX.2 small decoder bundled as the VAE, since its terms are separate from the Apache grant on the pipeline code. Compare image quality on your own prompts, especially long text, multi-line signage and non-English text, which are the cases it claims to handle.
What are the limits and open questions?
- No published benchmarks. "Strong text rendering" is a claim until someone measures it.
- Layout is experimental. The guide labels it that way, and authoring boxes by hand is slow.
- Custom pipeline code.
trust_remote_code=Trueexecutes code from the repository. Pin a revision and read it. - NVIDIA-only in the docs. The quick start requires CUDA; no Apple Silicon or AMD path is documented.
- Speed. Fifty steps and two forwards per step with default guidance; few-step distillation is only promised.
- Early traction. At writing the GitHub repo showed about 431 stars and the SFT card about 1,000 downloads in the last month, so independent testing is thin.
What this means for builders
If you generate marketing images, posters or UI mockups, test the SFT checkpoint on three of your hardest prompts: a long paragraph of text, a bilingual sign, and a layout where position matters. If it holds up, Apache 2.0 plus a LoRA-friendly Base makes it a candidate for a house-style fine-tune. If you only need quick generic images, an 8-step model will be faster. Either way, keep the first run on a sandboxed machine because of the remote pipeline code.
Related reading
- FLUX.3 Image Klein: 5.6B open weights guide
- Qwen-Image-2.1-Turbo: 8 steps, 7B, how to run it
- Halcyon: text-to-image without language pretraining
- Sperid Iris: a 3B pixel-space image model with no VAE
- Krea 3 image editing model vs Nano Banana Pro and GPT Image 2
- What are agent skills? A complete guide
- Official: MOSS-Image on GitHub, MOSS-Image-SFT on Hugging Face
Details reflect the GitHub README and Hugging Face model card as of October 17, 2026. The repository is new and changing, so check it for current settings and license files.