MOSS-Image Edit LoRA in ComfyUI: Edit Photos With Text and Up to 4 Reference Images

MOSS-Image arrived in ComfyUI as a text-to-image model, and until this week it could not edit a photo you already have. The MOSS-Image Edit LoRA changes that. Released on October 22, 2026 by the Hugging Face user chinoll, it is a 297 MB rank-64 adapter that teaches MOSS-Image to follow edit instructions such as “make it winter”, “change her jacket to red leather” or “turn this into a watercolour”. You can feed it up to four reference images, so you can also say “dress the person in image 1 in the outfit from image 2”. On the same day, Kijai’s pull request added native support to ComfyUI, and a separate node pack by Chenkin-x gives you ready-made workflows. In this guide I cover both routes: the exact files and folder paths, how to install each, how to write edit prompts that work, the settings to start with and what to do on a 16 GB GPU.

What Is the MOSS-Image Edit LoRA?

MOSS-Image is the open 5B image model from OpenMOSS, with a Qwen3.5-9B language model reading your prompt and support for JSON layouts. Out of the box it only generates images from text. The Edit LoRA is a small add-on that changes how the model treats extra images: instead of ignoring them, it uses them as the picture to edit (or as references to copy from), and follows your text instruction.

Here are the key facts:

What It Can and Cannot Edit

The model card lists the edits it was trained for: colours, outfits, lighting, seasons and visual style, and the ComfyUI Wiki adds facial expressions. In practice that covers a lot of everyday jobs:

• recolouring a car, a dress or a wall
• changing clothes while keeping the person
• turning day into night, or a sunny scene into a rainy one
• summer to winter, spring to autumn
• photo to anime, oil painting, watercolour or pixel art
• a neutral face to a smile or a surprised look

What it does not promise: adding new objects, removing objects, or combining two separate people into one scene. There is no benchmark yet. If you need object removal or insertion, a dedicated editing model such as Bria Fibo 2.0 is a better fit today.

How It Works

The LoRA was trained with a specific layout, which the ComfyUI code calls the Moss-Image-Edit format. The reference images are encoded by the VAE and placed in front of the image being generated, at timestep zero, so the DiT can “look at” them while it denoises. The text encoder only sees your instruction, not the images. That has one practical consequence: your prompt has to describe the edit on its own. The look of the subject comes from the reference latents, not from the text.

Because the adapter was trained in that exact layout, it only works properly when the node puts the references in the same place. That is why you need either the dedicated node pack or the new core node with the right edit_format. A plain LoRA loader on a normal MOSS-Image text-to-image graph will not edit anything.

Two Ways to Run It in ComfyUI

If you followed my MOSS-Image ComfyUI guide and already have the single-file models, try Route 2 first, because it reuses everything you downloaded. If you are starting from scratch, Route 1 is the documented path with workflows that match the author’s settings.

Route 1: Install the ComfyUI-Moss-Image-Edit Node Pack

Step 1: install the nodes. Open a terminal in your ComfyUI folder (the one that contains main.py) and run:

git clone https://github.com/Chenkin-x/ComfyUI-Moss-Image-Edit.git custom_nodes/ComfyUI-Moss-Image-Edit
python -m pip install -r custom_nodes/ComfyUI-Moss-Image-Edit/requirements.txt

Use the same Python that runs ComfyUI. On the Windows portable build, run the pip step from the ComfyUI_windows_portable folder instead: python_embeded/python.exe -m pip install -r ComfyUI/custom_nodes/ComfyUI-Moss-Image-Edit/requirements.txt. If you installed an earlier version into custom_nodes/Moss-Image-Edit, move that old folder out of custom_nodes first, or the nodes register twice.

Step 2: download the base model and the LoRA. From the same ComfyUI folder, with the Hugging Face CLI:

hf download OpenMOSS-Team/MOSS-Image-SFT --local-dir models/moss_image/MOSS-Image-SFT

hf download chinoll/Moss-Image-Edit adapter_config.json adapter_model.safetensors --local-dir models/moss_image/Moss-Image-Edit

When it finishes, your folders should look like this:

ComfyUI/
├── custom_nodes/ComfyUI-Moss-Image-Edit/
└── models/moss_image/
    ├── MOSS-Image-SFT/
    │   ├── pipeline_moss_image.py
    │   ├── transformer/
    │   ├── text_encoder/
    │   ├── tokenizer/
    │   ├── vae/
    │   └── scheduler/
    └── Moss-Image-Edit/
        ├── adapter_config.json
        └── adapter_model.safetensors

The SFT download is the full Diffusers model, including the bf16 transformer and the Qwen3.5-9B text encoder, so it is much bigger than the single-file int8 weights. Make sure you have the disk space before you start. To use MOSS-Image-Base instead, download OpenMOSS-Team/MOSS-Image-Base to models/moss_image/MOSS-Image-Base.

