Have you ever had MOSS-Image give you a black or corrupted image after switching to fp16? You are not alone, and it is not your GPU. The base model runs extremely close to the fp16 limit.
MOSS-Image-heal is a full finetune by KohakuBlueleaf that repairs this. It keeps the same look and the same ComfyUI setup, but has about 20x more headroom, so fp16 is finally safe.
This guide explains the problem in plain words, the three files and which to pick, the exact ComfyUI setup with the --fp16-unet flag, how close it is to the original, and the fixes for common problems.
- What: KBlueLeaf/MOSS-Image-heal, a full finetune of MOSS-Image-Base that removes huge activation spikes. Apache 2.0.
- Why: base MOSS peaks at 58,411-61,696 inside the model, right next to the fp16 max of 65,504. Heal peaks around 3,083-3,278.
- Files:
moss_image_heal_bf16.safetensors(10.2 GB),moss_image_heal_fp16.safetensors(10.2 GB),moss_image_heal_int8_convrot.safetensors(5.4 GB). - Folder:
ComfyUI/models/diffusion_models/, loaded with Load Diffusion Model. Keep your MOSS text encoder and VAE. - fp16: start ComfyUI with
--fp16-unet. - Who needs it: GPUs without fast bf16 (RTX 20 and GTX 16 series) and anyone who got black fp16 images.
The fp16 Problem in Plain Words
Numbers in fp16 can only go up to 65,504. Anything bigger becomes “infinity”, and one infinity spreads through the whole image. The result is black or garbage output.
Inside MOSS-Image-Base, some values in the residual stream reach 58,411. That leaves only about 1.12x headroom. A slightly unusual prompt or setting can push it over the edge.
| MOSS-Image-Base | MOSS-Image-heal | |
|---|---|---|
| Largest residual value (author’s test) | 58,411 | 3,083 |
| Headroom below fp16 max | About 1.12x | About 21x |
| Peak value running in fp16 (probe) | 61,696 | 3,278 |
| Safe in fp16 | Risky | Yes |
bf16 has a much larger range, so it rarely overflows. That is why most guides, including my MOSS-Image ComfyUI guide, use bf16 or int8 files.
Who Should Use MOSS-Image-heal
- RTX 20 series and GTX 16 series owners. These cards have no fast bf16 support, so fp16 is the natural choice.
- Anyone seeing black or broken images with MOSS-Image in fp16.
- People who want the most accurate output. The author measured the fp16 heal file closest to an fp32 reference (error about 2.1e-3, vs about 1.7e-2 for bf16).
- LoRA trainers who train in fp16 and want stable numbers.
On RTX 30, 40 and 50 cards, bf16 already works well. For you, heal is optional; the int8 file is still the best size/speed choice. My bf16 speed guide for RTX 30/40 covers that side.
Files and Which One to Pick
All three are single-file safetensors in Comfy-Org’s key layout, so they drop into the official MOSS-Image workflow.
| File | Size | Best for |
|---|---|---|
moss_image_heal_fp16.safetensors |
10.2 GB | RTX 20 / GTX 16, or best accuracy with --fp16-unet |
moss_image_heal_bf16.safetensors |
10.2 GB | RTX 30/40/50 at full precision, LoRA work |
moss_image_heal_int8_convrot.safetensors |
5.4 GB | 12-16 GB cards; same layout as Comfy-Org’s int8 file (757 keys) |
Tip: a 10.2 GB model on an 8 GB card will offload to system RAM and slow down. On 8 GB, try the 5.4 GB int8 file first.
ComfyUI Setup (Step by Step)
If you already run MOSS-Image, this takes two minutes. Only the diffusion model changes.
- Download one heal file from the
comfyui/folder of KBlueLeaf/MOSS-Image-heal. - Put it in
ComfyUI/models/diffusion_models/. - Keep your text encoder in
ComfyUI/models/text_encoders/: the Comfy-Org Qwen3.5 9B encoder, for exampleqwen3.5_9b_int8_convrot.safetensors. - Keep your MOSS VAE in
ComfyUI/models/vae/(flux2-vae.safetensorsorflux2-vae_small.safetensors, as in the official workflow). - For the fp16 file, start ComfyUI with the flag:
python main.py --fp16-unetOn Windows portable, add
--fp16-unetto the end of the line inrun_nvidia_gpu.bat. - Open the official MOSS-Image workflow and switch the Load Diffusion Model node to your heal file.
Need a refresher on flags? My ComfyUI command line arguments guide lists them all.
Note: --fp16-unet affects every diffusion model you load in that session. Remove it if another model starts giving black images.
How Close Is It to the Original?
The author calls it a numerical repair, not a style retrain. Here are their numbers:
| Measure | Result |
|---|---|
| Flow loss | 0.4280 (base) to 0.4289 (heal) |
| Velocity cosine vs base | 0.9983 |
| fp16 heal vs fp32 reference | cosine 0.999996, relative error about 2.1e-3 |
| Probe size | Six samples (small) |
So images are very close to the base model, but not identical. The same seed can give small differences.
Training used 50,000 steps at 64 samples per step (3.2M samples) on about 999,294 Danbooru posts, captioned with Qwen3.8-27B and Qwen3.5-9B. That data is anime-heavy, so compare a few realistic prompts against the base before switching for photo work.
Settings and LoRAs
The author’s sample grids used these settings. They are not official recommendations, but they make a good start:
| Setting | Value |
|---|---|
| Steps | 16 |
| CFG | 3 |
| Shift | 5 |
| Resolution | About 1 megapixel (for example 1024×1024 or 1344×768) |
The model card does not say whether base MOSS-Image LoRAs work on heal. Because it is a light repair of the same model, many should load; test at lower strength and compare with the base.
Training your own? Both KohakuMoss and ZenTrainer support MOSS-Image, and heal makes fp16 training safer.
Want it faster too? The SPEED sampler supports MOSS Image and can cut render time by about a quarter to a third.
Troubleshooting
Still getting black images
Make sure the Load Diffusion Model node actually points to the heal file, not the old base. Also check the VAE is the MOSS one, and try without other speed hacks first.
fp16 is slow on my RTX 30/40
These cards run bf16 well. Use the bf16 or int8 heal file and drop --fp16-unet.
Out of memory
Switch to the 5.4 GB int8 file and a smaller text encoder (w4a8). My CUDA out of memory fix has more options.
Error about missing or unexpected keys
Use the files from the comfyui/ folder, which use Comfy-Org’s key layout. Other folders in the repo may be in a different format.
Images look slightly different from before
That is expected. Heal is about 99.8% aligned with the base, not 100%.
My Take
If you own an RTX 20 or GTX 16 card, MOSS-Image-heal is a must. It turns “maybe black, maybe fine” into a model you can trust in fp16.
On newer cards I would keep the int8 file for daily use, and still grab heal if you train LoRAs or ever saw a black image. It is free, Apache 2.0, and a drop-in swap.
FAQ
What is MOSS-Image-heal?
A full finetune of MOSS-Image-Base by KohakuBlueleaf that shrinks extreme internal values, so the model runs safely in fp16.
Why does MOSS-Image give black images in fp16?
Its internal values get within about 12% of the fp16 maximum. If they overflow, they become infinity and the image breaks.
Do I need a new text encoder or VAE?
No. Keep the same Qwen3.5 9B text encoder and MOSS VAE you already use.
Which file should I download?
fp16 for RTX 20/GTX 16 or best accuracy, bf16 for newer cards at full precision, and int8 (5.4 GB) for lower VRAM.
Is MOSS-Image-heal free for commercial use?
The model card lists Apache 2.0, the same as the official MOSS-Image weights.
Will my MOSS-Image LoRAs work?
The card does not say. Since heal is a light repair of the same model, many should work; test them at lower strength first.