MOSS-Image: Base, SFT and Local Image Generation

akhaliq/MOSS-Image-Edit-HQ is an unofficial instruction-based editing LoRA trained for MOSS-Image-SFT. Its current release is armV5 as checked on October 25. It adds a reference-image editing workflow to the existing SFT pipeline; keep the SFT backbone, Qwen3.5 text encoder and FLUX.2 VAE. Compatibility with Base and Kromoss is unverified in the adapter card.

Choose the file format that matches the loader. Native ComfyUI support merged in PR 17296 after the v0.42.1 tag: use a build containing that change, load the ai-toolkit checkpoint as a LoRA and set Text Encode MOSS-Image Edit to edit_format=ai-toolkit. The Chenkin-x plugin instead needs the converted moss-edit-lora file in models/model_patches, not models/loras; its guide requires ComfyUI 0.42.3 or newer.

The publisher’s native recipe uses 50 steps, CFG 3, Euler and SLG layer 22, with references downscaled to at most 384×384 by that path. The plugin recipe uses shift 5 and its own reference handling. Retain the matching workflow for the first trial rather than mixing the two recipes. Each V5 adapter is about 496MB on disk; the complete SFT pipeline and reference-image processing still determine runtime memory.

The adapter author publishes comparison grids and checkpoints, including earlier experiments. Those are publisher examples. Use your own source image and one checkable edit, then inspect identity, requested changes and untouched areas before running a batch. Keep the adapter revision, loader, reference size, output size and accepted-image count with the session cost.

MOSI lists MOSS-Image-Base-1.0 and MOSS-Image-SFT-1.0 as Beta, each at 0 credits with “Free for a limited time” on its model page. As checked on October 22, the pages do not provide a long-term price, offer end date or numerical free quota. Use the promotion for an initial trial; a continuing production budget needs the terms that apply after the offer.

Create a MOSI account and API key, then send a text prompt to POST https://api.mosi.cn/v1/images/generations. Use moss-image-base-1.0 or moss-image-sft-1.0; snapshots ending in -2026-10-09 pin the documented version. The endpoint returns one PNG image URL per request. Dimensions must each be 256–2048 pixels, multiples of 16, with at most 2,097,152 pixels in total. Streaming is not supported.

The example below uses SFT at 1024×1024. Inspect the returned image’s lettering and layout before sending a batch. The API documents rate and concurrency errors but does not turn the promotion into unlimited capacity. If a request times out, the task may still be running; check its state before submitting the same job again.

The hosted beta avoids provisioning a local pipeline for an initial trial. A local deployment instead incurs machine time, electricity or rental, storage and any idle allocation, even while the hosted promotion lists zero credits. Keep the two budgets separate: no permanent per-image API price can be inferred from the offer.

Gradio offers GPU-resident, component-offload and sequential memory modes. If the full pipeline does not fit, use offload or reduce image size; sequential mode trades memory for slower inference. Compile DiT is off by default and unavailable in sequential mode.

Measure loading time, generation time, peak memory and whole-system wall power on the exact checkpoint, resolution and memory mode. Download size and the DiT parameter count cannot establish a minimum GPU or a price per image. The 5B figure describes the DiT backbone, not the complete pipeline: the Qwen3.5-9B text encoder, FLUX.2 VAE and runtime also need memory.

For an assumed existing-machine run using 500 W for 12 minutes at $0.20/kWh, electricity costs $0.02. If ten images pass your checks, that is $0.002 of electricity per accepted image. Rented hardware also costs money while loading or waiting; include the full allocated time and any storage charges.

mirthtime reports the official SFT Diffusers script on an RTX 5090 with 32GB card capacity and 64GB system RAM, at 50 steps and CFG 3: warm generations took 67–82 seconds, with roughly 55 additional seconds for a cold start. Resolution, model precision, batch and offload settings are not given, and card capacity is not peak pipeline memory. This illustrates why loading belongs in a session budget; it is not a matched speed comparison with the ComfyUI adapter runs below.

OpenMOSS released both checkpoints together on October 16. MOSS-Image-Base is the base text-to-image model; MOSS-Image-SFT is fine-tuned from it on curated data. Start a general prompt trial with SFT, and consider Base when you want to adapt the model. The official cards show clearer text grouping in one SFT whiteboard example; compare your own prompts before choosing.

Use the exact repository name in your runner. The SFT file tree includes the transformer, text encoder, tokenizer, VAE and scheduler. Its displayed 27.2GB repository size is a download/storage figure, not measured peak GPU memory.

Clone the official repository, create a Python virtual environment and install its requirements. The custom Diffusers pipeline downloads code as well as weights; review that source before enabling trust_remote_code. The following request uses the SFT card’s pipeline and sampling defaults at 1024×1024.

Keep the model name, seed and generation settings with the saved image. Inspect the requested text, line breaks and layout before trying larger batches. For a graphical interface, install the repository’s UI dependencies and start Gradio with the checkpoint you chose.

ComfyUI master/nightly includes native MOSS-Image support: PR17095 merged into master on October 16. Use a build containing that change and the repackaged DiT, Qwen3.5-9B text encoder and FLUX.2 VAE from Comfy-Org. Kamimoto’s October 17 test notes that stable versions 0.41.0–0.41.2 did not yet contain it. For a separate installation path, the OpenMOSS repository offers a plugin with a complete-directory HF loader. For that plugin, download its example workflow and drag it into ComfyUI. In MOSS-Image HF Loader, point model_path at the complete local checkpoint directory containing transformer, text_encoder, tokenizer and vae.

