Run MOSS-Image Locally on Windows 11, Mac and Kali Linux: the ComfyUI Nightly It Needs, int8 and GGUF Files for 8 to 12 GB GPUs, Text in Images, JSON Layouts and the 8-Step LoRA

MOSS-Image is a new open image generator from the OpenMOSS team, released on October 16, 2026 under the Apache 2.0 license: a 5-billion-parameter model that turns a text prompt into a picture, writes readable English and Chinese text inside the image, and accepts a JSON layout that says where each piece of text or object goes. You can run it locally today in ComfyUI on an NVIDIA card with 8 to 12 GB of VRAM, or on a Mac. Two things surprise people on the first evening. First, the stable ComfyUI release cannot load it: support was added on October 16, after the latest release (v0.41.0) shipped, so you need ComfyUI's newest development version. Second, the part of the download that never draws anything is the biggest: the model reads your prompt with Qwen3.5-9B, a 9-billion-parameter text encoder that is larger than the 5B image model itself, 16.78 GB at full precision. This page has the exact files for your graphics card, the ComfyUI update that makes it work, the settings that matter, how the text and layout features work, the 8-step speed-up, and fixes for the errors people hit first.

Jake's computer shop prints its own signs: "Screen repairs while you wait," "Back in 10 minutes," prices for the festival sale. Every image model he had tried could draw a nice shopfront and then spell "REPAIRS" as "REPIARS." Ethan, his developer friend, set up MOSS-Image on the shop PC on Friday because its whole pitch is text that comes out right, placed where you ask. It took two tries to load. This page is what fixed the first one.

New to ComfyUI? Our ComfyUI install guide gets the app and its Manager running in about fifteen minutes, and our free local AI series explains VRAM, quantization and model files in plain English. Come back here once ComfyUI opens in your browser.

What MOSS-Image is, and what it is good at

MOSS-Image is a text-to-image model: you describe a picture, it generates it. Under the hood it is a 5-billion-parameter diffusion transformer (the same family of design as FLUX), trained with a method called flow matching, and it works in the same compressed image space as FLUX.2, which is why it uses the FLUX.2 VAE to turn its output into pixels. It comes in two versions:

• MOSS-Image-SFT, the fine-tuned version for everyday use. It gives cleaner layouts and tidier text grouping. Start here.
• MOSS-Image-Base, the raw pretrained model. It is the one to fine-tune or train LoRAs on, and some people prefer its looser, less polished style.

What makes it worth trying alongside FLUX and Qwen-Image is the way it reads prompts. It accepts three kinds:

• Natural language, the usual sentence or paragraph describing the scene.
• Tag sequences, the comma-separated style many image-model users already write.
• JSON layouts, where you give a caption for the whole image and then a list of items with their text and a bounding box, so the model puts each one where you said. That is the feature for posters, signs, slides and product mock-ups, and it has its own section below.

It renders text in both English and Chinese, accepts an optional negative prompt, and works at any resolution that is a multiple of 16, from square 1024 by 1024 up to the 1456 by 1456 used in its own examples. The license is Apache 2.0 for the weights, which is about as permissive as it gets: you can use the images commercially and build products on the model, with no revenue limit.

"It's the first one that doesn't need me to fix the spelling afterwards," Jake said. "It's the first one that lets you say where the spelling goes," said Ethan.

Which files to download for your graphics card

A MOSS-Image setup is three files: the image model, the text encoder, and the VAE. The image model is small for 2026; the text encoder is not. Qwen3.5-9B is a full language model in its own right, and at full precision it is 16.78 GB, against 10.16 GB for the image model. ComfyUI handles this well: it runs the encoder once to read your prompt, then moves it out of the way before the image model starts drawing, so the two never have to fit in VRAM at the same time. That is why a 12 GB card works even though the files add up to more than 15 GB.

Where each file comes from:

• Comfy-Org/MOSS-Image on Hugging Face has the repackaged ComfyUI files: the image models in bf16 (10.16 GB) and int8 ConvRot (5.41 GB) for both SFT and Base, the two text-encoder versions (int8 ConvRot 9.75 GB, w4a8 GPTQ 7.34 GB), and the FLUX.2 VAE (0.34 GB). This is the repository most people should use.
• realrebelai/MOSS-Image_GGUFs has GGUF versions of both models, from Q2_K (2.25 GB) to Q8_0 (5.71 GB), with Q4_K_M at 3.70 GB as the balanced choice for 8 GB cards. GGUF image models load through the ComfyUI-GGUF custom node, not ComfyUI's built-in loader.
• OpenMOSS-Team/MOSS-Image-SFT and -Base are the original repositories in Diffusers format, for the Python route.