Step 3: load a workflow. Restart ComfyUI. The pack ships two workflows: moss_edit_single_reference.json (one image to edit) and moss_edit_multi_reference.json (two images). The nodes sit in the MOSS Image Edit category. In the loader node, snapshot_dir points at the base model folder and adapter_dir at the LoRA folder. Relative paths are read from ComfyUI/models, so the defaults are moss_image/MOSS-Image-SFT and moss_image/Moss-Image-Edit. If you use Base, change snapshot_dir to moss_image/MOSS-Image-Base.

Step 4: edit. Load your photo into the reference input, type the instruction in prompt (leave negative_prompt empty to start), and queue.

Route 2: Native ComfyUI Nodes

Kijai’s pull request #17296, “Support MOSS-Image edit LoRAs”, was merged on October 22, after the v0.42.1 release tag. So you need a ComfyUI build newer than v0.42.1: run update/update_comfyui.bat on the portable build, git pull in a git install, or switch ComfyUI Desktop to the nightly channel until the next release.

Files: use the normal MOSS-Image single files from Comfy-Org/MOSS-Image, and copy the LoRA into your loras folder with a clear name:

hf download Comfy-Org/MOSS-Image diffusion_models/moss_image_sft_bf16.safetensors --local-dir ComfyUI/models
hf download Comfy-Org/MOSS-Image text_encoders/qwen3.5_9b_int8_convrot.safetensors --local-dir ComfyUI/models
hf download Comfy-Org/MOSS-Image vae/flux2-vae.safetensors --local-dir ComfyUI/models
hf download chinoll/Moss-Image-Edit adapter_model.safetensors --local-dir ComfyUI/models/loras/moss-image-edit

Then rename ComfyUI/models/loras/moss-image-edit/adapter_model.safetensors to moss_image_edit.safetensors so you can find it in the list. The PR added aliases for this LoRA’s bare key names, so the stock loader reads it directly.

The graph:

1. Load Diffusion Model with the MOSS-Image SFT transformer.
2. LoraLoaderModelOnly with moss_image_edit.safetensors at strength 1.0.
3. Load CLIP with the Qwen3.5-9B encoder, type moss_image.
4. Load VAE with flux2-vae.safetensors.
5. Load Image for your photo (and up to three more for extra references).
6. Text Encode MOSS-Image Edit (category model/conditioning/moss_image, marked experimental). Connect clip, vae and your images, type the instruction in prompt, and set edit_format to Moss-Image-Edit. The other options, ai-toolkit and ai-toolkit (kv_cache off), are for adapters trained with ai-toolkit, not this one.
7. Your usual sampler setup and VAE Decode, as in a normal MOSS-Image graph.

The images connect straight to the text encode node. You do not need a separate latent input for them. I chose the bf16 transformer here because LoRAs are the reason that file exists in the repo. If you want to try the 5.4 GB moss_image_sft_int8_convrot.safetensors to save memory, test it, and switch back to bf16 if the edit does not take.

All Files and Paths in One Table

Settings to Start With

These are the node pack’s defaults, which match how the author sampled the examples:

For the core route there are no official numbers yet. Start with the same values (30 steps, CFG 4, shift 5 in your model sampling node) and the sampler you already use for MOSS-Image. The 4-step and 8-step speed LoRAs from my MOSS-Image guide were trained for text-to-image, so test them carefully before stacking them with the Edit LoRA.

Writing Edit Prompts

Remember that the text encoder does not see your image. Write the instruction as if you were telling a retoucher what to change, without describing the whole photo:

• Say what changes, and what stays. “Change the jacket to red leather, keep the face, hair and background the same.”
• One edit per pass. Do the outfit first, then the lighting in a second run using the result as the new reference.
• Be specific about style. “Turn the photo into a soft watercolour painting with visible paper texture” works better than “make it artistic”.
• Use the categories it was trained on. Colour, outfit, lighting, season, style and expression are its strengths.

Some example instructions to try:

Make it a snowy winter day. Add snow on the ground and rooftops, keep everything else the same.
Change the car's paint to matte black.
Relight the portrait with warm golden hour sunlight coming from the left.
Turn the photo into a 90s anime screenshot.
Make the woman smile warmly, keep her face and pose the same.
Change her dress to a green silk evening gown.

Using 2 to 4 Reference Images

With more than one image, the adapter does not decide on its own which image is the photo to edit and which is the reference. You have to say it in the prompt by number, in the order the images are connected:

Dress the person in image 1 in the outfit from image 2.
Apply the colour palette and lighting of image 2 to the room in image 1.
Give the man in image 1 the hairstyle from image 2 and the glasses from image 3.

