MOSS-Image-Base

MOSS-Image-Base

Draws images from text with a 5.1B text-to-image model that takes plain prompts, tag sequences or JSON layouts to place text and objects. For developers and designers with an NVIDIA GPU.

Made by OpenMOSS-Team 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: MOSS-Image-Base draws pictures from text. It is the starting model of OpenMOSS's MOSS-Image family, with 5.1B parameters, and it runs through the diffusers library. You can prompt it with plain sentences, tag sequences or JSON layouts, and the layouts let you decide where text and objects sit.

Who it suits: It suits designers and developers who want pictures with text placed on purpose, such as whiteboard-style graphics, and teams who want a base model to fine-tune or compare.

Industry | Who uses it | How they use it | Example
Design | Designers making graphics | Describe a picture and say where the text goes | A whiteboard graphic with grouped labels
Software | Developers adding image features | Load the model through diffusers in Python | A text-to-image step inside an internal tool
Research | Teams working on image models | Start from the base model before fine-tuning | Compare Base with the SFT version

Anyone without an NVIDIA GPU can skip running it locally, since the quick start calls for CUDA.

Where to use it:

• Python with the diffusers library on an NVIDIA GPU with CUDA
• ComfyUI, which the card links a guide for
• A demo on Hugging Face Spaces
• Windows, macOS or Linux, where you can download the files with Python

Use case | Who | What they get back
Text-heavy images | Designers | Pictures with text placed by a JSON layout
Tag-style prompts | Experienced image users | Images made from a tag sequence instead of sentences
Model comparison | Researchers | Base and SFT outputs for the same prompt

How to set it up: You need these first:

• Python 3.10 or newer
• An NVIDIA GPU with CUDA support
• A PyTorch build, version 2.9 or newer, that matches your CUDA setup
• The huggingface_hub package, if you want to download the files yourself

1. Install PyTorch to match your CUDA environment.
2. Install the libraries the card lists with the pip command below.
3. Optionally download the weights first with the Hugging Face tool. They take about 10.2 GB in BF16.

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

pip install -U huggingface_hub
hf download OpenMOSS-Team/MOSS-Image-Base

How to use it: Load the pipeline in Python, move it to the GPU, then give it a prompt in one of the three styles. The card's quick start loads the model like this, and its generation call follows after these lines.

import torch
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "OpenMOSS-Team/MOSS-Image-Base",
    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")

Tool | What it does
DiffusionPipeline | Loads the model with the card's own custom pipeline
trust_remote_code | Lets the pipeline run code that ships with the model
pipe.to | Moves the model onto the GPU

Example: You describe a whiteboard scene in a sentence, or use a JSON layout to say where each piece of text and each object sits. The model returns an image that follows that layout. The card shows the SFT version grouping the text more clearly than Base in one whiteboard comparison.

For newcomers and experts: This is a model that draws pictures from a written description. To start, set up the libraries, load the pipeline with the code above, then describe one simple scene in a sentence and look at what comes out.

Under the hood it is a diffusers pipeline with a custom pipeline file, so the weights load in bfloat16 while the VAE stays in float32. The scheduler is rebuilt from its own config before the model moves to CUDA. Base is the raw model, and the card points to MOSS-Image-SFT for cleaner text grouping in its example.

Write a prompt, tags or a JSON layout
Load the pipeline with diffusers
Move it to the CUDA GPU
Generate the image

Good to know:

• Size: 5.1B parameters, about 10.2 GB in BF16 and about 2.5 GB at 4-bit, as an estimate
• Languages: English and Chinese are listed
• Versions: Hugging Face lists 16 quantized and 50 fine-tuned versions made by other people

Title: Weight size in GB
BF16: 10.2 GB
4-bit estimate: 2.5 GB

• License: apache-2.0
• Cost to run: none named for a local run. The card also lists an API platform and a Hugging Face demo as other ways to try it
• Data it reaches: it downloads model files from Hugging Face, and the example sets trust_remote_code to True so it runs the pipeline code that ships with the model
• Not for: machines without an NVIDIA GPU and CUDA, since the quick start asks for both

On Hugging Face, 13 November 2026

• Task: text to image
• Library: diffusers
• Parameters: 5.1B
• Weights: about 10.2 GB in BF16; about 2.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 13,535
• Likes: 656
• License: apache-2.0
• Languages: en, zh
• Quantized versions: 16
• Fine-tunes: 51
• Tags: diffusers, safetensors, moss-image, text-to-image

Links

• Model: https://huggingface.co/OpenMOSS-Team/MOSS-Image-Base
• Files: https://huggingface.co/OpenMOSS-Team/MOSS-Image-Base/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download OpenMOSS-Team/MOSS-Image-Base

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