"int8 ConvRot" is a ComfyUI quantization format: 8-bit weights with a rotation trick designed to keep quality close to bf16, at about half the size. ComfyUI's int8 path is tuned for NVIDIA cards from the GTX 16 and RTX 20 series onward. On a Mac, ComfyUI switches int8 computation off because Apple's GPU backend lacks the operation it needs, so the file's memory saving does not apply there; plan Mac memory around the 16-bit sizes.

Run MOSS-Image in ComfyUI on Windows 11

This is the route for most people. The one step nobody expects is the first one.

1. Update ComfyUI to the development version. MOSS-Image support was merged on October 16, after ComfyUI v0.41.0 was released, so the stable release does not have it yet. In ComfyUI Manager, choose Update ComfyUI and switch the update channel to nightly (or "latest"), then restart. For a git install, run git pull in the ComfyUI folder and then pip install -r requirements.txt. For the Windows portable build, run update\update_comfyui.bat. If you skip this step, ComfyUI still starts, but the model fails to load with an error that it cannot detect the model type.
2. Download the three files for your card from the file table.
3. Put each file in its folder: the image model in ComfyUI\models\diffusion_models\, the text encoder in ComfyUI\models\text_encoders\, and the VAE in ComfyUI\models\vae\.
4. Load a MOSS-Image workflow. After the update, look in the workflow templates (Workflow > Browse Templates) for MOSS-Image. The workflow template packages were refreshed on October 16 and 17; if you do not see it yet, update the templates from the Manager. Without a template, build it by hand: Load Diffusion Model > your image model; Load CLIP (text encoder) > the Qwen3.5-9B file, with the type set to MOSS-Image; Load VAE > flux2-vae; then the usual prompt, sampler and VAE Decode nodes.
5. Generate. Use the settings in the next section. The first run is slower while files load from disk.

For the 8 GB GGUF setup, install the ComfyUI-GGUF custom node from the Manager first, and use its Unet Loader (GGUF) node in place of Load Diffusion Model. GGUF support for a brand-new architecture depends on the custom node being updated too; if the GGUF loader refuses the file, update ComfyUI-GGUF, and if it still refuses, use the int8 file with ComfyUI's memory offloading instead, which is slower on an 8 GB card but works.

There is a speed improvement on the way for int8 files: a fused kernel merged on October 17 makes MOSS-Image about 30% faster with int8 models once the matching comfy-kitchen package update reaches you. Updating ComfyUI again in a few days picks it up.

The settings that matter

MOSS-Image was released with clear default settings, and they are different enough from FLUX to be worth copying exactly:

In ComfyUI, a MOSS-Image template sets the shift for you; if you build the workflow by hand, add a model-sampling shift node set to 5 between the model loader and the sampler. Leave the CFG at 3.0 for the 50-step model: higher values make text harsher and colors oversaturated, lower values make it drift from the prompt. Keep a fixed seed while you tune a prompt, so you can tell whether a change came from the words or from chance.

Getting text right, and placing it with a JSON layout

Text is MOSS-Image's strong suit, and two habits make it reliable.

Put the exact words in quotes

Write the text you want in the image inside double quotes, and say what it is: A hand-painted shop sign above a phone repair counter that reads "SCREEN REPAIRS WHILE YOU WAIT", warm evening light. Short phrases come out more reliably than paragraphs; for a sign with three lines, describe each line separately. Chinese works the same way, inside quotes.

Use a JSON layout to say where things go

For anything with a layout (a poster, a slide, a price board), describe the picture in a caption and list each element with a bounding box. The coordinates are measured from the center of the canvas, x to the right and y downward, in pixels, and each box is written as [y1, x1, y2, x2] (top, left, bottom, right). For a 1024 by 1024 image, the canvas runs from -512 to 512 in both directions. A two-line poster:

{
  "summary": {
    "caption": "A bright festival sale poster for a small phone repair shop, orange and green, clean flat design"
  },
  "items": [
    {"label": "text", "text": "FESTIVAL SALE", "bbox": [-400, -420, -220, 420]},
    {"label": "text", "text": "Screen repairs from $49", "bbox": [-120, -360, -20, 360]},
    {"label": "text", "text": "Open 9 am to 9 pm", "bbox": [300, -300, 380, 300]}
  ],
  "bbox_coord_space": "abs_centralized",
  "bbox_format": "yxyx"
}

Paste the JSON as the prompt. In ComfyUI, the MOSS-Image example workflow that shipped with the support (a text-to-image workflow with bounding boxes) shows the same idea with nodes. Three tips: keep boxes for text wide and short, the shape of the words; leave space between boxes, because the model fills a box with its item; and keep the caption about the whole scene, not repeating the texts, which the items already carry.

Jake's festival poster came out on the second try with every word spelled right. The first try had the price in a box too narrow for it, and the model squeezed the letters into a tall thin column. "So the box is the font size," Jake said. "The box is everything," said Ethan.

The 8-step LoRA: about six times fewer steps

Fifty steps at 1024 by 1024 is slow on a mid-range card. Within a day of the release, a community distillation appeared that gets usable images in 8 steps with no CFG: lodestones/MOSS-Image-SFT-8-steps-dmd on Hugging Face, Apache 2.0, made with a technique called DMD (distribution matching distillation). Because CFG is off, each step is also cheaper, so the total speed-up is larger than 50 divided by 8.

1. Download lora.safetensors (1.19 GB) from the repository into ComfyUI\models\loras\. There is also lora_latest.safetensors, a newer checkpoint meant to be used at strength 0.7.
2. Add a LoraLoaderModelOnly node after your MOSS-Image SFT model loader and select the LoRA, strength 1.0 (or 0.7 for lora_latest).
3. Set the sampler to 8 steps and CFG 1.0, Euler, shift 5.

Its author calls it a work in progress, and it trades some detail and text precision for speed: use it to explore ideas and compositions quickly, then render the final image with the full 50 steps on the same seed. The repository also has a full transformer version, but that one must be loaded and run in fp32, which takes far more memory; the LoRA is the practical route. There is also a ready-made "Turbo" int8 file from another uploader (moss_image_sft_turbo_int8_convrot, 5.41 GB) if you prefer a single model file to a LoRA.

Run it with Python and Diffusers

If you want to script image generation (a batch of product images, or an app), the official repositories load in Diffusers with a custom pipeline. This needs an NVIDIA card with plenty of VRAM, or the CPU offload modes described below.

git clone https://github.com/OpenMOSS/MOSS-Image.git
cd MOSS-Image
python -m venv .venv
.venv\Scripts\activate          # Windows;  macOS/Kali: source .venv/bin/activate
pip install -r requirements.txt

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.to("cuda")

