Skip to main content
by artokun · June 16, 2026 · anima · anime · ComfyUI · model highlight Every “best anime model” list in 2026 assumes you’ve got a 12-to-16 GB card and patience for a 6.5 GB SDXL checkpoint. ANIMA 1.0 quietly ignores that assumption. It’s a ~2B-parameter anime/illustration model that generates — and trains LoRAs — under 6 GB of VRAM, takes Danbooru tags and plain English in the same prompt, and ships with a real anime inpainting workflow. It’s the tiny-but-mighty entry in our model-highlight series: not the biggest, but arguably the best anime-quality-per-gigabyte you can run locally. Below: what ANIMA actually is (and the architecture surprise under the hood), the inpainting and ControlNet workflow, how to train your own anime LoRA on a 6 GB card, how it stacks up against the SDXL-lineage giants, and the fastest path to running it — a one-command install with comfyui-mcp and the sidebar Panel, instead of hand-downloading a dozen files into five folders.
TL;DR — one-command setup. Install comfyui-mcp, apply the anima pack (apply_manifest --path packs/anima/manifest.yaml, or run the generated installer from your ComfyUI root), and drive the graph from your own Claude session via the Panel. Jump to Install.

​
What is ANIMA 1.0?

ANIMA is a ~2B-parameter anime and illustration text-to-image model from CircleStone Labs (built in collaboration with Comfy Org). Here’s the part that makes it different from every other anime model you’ve used: it is not SDXL-lineage. ANIMA is a fine-tune of NVIDIA’s Cosmos-Predict2-2B-Text2Image — a DiT / flow-matching architecture — paired with a Qwen3-0.6B text encoder and the Qwen-Image VAE. Per the model card, it was trained on “several million anime images and about 800k non-anime artistic images,” with no synthetic data and a stated anime knowledge cutoff of September 2025. The pitch is “tiny but mighty”: a modern transformer image model small enough to run anywhere SDXL or Illustrious runs, tuned specifically for anime, manga, and illustrated characters and styles. It is honestly not a realism model — the authors say so plainly, and so do we. It speaks two prompt languages at once. ANIMA’s standout feature is that it accepts Danbooru-style tags AND natural-language sentences in the same prompt — you can write 1girl, solo, silver hair, neon city and then add “standing in the rain, cinematic lighting, medium close-up” right after it. That flexibility comes from the Qwen text encoder, and it’s the thing tag-only SDXL models can’t really do. The honest caveats. ANIMA is young. Community reviewers have noted that the base model’s default output can look flat without aesthetic LoRAs, that very obscure or very recent artists may be under-represented, and that pose control is strongest for poses that exist as Danbooru tags. The bundled aesthetic LoRAs and the ControlNet stack exist precisely to address the first two. If you want maximum out-of-the-box polish on a big GPU, an Illustrious/NoobAI/Animagine fine-tune may still edge it — see the comparison below.
License — read this before commercial work. The weights ship under the CircleStone Labs Non-Commercial License (with NVIDIA Open Model License terms on derivatives) — you can’t host them in a paid generation service or embed them in a monetized product without a separate commercial license. But per the current model card, the images you generate are usable commercially — you can sell prints, take commissions, and use outputs as game/VN assets. That’s an unusual and generous split. Licenses change; verify the current text on the model card before relying on it.

​
ANIMA vs the SDXL anime giants

There’s no single “best” anime model in 2026 — the community consensus is division of labor. Here’s where ANIMA fits: The SDXL-lineage models are larger, more mature, and have years of community fine-tunes behind them — if you have the VRAM and want plug-and-play polish, they’re strong. ANIMA’s argument is different: it’s a dedicated anime model that’s small enough to run and train on hardware those models strain, with a text encoder that understands sentences. If your bottleneck is a 6–8 GB card, or you want to fine-tune without renting a GPU, ANIMA is the easy call. For non-anime work, this series covers the other specialists: the open-weight text-and-layout champion in our Ideogram 4 post, and the speed/low-VRAM generalist in our Z-Image post.

​
System & VRAM requirements