The plugin exposes MODEL, CLIP and VAE to the workflow. A standalone transformer file is not a substitute for the complete directory expected by this loader. Keep the supplied sampling graph for the first run, then change one setting at a time.

The user guide recommends English prompts and supports natural language, tags and experimental JSON layouts. Put the exact words and intended line breaks in the prompt. A layout describes the overall scene in summary.caption and individual text or objects in items.

For the documented layout format, bbox_format is yxyx and bbox_coord_space is abs_centralized. Coordinates are pixels measured from the canvas center, not normalized fractions. Match the JSON canvas to the generation dimensions; for 1024×1024, each axis runs from −512 to +512. Paste the JSON into Gradio’s prompt field or serialize it as the Python prompt.

Use a small, checkable composition first: one title and one object. Examine spelling and placement, then add elements. The Base guide recommends at least 50 steps, CFG 3 as a starting point and image dimensions divisible by 16.

mearbode ran a 35-prompt set on an RTX 3060 12GB with 16GB system RAM, using XCEED123’s INT8 ConvRot model and the OpenMOSS ComfyUI plugin. The Base configuration used 50 steps, Euler / sgm_uniform, CFG 3, shift 5 and negative-branch layer 22 skipping. Reported times were 137 seconds at 1MP, about 230 seconds at 1.6MP and 340 seconds at 2.1MP, with roughly 9.7GB peak VRAM. The author kept seed 42 and included failed prompts, reporting problems with negation and specific clock times.

That post also tests a separate community eight-step DMD adapter. Its faster results do not describe the official Base or SFT defaults. In the replies, the early quantization author warns of slight quality loss in some cases and recommends the newer Comfy-Org files. Use the timings to understand that recorded configuration, rather than choosing an old quant solely for speed.

Kamimoto’s separate RTX 4070 12GB test used Base INT8 ConvRot plus the INT8 Qwen3.5-9B encoder and FLUX.2 VAE, at 832×1216, 50 steps, CFG 3, Euler and layer 22 skipping. The machine had an i3-12100F, 48GB RAM, Windows 11 and ComfyUI fc04da9. Images took about 50–52 seconds after model loading. The reported 11,600MiB is whole-GPU usage from nvidia-smi, including other apps, rather than isolated model memory. The author found missed poses and weak anime results in those prompts, so a completed image still needs a quality check.

These two workflows use different quantizations, software paths and system RAM. Keep download size, peak VRAM and system RAM as separate budgets; neither result establishes that every 12GB card can run the full BF16 pipeline. Reproduce one complete workflow before estimating batches or paying for a GPU rental.

Lodestones publishes MOSS-Image-SFT-8-steps-dmd as a community adapter. In an original Reddit test, Ant_6431 reports one-megapixel output in five seconds on a 4070 Super with eight steps, Euler and the simple schedule. The post does not give model precision, software revision or peak memory, so use it as a configuration lead rather than a guaranteed time or a complete hardware budget. It is separate from the official Base/SFT defaults and the earlier Base DMD case above.

Adapter strength also varies by example: the adapter author recommends 0.6–0.8 for the latest file, while Ant_6431 reports malformed bodies at those strengths and prefers 0.95. Compare outputs from the exact adapter file before applying a setting to a batch. Another reply reports 52 seconds in WanGP on an RTX 4060 8GB using SFT INT8 ConvRot, without an output resolution; that cannot establish a speed ratio against the 4070 Super case.

gosrum reports an RTX 5090 ComfyUI run at CFG 2.5 and 25 steps taking 6.25 seconds at the post’s 1024 size. With eight steps and CFG 1, the reported times are 1.26 seconds at 1024, 1.92 at 1248 and 2.71 at 1456. A follow-up reply identifies the adapter as lodestones/MOSS-Image-SFT-8-steps-dmd. Precision, peak memory, batch size, warmup and repeat count are not provided, so keep these timings scoped to that author’s SFT-adapter workflow, separately from Kromoss.

Lodestones’ Kromoss is a full fine-tune of MOSS-Image-Base at 1024 pixels, using the same pipeline, Qwen3.5-9B encoder and FLUX.2 small VAE decoder as the SFT release. Its card describes reducing Base blur. The full-model recipe uses 50 steps and CFG 3; compare its output on your own lettering and composition tasks before replacing an existing workflow.

The repository also provides 8-steps-dmd-lora.safetensors, a data-space DMD distillation adapter derived from Base. Its ComfyUI recipe uses Euler / simple, eight steps, CFG 1 and LoRA strength 1, without a negative branch. Keep this Kromoss/Base path separate from the MOSS-Image-SFT-8-steps-dmd adapter discussed above.

For native ComfyUI, the author lists separate diffusion-model, text-encoder and VAE files. The 5.4GB INT8 ConvRot file is the diffusion component, not the complete pipeline or its peak VRAM. Load the encoder and VAE as well, and record memory and time for the entire chosen workflow. The card licenses its weights and bundled inference code under Apache 2.0.

Early output comparisons are subjective: eduardcalimanX favors MOSS/SFT in an initial trial, while SlipperyGem describes Kromoss as more realism-oriented. Neither report supplies matched hardware or timing data; compare the same prompts before changing a style workflow.

The SFT model card states Apache 2.0 for its weights and bundled inference code. Keep the license and notices with any redistribution, and review the components used in your workflow. MOSI account terms, capacity limits and the duration of its hosted promotion are separate from the downloadable checkpoint’s license.