image = pipe(
    'A shop window sticker that reads "OPEN 7 DAYS", white vinyl on glass, street reflections',
    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("sticker.png")

Two details are easy to miss. The torch_dtype is a dictionary: the transformer and text encoder run in bf16, the VAE in fp32, and forcing everything to bf16 costs image quality. And uncond_skip_layers=[22] is the negative-branch layer skip from the settings table; leave it in.

The full-precision pipeline holds about 27 GB of weights (16.78 GB encoder, 10.16 GB image model, 0.25 GB VAE), more than most cards. The repository's app offers three memory modes: everything resident on the GPU (fastest), component mode, which moves each part onto the GPU only while it is needed, and sequential mode, the slowest and smallest. For a browser interface without ComfyUI, run pip install -e '.[ui]' and then python gradio_app.py --model OpenMOSS-Team/MOSS-Image-SFT.

Run it on Kali Linux

On Kali, ComfyUI is the same app with the same files, installed with git and a virtual environment. Kali's Python refuses system-wide pip installs, so the virtual environment is not optional; our guide to that pip error explains why.

sudo apt update && sudo apt install -y git python3-venv
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv .venv && source .venv/bin/activate
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
python main.py --listen 127.0.0.1 --port 8188

A fresh clone from October 16 onward already includes MOSS-Image support; an older clone needs git pull and pip install -r requirements.txt again. Pick the PyTorch build that matches your NVIDIA driver (the cu128 line above is for recent drivers), then put the model files in models/diffusion_models, models/text_encoders and models/vae as on Windows, and open http://127.0.0.1:8188. If Kali runs in a virtual machine, image generation needs the GPU on the host; run ComfyUI there and open it from the VM's browser.

Run it on a Mac

ComfyUI runs on Apple silicon through PyTorch's Metal backend. Use the bf16 image model (10.16 GB). For the text encoder, the Comfy-Org repository only offers the int8 and w4a8 files; ComfyUI turns int8 weight-only computation off on Macs, because the operation it relies on is missing from the Metal backend, so budget memory as if the encoder were its full 16-bit size, about 17 GB. That makes a Mac with 32 GB of unified memory the practical minimum, and 48 GB or more comfortable. If the encoder will not load on your Mac, the Python route below, which uses the official repository's own files, is the fallback.

Install the ComfyUI desktop app for macOS, switch it to the newest version as on Windows, place the files in the same folders, and use the same workflow. Expect it to be slower than a mid-range NVIDIA card at 50 steps; the 8-step LoRA helps most here. The Python route works on a Mac too, with pipe.to("mps") in place of "cuda".

MOSS-Image vs FLUX 3 Image Klein and Qwen-Image

Three open image models arrived within a few weeks of each other, and they suit different jobs:

• MOSS-Image (5B, Apache 2.0): the strongest pitch is layout control with JSON boxes, and English and Chinese text. Its 9B text encoder is the heaviest part of the setup. No published benchmark scores yet, so judge it on your own prompts.
• FLUX 3 Image Klein (5.6B): very fast, good for 8 GB cards, with editing and bounding-box features; its license is free only below a revenue limit. Our FLUX 3 Image Klein guide has the setup.
• Qwen-Image 2.1: strong text rendering too, with a fast Turbo version; see our Qwen-Image 2.1 Turbo guide.

If the license matters to your business (images for paying customers, or a product built on the model), MOSS-Image's Apache 2.0 with no revenue condition is a real advantage. If speed on a small card matters most, Klein is the easier daily driver. For signs, posters and anything where words must land in a particular place, MOSS-Image is the one to try first.

Errors and fixes

The problems that come up most in the first days.

"Could not detect model type" or the model will not load in ComfyUI

Your ComfyUI is older than October 16. The stable v0.41.0 release does not include MOSS-Image. Switch the Manager's update channel to nightly and update, or git pull, then restart ComfyUI fully.

The text encoder will not load, or the CLIP loader has no MOSS-Image type

Same cause: the update adds the MOSS-Image text-encoder type. Update, restart, and set the type in the Load CLIP node. Also check that the file is in models/text_encoders, not models/clip on an old layout.

Out of memory on an 8 GB or 12 GB card

Use the smaller files from the file table: the w4a8 encoder (7.34 GB) and a Q4_K_M GGUF or the int8 image model. Close other GPU apps (browsers with hardware acceleration count), lower the resolution to 1024 by 1024, and let ComfyUI's automatic offloading do its job instead of forcing high-VRAM mode.

The GGUF file will not load

GGUF image models need the ComfyUI-GGUF custom node, and that node must know the MOSS-Image architecture. Update it from the Manager. If it still fails, use the int8 file instead.

Text is misspelled or garbled

Put the exact words in double quotes, keep each phrase short, use the SFT model, and give text its own wide bounding box in a JSON layout. The 8-step LoRA is weaker at text than the full 50 steps; render the final version at 50.

Images look washed out or oversaturated

Check CFG (3.0 for the 50-step model, 1.0 with the 8-step LoRA), the shift of 5, and that the VAE is flux2-vae. A FLUX.1 or SDXL VAE produces muddy colors.

int8 files fail on a Mac or an old GPU

ComfyUI's int8 path is tuned for NVIDIA GTX 16 and RTX 20 series cards and newer. On an older card, use the bf16 image model or a GGUF; on a Mac, see the Mac section.

Frequently asked questions

The festival sale poster went up in the shop window on Saturday morning, printed from a 1456 by 1456 render with three boxes of text, every word in place. A customer asked who had designed it. "A computer," Jake said, "with very strict instructions." Ethan laughed. "Most of the design was the boxes."

Revision note. Written October 17, 2026, the day after MOSS-Image's release. "A place for everything, and everything in its place," the proverb says; this is the first image model that takes it literally.