In the node pack, start from moss_edit_multi_reference.json. It has two references wired up. For three or four, add Load Image nodes and connect them to the spare reference_3 and reference_4 inputs. In the core route, the Text Encode MOSS-Image Edit node adds a new image input each time you connect one, up to four.

Keep the references clean: one clear subject, good lighting, and the outfit or object you want copied clearly visible. Each extra reference also costs memory and time, so use only as many as you need.

Running It on a 16 GB GPU

Neither the LoRA author nor the PR gives a VRAM figure, and the PR’s review notes warn that reference editing can run out of memory. On a 16 GB card like my RTX 5080, these are the levers:

• Prefer the core route with single files. The int8 text encoder (9.75 GB) or the W4A8 one (7.3 GB) is lighter than the full bf16 Diffusers folder the node pack loads.
• Stay at 512 to 768 pixels while testing, with reference_max_edge at 512.
• Use one reference unless the edit really needs more.
• Start ComfyUI with --lowvram so the text encoder is moved out of VRAM before sampling.
• More general fixes are in my 16 GB out of memory guide.

Troubleshooting

• The output ignores my photo and makes a new image: the references are not reaching the DiT. In the core route, check that you used Text Encode MOSS-Image Edit with edit_format set to Moss-Image-Edit, and that ComfyUI is newer than v0.42.1.
• The LoRA shows “lora key not loaded” warnings: your ComfyUI is older than the PR that added the key aliases. Update it.
• Nodes appear twice in the node pack: an old custom_nodes/Moss-Image-Edit folder is still there. Move it out.
• “snapshot_dir not found”: the loader reads relative paths from ComfyUI/models. Check that the folder is ComfyUI/models/moss_image/MOSS-Image-SFT and contains transformer/, text_encoder/ and vae/.
• Image 2’s subject replaces image 1’s: your prompt did not assign roles. Name each image by number.
• The edit is too weak: raise CFG a little (4.5 to 5), make the instruction more specific, or try more steps.
• Out of memory: lower the resolution, use one reference, use the lighter text encoder and --lowvram.

License Notes

The node pack and the training code are released under GNU GPLv3. The LoRA’s model card does not state a separate licence for the weights. MOSS-Image itself is Apache 2.0 according to OpenMOSS. If you plan to use edited images commercially, check the LoRA page for a licence update or ask the author first, since a missing licence is not the same as permission.

FAQ

What is the MOSS-Image Edit LoRA?

It is a 297 MB, rank-64 community LoRA by chinoll that adds instruction-based image editing with up to four reference images to the MOSS-Image model.

Does ComfyUI support it natively?

Yes, from builds after v0.42.1. Kijai’s PR #17296 added the Text Encode MOSS-Image Edit node and the LoRA key aliases. You can also use the ComfyUI-Moss-Image-Edit node pack.

Should I use MOSS-Image-SFT or Base?

Start with SFT. The examples were trained and sampled against SFT and it gives tidier results. Base keeps more of the raw training signal and is mainly useful if you want to experiment.

Can it remove or add objects?

It is not documented for that. It is built for attribute and scene edits: colour, outfit, lighting, season, style and expression.

How many reference images can I use?

Up to four. With more than one, name each image’s role in the prompt, for example “the person in image 1 wearing the outfit from image 2”.

Where do I put the LoRA file?

For the node pack, put both files in ComfyUI/models/moss_image/Moss-Image-Edit/. For the core nodes, put adapter_model.safetensors in ComfyUI/models/loras/ (renaming it helps) and load it with LoraLoaderModelOnly.

Final Thoughts

The MOSS-Image Edit LoRA turns MOSS-Image from a generator into a practical photo editor for colour, outfit, lighting, season and style changes, and the multi-reference support makes outfit swaps easy. It is young and unofficial, with no benchmark or VRAM numbers yet, but both routes in ComfyUI work today. Use the node pack if you want the author’s workflows, or the core nodes if you already run MOSS-Image natively, and keep your prompts short, specific and clear about which image is which.

More MOSS-Image and image editing guides:

• MOSS-Image in ComfyUI: Files, Settings, Layout JSON and 4-Step LoRAs
• Train a MOSS-Image LoRA With KohakuMoss
• Bria Fibo 2.0 in ComfyUI: Generate and Edit Images
• FLUX 3 Image Klein in ComfyUI

Sources

• Hugging Face: chinoll/Moss-Image-Edit (model card)
• GitHub: Chenkin-x/ComfyUI-Moss-Image-Edit (README)
• GitHub: Chenkin-x/Moss-Image-Edit (training and inference code)
• GitHub: ComfyUI PR #17296, Support MOSS-Image edit LoRAs
• Hugging Face: Comfy-Org/MOSS-Image
• ComfyUI Wiki: MOSS-Image Edit LoRA news