MOSS-Image: what it is, how to run it, and how to turn its pictures into video

MOSS-Image is a text-to-image model that OpenMOSS released on October 16, 2026, with open weights under Apache-2.0 [1] [2]. Its headline features are readable English and Chinese text inside pictures and a JSON layout prompt that places text and objects where you say [3]. This guide covers what the model is, how to run it with ComfyUI or Python, and how to turn its pictures into short videos on Effect Video.

We have not run MOSS-Image ourselves. Every step below comes from the official repository, the model cards or the ComfyUI documentation, and each claim carries a numbered reference that points to the list at the end of the page.

What MOSS-Image is

OpenMOSS is an open research team from the Shanghai Innovation Institute, the Fudan University NLP Lab and MOSI Intelligence [4]. Its MOSS-Image family has two checkpoints. MOSS-Image-Base is the base text-to-image model [5]. It has had no post-training, and the team says this keeps the training information intact for people who want to train LoRAs [6]. MOSS-Image-SFT is fine-tuned from Base on curated data [1].

The generator is a 5B single-stream diffusion transformer, pretrained from scratch. The text encoder is Qwen3.5-9B and the image autoencoder is the FLUX.2 VAE. Both are frozen, and the report's 5B figure leaves them out [7].

The technical report opens with the gap the team wanted to close.

"open-weight text-to-image models still struggle with dense text and intricate layouts"

MOSS-Image Technical Report, abstract [7]

The README names layout control, text rendering, prompts of up to 4K tokens, anime and photorealistic styles, and easy fine-tuning as the highlights [1].

MOSS-Image at a glance

Hardware needs depend on the route you pick. The model card asks for Python 3.10 or later, an NVIDIA GPU with CUDA and PyTorch 2.9 or later for the standard pipeline [2]. The full SFT repository on Hugging Face totals about 27 GB [8]. The ComfyUI templates load int8 files, and bf16 builds sit in the same repository for cards with more VRAM [9]. One writer expects the int8 files to just fit in 16 GB of VRAM when fully loaded [14]. Another tester ran the Base int8 files on a 12 GB RTX 4070 and measured about 52 seconds for an 832 by 1216 picture at 50 steps [15].

What it does well and where it falls short

On text, the numbers come from the team's own evaluations. The abstract says MOSS-Image leads open-weight models on LongLongTextBench, a benchmark the team introduced, with an average text coverage of 96.3 percent. On RealLayoutArena it ranks second in the end-to-end comparison, and its backbone ranks first among generators that receive the same enhanced prompts [7]. The report adds that all results on 7Bench, LLTB and RLA come from its own evaluation, and that text recall is lower for the longest Chinese texts [7]. An independent reading of the report treats these numbers as self-reported until third parties reproduce them [16].

Layout control works through a JSON prompt that lists each text block or object with a caption and a bounding box. The user guide calls layout prompts experimental and explains the choice of coordinates [6].

"We use absolute pixel coordinates, which we believe are better suited to layout control across different resolutions and aspect ratios."

MOSS-Image user guide, layout prompts [6]

The guide also notes that native layout support makes the models harder to use [6]. The repository therefore includes a Prompt Enhancer skill that turns a rough idea into a detailed caption or a layout prompt [1]. The team says a language model fine-tuned for layout planning is on the way [6].

The current backbone does not condition on reference images and does not edit images, according to the limitations section of the report. The team lists both as future work [7]. The user guide adds that simple SFT can already enable reference-based generation in Base, with details still to come [6]. The report also says the prompt enhancer depends on external language models, which can lower the quality of the specifications it writes [7].

Make a picture with MOSS-Image

There are four ways in, from least to most setup. The demo needs no GPU. ComfyUI suits a local run on a modest card. Python gives you the official pipeline, and the hosted API skips local hardware altogether.

Try the demo first

OpenMOSS runs a live demo as a Hugging Face Space, so you can test prompts without installing anything [10]. One independent write-up suggests sending about five requests close to your own work before you set up a GPU [16].