ANIMA’s whole selling point is that it’s light: A community GGUF quant (Abiray/Anima-base-v1.0-GGUF) exists for even lower memory, but it needs a GGUF loader node and is not included in this pack — unverified against this workflow.

​
Install ANIMA in ComfyUI

ANIMA loads with standard split-file loaders — not a single checkpoint. You need a diffusion model, a text encoder, and a VAE in three different folders, plus the ControlNet, LoRAs, and detailer models if you want the full kit: The official weights live on the CircleStone Labs HF repo; the pack pulls from a CI-validated mirror.

​
The fast way — comfyui-mcp + the Panel

Wiring three loaders by hand and chasing a dozen files into five folders is exactly the busywork the comfyui-mcp anima pack removes. One declarative manifest installs the custom nodes (including the ComfyUI-Anima-LLLite inpainting node) and pulls every model to the correct folder — and the same manifest drives both an MCP-native install and a generated double-click installer:
Run the generated installer from your ComfyUI root (the folder containing custom_nodes/ and models/), restart ComfyUI, and load packs/anima/workflow.json. Because the pack ships with the plugin, your own Claude session can drive the live graph through the Panel — add/wire nodes, set widgets, swap LoRAs, and iterate on prompts conversationally, with full undo and no API keys. Every model URL in the pack is CI-validated for reachability and size, so a link never quietly rots (here’s why that matters).

​
Anime inpainting (the Anima-LLLite workflow)

ANIMA’s inpainting isn’t a bolt-on — it’s a dedicated Anima-LLLite ControlNet. LLLite (“LoRA-Lite”) patches the MODEL directly rather than feeding standard ControlNet conditioning, so the pack uses a special AnimaLLLiteApply node from ComfyUI-Anima-LLLite (kohya-ss). The inpaint flow is clean:
  1. Load an image and paint a mask over the region you want to redraw.
  2. VAEEncode the source image, then SetLatentNoiseMask with the mask.
  3. Patch the model with anima-lllite-inpainting-v1.safetensors via AnimaLLLiteApply, fed the same image + mask.
  4. Sample. The masked area is regenerated from your prompt while everything outside it is preserved.
The same AnimaLLLiteApply node powers ANIMA’s other control modes — just swap the lllite_name and feed a preprocessed control image:
Gotcha: AnimaLLLiteApply is not a standard ControlNet node. If it’s missing, install ComfyUI-Anima-LLLite (the pack does this for you).

​
Train your own anime LoRA (under 6 GB)

This is where ANIMA’s small size pays off twice. Because the model is ~2B params, you can train a character or style LoRA on the same ~6 GB card you generate with — no rented A100 required. The comfyui-mcp anima-lora-trainer skill walks through Citron’s local Gradio trainer, which drives kohya-ss/sd-scripts under the hood with an Anima-specific network module. The short version:
  • Dataset: a flat folder of images, each with a matching .txt caption of the same basename. Caption in the same Danbooru-tags-plus-natural-language style you’ll prompt with.
  • Defaults that fit 6 GB: network_dim 32, resolution 768, batch 1, AdamW8bit, gradient checkpointing + latent/text-encoder caching, bf16 (fp16 on older GPUs). OOM? Drop to network_dim 8 and/or resolution 512.
  • Output: a standard .safetensors LoRA. Drop it into models/loras/, load it with LoraLoaderModelOnly or rgthree’s Power Lora Loader, and stack it with the turbo LoRA for fast 12-step generation.
A GTX 1060 6 GB can train (slowly); pre-Pascal GPUs are unsupported. Full parameters, the accelerate launch command, and dataset rules are in the anima-lora-trainer skill.

​
Prompt style

ANIMA’s recommended formula stacks tags and prose:
The structure: quality tags → subject/count tags → optional @artist name → anime style tags → 2–4 natural-language sentences (subject, outfit, pose, composition, background, lighting, mood). Tags are lowercase with spaces, not underscores — the only exception is score tags like score_7. Artist tags use the @artist name form; browse names at the community Anima Style Explorer. Unlike Flux or Qwen, ANIMA does use a real negative prompt (a second text encode, since base mode runs CFG above 1):

