Anima RGBA in ComfyUI: Generate Transparent PNGs With No Custom Nodes

Getting a clean transparent PNG out of an image model usually means generating on a flat background, then cutting it out with a background-removal node. Hair and soft edges almost always come out ragged.

Anima RGBA skips that step. It is a 4-channel VAE plus a matching LoRA for the Anima anime model, so ComfyUI writes a real RGBA PNG with an alpha channel straight from the sampler. It needs no custom nodes.

This guide covers the two files and where they go, the exact workflow changes, the settings the author tested, the measured alpha quality, what it still gets wrong, and fixes for the common problems.

What Anima RGBA Does

Anima is an anime and illustration model fine-tuned from NVIDIA’s Cosmos-Predict2-2B text-to-image model. It normally uses the Qwen-Image VAE, which has three colour channels: red, green and blue. There is nowhere to store transparency.

Anima RGBA gives you two pieces:

• A 4-channel VAE (encoder and decoder) that decodes RGB plus alpha. It keeps the same 16-channel latent at 1/8 resolution and uses the Qwen-Image VAE key format, so it drops into Anima’s existing graph.
• A LoRA for the Anima DiT that teaches the model to actually draw isolated subjects when you ask for a transparent background.

You need both. The VAE alone still produces alpha, but it is hazy, and without the LoRA the model has no idea it should leave the background empty.

If you already use Anima for characters, it pairs nicely with the Anima Reference Adapter v2, which keeps the same character across images. Transparent output is exactly what you want for stickers, sprites and character sheets.

Files and Folders

The RGBA VAE replaces the Qwen-Image VAE (qwen_image_vae.safetensors) that Anima normally loads. Keep the old one too, because you still want it for normal opaque images.

Both add-on files are small. Anima itself is a 2B model, so this whole setup runs comfortably on 8 GB cards. The model card does not give VRAM figures, though, so that last part is my estimate from the model size.

Set It Up in ComfyUI

Start from any working Anima text-to-image workflow and make four changes:

1. Swap the VAE. In the Load VAE node, choose anima_rgba_vae.safetensors instead of the Qwen-Image VAE.
2. Add the LoRA. Put a standard LoraLoaderModelOnly (or Load LoRA) node between the model loader and the sampler. Pick anima_rgba_lora.safetensors and set strength to 1.0.
3. Add the trigger. Include transparent background or isolated on a transparent background in your positive prompt.
4. Save as PNG. VAE Decode now outputs four channels, and the normal Save Image node writes an RGBA PNG.

That is all. There is no custom node to install, and nothing to pip install.

Example prompt

masterpiece, best quality, newest, safe, 1girl, knight in silver armour holding a sword, full body, standing, transparent background

And the example negative prompt from the model card:

worst quality, low quality, score_1, score_2, score_3, blurry, jpeg artifacts

A quick tip: the ComfyUI preview pane may show the transparent area as black or white. Open the saved PNG in an image editor, or drop it on a checkerboard, to see the real alpha.

Settings That Work

These are the author’s sample settings. Full-body and medium shots with space around the subject work best, because the model has a clear background area to make transparent.

LoRA Strength vs Trigger Weight

The model card tested 8 prompts with 2 seeds each at 1024×1024, and counted how many pixels came out semi-transparent (the hazy in-between state you do not want):

All settings gave 16 out of 16 transparent results. The lesson is clear: do not push the LoRA above 1.0. At 1.5 it adds stray semi-transparent debris and smoke.

If a background stays opaque, raise the trigger weight instead, for example (transparent background:1.3). That fixes it while leaving the alpha almost unchanged.

How Good Is the Alpha?

The VAE was tested on a holdout set of 200 transparent and 50 opaque images at 512 px:

In plain words, the alpha is very accurate, and nearly all the error sits on the edges. The RGBA VAE also reconstructs normal opaque images slightly better than the stock VAE in this test, so you lose nothing by using it.

How it was trained

• VAE: 12,000 steps, batch size 4, 512 px crops, with 15% opaque images as regularisation. The losses were an L1 composite over random solid backgrounds, LPIPS at 0.2, alpha L1, an alpha edge (Sobel) term, and a latent match against the original encoder.
• LoRA: rank 32, 25,000 steps, on 18,426 images. The Qwen3 text encoder and LLM adapter were frozen. Captions alternate between the two trigger phrases, and the opaque images have no trigger.

Limitations

• Fine see-through detail is weakest. Loose hair strands, glass and smoke are the hardest, because the VAE trained on 512 px crops.
• Alpha is mostly binary. See-through clothing such as lace or sheer sleeves usually comes out fully opaque.
• Close-ups can keep a white background. When the subject fills the frame, the model sometimes keeps an opaque white backdrop. This happens more often when you stack other LoRAs.
• Without the LoRA, characters can go partly transparent, especially white clothing.
• Anime and illustration only. It is not meant for photos.

RGBA VAE vs Background Removal

For anime-style work on Anima, I would use RGBA every time. For photos, or for other models, background removal is still the way to go.

Good Uses

• Stickers and emotes for chat apps and streams.
• Game sprites and visual-novel character art.
• Character sheets you can lay over any background.
• Thumbnail and banner cut-outs.
• Layered artwork you finish in Krita or Photoshop.

Troubleshooting

The background is still solid white or grey

Check that the LoRA is loaded and the trigger is in the prompt. Then raise the trigger weight, for example (transparent background:1.3), rather than the LoRA strength. Pull the camera back so the subject does not fill the frame.

The saved image looks black where it should be clear

The viewer is not showing alpha. Open the PNG in an editor that shows a checkerboard. Also make sure you are saving as PNG, not JPG or WebP without alpha.

The character is partly see-through

That happens without the LoRA. Add it at 1.0. White clothing is the most prone to this.

Stray wisps and debris around the subject

Your LoRA strength is too high. Go back to 1.0.

It breaks when I add a style or character LoRA

Stacked LoRAs make the opaque-background problem more likely. Lower the other LoRA, raise the trigger weight, and use wider shots.

VAE error or size mismatch

The RGBA VAE is for Anima, which uses the Qwen-Image VAE format. It will not work with SDXL, Flux or other model families.

My Take

This is one of those small releases that solves a real, annoying problem. Two files, four workflow changes and no custom nodes, and you get proper transparent PNGs with clean edges.

The limits are honest and clearly documented: no sheer fabric, weak on fine hair and glass, and anime only. For stickers, sprites and character art, though, I think it beats any cut-out workflow I have used.

FAQ

Do I need custom nodes for Anima RGBA?

No. You use the standard Load VAE, LoRA loader, VAE Decode and Save Image nodes.

Where do I put the Anima RGBA files?

The VAE goes in ComfyUI/models/vae/ and the LoRA in ComfyUI/models/loras/.

What is the trigger word?

“transparent background” or “isolated on a transparent background”.

Does it work with SDXL, Flux or other models?

No. It is trained for Anima and uses Anima’s Qwen-Image VAE format.

Can I use it commercially?

The Anima-RGBA repo is Apache-2.0, and the VAE is derived from the Apache-2.0 Qwen-Image VAE. Check the Anima base model’s own licence too, because it applies to the model you generate with.

Why is my image partly transparent without the LoRA?

The VAE still outputs alpha, but without the LoRA the model does not know to keep the subject solid. Always use them together.

Does it work for realistic photos?

No. It is built for anime and illustration. For photos, generate normally and use a background-removal node.

Sources

• Hugging Face: localai0301/Anima-RGBA (model card, files, test results)
• Hugging Face: circlestone-labs/Anima
• ComfyUI Wiki: Anima RGBA news