Run it in ComfyUI

The ComfyUI route is the one both independent write-ups walk through [14] [15]. The steps below follow the ComfyUI documentation.

1. Update ComfyUI to version 0.42.0 or later. The MOSS-Image templates need it [9], and as of October 19 the 0.41.3 release did not include the support [11].
2. Open the Template Library and search for MOSS-Image. Four templates appear: text-to-image and layout-guided text-to-image, each for the SFT and the Base checkpoint [9].
3. Download the model files from the Comfy-Org/MOSS-Image repository on Hugging Face [12]. The SFT templates use three files. Put moss_image_sft_int8_convrot.safetensors in models/diffusion_models, qwen3.5_9b_w4a8_gptq.safetensors in models/text_encoders and flux2-vae_small.safetensors in models/vae. The text encoder loads through CLIPLoader with the type moss_image [9].
4. Type a description of the finished picture into the positive prompt and click Queue [9].

The template defaults favor speed. They run 25 steps at CFG 2.5 with the er_sde sampler, and the documentation suggests the official 50 steps at CFG 3 if a result looks undercooked [9]. The templates also include a prompt upsampler that expands a short request into a full caption. Set enable_prompt_upsampler to false when you want your own wording sent unchanged [9]. One tester notes that the Qwen3.5 model behind the upsampler can refuse prompts that trip its moderation [14].

"Describe the finished image, not the request."

ComfyUI documentation, prompting tips [9]

The model was trained on captions, so a prompt that reads like a caption works best [9]. Keep the canvas between 1 and 2 megapixels, with width and height in multiples of 16 [9]. When a line break inside the picture matters, type real newlines or \n in the text to render, because automatic breaks may land in the wrong place [9].

For placement control, pick a layout-guided template, open Create Bounding Boxes, drag one box per element and caption each box. Boxes marked as text render the words you type [9]. One tester says editing the boxes requires Nodes 2.0 to be switched on in the settings [14].

Run the official pipeline with Python

The model card gives a minimal Diffusers script. It needs Python 3.10 or later, an NVIDIA GPU with CUDA and PyTorch 2.9 or later [2].

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

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")

prompt = "A minimalist travel poster with a cream background, a blue mountain illustration, and the title EXPLORE at the top."

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]
image.save("poster.png")

The call sets trust_remote_code=True, which runs the pipeline code shipped in the model repository. Model files and that code are downloaded and cached on first use [2].

The defaults are the Euler sampler, 50 steps, CFG 3, shift 5 and negative-branch skipping at layer 22. The user guide recommends 50 steps or more and a CFG between 3.0 and 6.0, and it recommends English prompts, which have the most training data [6]. Image sizes must be positive multiples of 16, and 1, 1.5 or 2 million pixels is the recommended range [6]. For cards with less memory, the repository also ships a Gradio app with GPU-resident, Component and Sequential memory modes [1].

Write a layout prompt

To place text and objects, pass a layout as the prompt. With the Python API, serialize it with json.dumps(layout, ensure_ascii=False). This is the official example for a 1024 by 1024 canvas [1].

{
  "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"
}

Each box is [y_min, x_min, y_max, x_max] in pixels, measured from the center of the canvas. On a 1024 by 1024 canvas both axes run from -512 to +512, with x growing to the right and y growing downward [6]. Use the same width and height for the layout and for the image you request. One independent write-up calls the coordinate order the easiest place to slip [16].

Use the hosted API

MOSI's API platform serves the MOSS-Image models, and the README lists a playground and an API there [1] [13]. The official MOSS account (@MOSS_Global) posted on X on October 20, 2026 that the API is live for free, and the post appears in the community wall below. Terms and limits can change, so read the platform before you build on it.

Turn a MOSS-Image picture into a video on Effect Video

MOSS-Image makes still pictures. The current backbone does not take a reference image or edit one [7], so animation is a second step. Save the picture, then use it as the reference photo for image-to-video. Each effect below takes one photo, so a single MOSS-Image output is all you need.