​
What to make with it

  • Original characters & OCs — design sheets, portraits, full-body refs
  • Fan art — established Danbooru/Gelbooru artists imitate best
  • Manga / illustration panels — clean lineart and soft shading
  • Concept and VN/game assets — generous output license makes this practical
  • Custom-style LoRAs — train a personal art style on a 6 GB card
  • Edits & fixes — anime inpainting to repaint hands, faces, or backgrounds

​
Settings that matter

ANIMA has two distinct modes, and they want different settings: The pack’s default enables anima-turbo-lora-v0.1 for fast 12-step previews. For maximum quality, drop the turbo LoRA, switch to 30–50 steps at CFG 4–5, and optionally enable the three bundled aesthetic LoRAs (anima-highres-aesthetic-boost, anima-preview-3-masterpieces-v5, anima_p3_rdbt_v0.29.b.122). Sampler character (from the model card): er_sde gives neutral style, flat colors, sharp lines; euler_ancestral softens/thins lines; dpmpp_2m_sde_gpu adds variety. A beta57 scheduler (via RES4LYF) leans painterly. Use a recommended resolution to avoid distortion: 1024x1024 (1:1), 896x1152 (3:4), 832x1216 (5:8), 768x1344 (9:16), or 640x1536 (9:21).

​
Troubleshooting

  • Weird / distorted images. Use a recommended resolution (1024x1024, 896x1152, 832x1216, 768x1344, 640x1536).
  • Turbo output looks washed/flat. That’s turbo at CFG 1. Switch to base mode (drop the turbo LoRA, 30–50 steps, CFG 4–5) for max quality.
  • AnimaLLLiteApply missing. Install ComfyUI-Anima-LLLite — it is not a standard ControlNet node.
  • CLIP loads but output is garbage. Confirm the CLIPLoader type is stable_diffusion and the file is qwen_3_06b_base.safetensors (the Qwen3-0.6B base, not a chat/edit Qwen).
  • Inpainting ignores the mask. Make sure both SetLatentNoiseMask and the inpainting AnimaLLLiteApply receive the painted mask.
  • OOM while training. Drop to network_dim 8 and/or resolution 512, keep batch 1, use AdamW8bit.

​
FAQ

How big is ANIMA, and what’s it built on? ~2B parameters — a fine-tune of NVIDIA Cosmos-Predict2-2B-Text2Image (a DiT / flow model), with a Qwen3-0.6B text encoder and the Qwen-Image VAE. It is not SDXL-lineage. How much VRAM do I need? Under 6 GB to generate, ~6 GB to train a LoRA. It runs anywhere SDXL or Illustrious runs. Can I use Danbooru tags or natural language? Both — in the same prompt. That’s ANIMA’s signature feature. Can I sell what I make with it? Per the current model card, yes — generated images are usable commercially (prints, commissions, game/VN assets). The weights themselves are non-commercial; you can’t host them in a paid service without a separate license. Verify the current license before relying on it. Can I really train a LoRA on a low-end GPU? Yes — the anima-lora-trainer skill uses kohya sd-scripts at defaults that fit ~6 GB (network_dim 32, res 768, batch 1). A GTX 1060 6 GB works, just slowly. Is it better than Illustrious / NoobAI / Animagine? For lowest VRAM, tag-plus-natural-language prompting, and local training, ANIMA wins. For out-of-the-box polish and the largest LoRA ecosystem on a bigger card, the mature SDXL fine-tunes still lead. Different jobs. Does it do realism? No. ANIMA is explicitly an anime/illustration model and isn’t tuned for photorealistic output.

​
Get it running in one command

  1. Install comfyui-mcp and the Panel — the panel auto-starts a background agent on your Claude subscription (no API keys; sign in with claude once).
  2. Apply the anima pack — nodes + every model land in the right folders, CI-validated, with the Anima-LLLite inpainting node included.
  3. Open the Panel and let the panel’s agent wire the graph, swap LoRAs, and iterate on tag-plus-prose prompts for you.
That’s the whole point of the project: expert ComfyUI setups that install in one step and drive themselves from your own agent session. Next in the series: LTX-2.3 — the fast GGUF video model with synchronized audio and the LTX Director timeline.