1. Generate a picture that matches what the effect asks for. AI Car Driving wants one front three-quarter photo of a car with the full body in frame. AI Hamster Dance wants one sharp, eye-level shot of a single hamster sitting upright. AI Dance and AI Outfit Change want one full-length photo of an adult. AI Anime Transformation wants one clear adult portrait with face and shoulders visible. Each effect page lists its own requirements.
2. Describe the finished picture the way you would caption it, with the subject, pose, framing, light and setting. Keep the whole subject in frame under plain lighting. An example for the car effect: "A silver coupe seen from the front three-quarter angle, full body in frame, on an empty coastal road in natural daylight."
3. Save the picture to your device and check hands, faces and edges. The video step animates whatever the picture contains, flaws included.
4. Open the effect page, upload the picture into the photo slot, confirm the consent line and generate.
5. Download the finished MP4 within seven days, because results stay available for that long.

Start with a car picture. No person appears in it, and the effect needs only one front three-quarter view.

Make this video

One upright hamster picture becomes a short dancing clip.

Make this video

Each of these effects returns a short vertical clip, five seconds long when we checked. The pages for AI Dance, AI Anime Transformation and AI Outfit Change work the same way with a person in the picture.

If the picture shows a person, upload adults only. The effect pages ask you to confirm that you own the picture or have permission to use it, and that everyone shown agrees. A generated picture can still resemble a real person, so get consent from anyone it is meant to depict.

Want to steer the motion with your own words? The generator takes a text prompt plus one reference photo with Seedance 2.0 Mini, Seedance 2.0 Fast and Kling 3.0. Open the generator, upload the picture as the reference photo and describe the movement. The model pages list lengths and quality settings.

License, commercial use and image rights

The model weights and bundled inference code are released under Apache-2.0 [2]. The project page adds that the pipeline code and third-party components keep their own licenses [3]. The text encoder and VAE come from the Qwen and FLUX teams, whom the README thanks [1], so check their terms if you redistribute those files. The hosted API has its own terms on the MOSI platform [13]. This page is not legal advice.

Pictures of people need extra care. Upload adults only, and only pictures you own or have permission to use. The Effect Video effect pages ask you to confirm that when you upload.

What testers and creators report

The independent write-ups agree on setup. Both Japanese notes describe the ComfyUI route and say you need a recent build, since support landed in the main branch on October 16, 2026 and ships in 0.42.0 and later [14] [15].

On quality the notes are less uniform, partly because the testers used different checkpoints. Kamimoto tested Base on an RTX 4070 and found the anime output weak and the photoreal output decent but not clearly better than other recent models. He suggested waiting unless you train a LoRA, and he later added that a character LoRA changed his view [15]. hirorohi, writing from the 2D illustration side, calls MOSS-Image among the strongest local options for anime and illustration, with strengths and weaknesses. He found Base harder to use for clean illustrations than SFT [14].

Slow 50-step runs have drawn several community workarounds. The README's community list includes an 8-step DMD distillation of SFT and a Spectrum-style accelerator for ComfyUI [1]. The posts below show creators comparing few-step runs with the standard one, and Kamimoto reports that few-step runs tend to simplify the painting.

The three videos below cover the model in ComfyUI and as a local generator. The first, from the ComfyUI channel, announces ComfyUI support [17]. The third pairs a ComfyUI tutorial with a free Kaggle notebook, going by its title [19]. The second includes a sponsor message for a different product [18].

How this page was put together

This page collects public material. We read the official repository, the model cards and the technical report, ComfyUI's documentation, three independent write-ups, three YouTube videos and a set of X posts, compared what they say and summarized it. Quotes are short and credited, and every figure comes from a numbered reference. We did not run MOSS-Image or measure it ourselves.

Videos play in YouTube's official player and posts appear through X's public data. This page shows no MOSS-Image sample pictures; the official showcase lives on the project page and in the repository. Last checked on October 22, 2026. If a source changes or disappears, we update or remove the line that relied on it.