CircleStone Labs · Comfy Org · Non-Commercial Weights
Anima 2.9B on 8GB: The Anime Model That Took Over Civitai
Something unusual happened to the local anime-image scene this month. Six of the twenty-five most-downloaded Civitai checkpoints are now built on Anima — a 2-billion-parameter model most people had not heard of in June — and all six were published within the last four weeks. Then on 12 August a layer-expanded 2.9B version arrived, ComfyUI shipped core support for it the following day, and the whole thing still fits on a 6GB card. This is the setup guide.
Quick answer: what you download and what it costs
Anima-2.9B in int8 is 3.08 GB, plus a 1.19 GB text encoder and a 0.25 GB VAE — about 4.5 GB of weights in total. That is a 6GB card comfortably and an 8GB card with room to spare. The bf16 build is 5.84 GB, taking the same trio to roughly 7.3 GB. There is no GGUF and you do not need one: the int8 file is ComfyUI's native quantisation path.
| Your card | Build | Weights total | Realistic verdict |
|---|---|---|---|
| 6 GB | int8_convrot | ~4.5 GB | Works. Stay at 812x1216 and skip loading a control model alongside. |
| 8 GB | int8_convrot | ~4.5 GB | The sweet spot. Full resolution range plus an LLLite patch with headroom. |
| 8 GB | bf16 | ~7.3 GB | Tight but viable if ComfyUI offloads the text encoder after conditioning. |
| 12 GB | bf16 | ~7.3 GB | Everything at once: 1536px, inpainting patch, no juggling. |
| 16 GB+ | bf16 | ~7.3 GB | Overkill for inference. Spend the extra on batch size or LoRA training. |
| Apple unified | bf16 or int8 | ~7.3 / ~4.5 GB | Fine on 16GB+ unified memory. Expect it to be slow rather than impossible. |
File sizes read from Gazingstars123/Anima-2.9B and circlestone-labs/Anima on 18 August 2026. Those are weight sizes, not peak VRAM — add activations, which scale with resolution and batch size. If you are shopping in this tier generally, our best image models for 8GB VRAM page covers the alternatives.
Key takeaways
- →Smallest serious anime model going. ~4.5 GB of weights all-in at int8. No GGUF gymnastics.
- →Day-zero ComfyUI support. v0.33.1 (13 Aug 2026) added loading for the expanded 40-layer architecture, one day after the model appeared.
- →July 2026 knowledge cutoff on the 2.9B fine-tune, against September 2025 on the base — that is the reason people are switching.
- →Weights are non-commercial; your images are not. The licence restricts the model, and explicitly not the outputs.
- →Still a preview. Only the newly inserted layers have been trained so far, and the author says training is ongoing.
What Anima actually is
Two different things share the name, and knowing which one you are downloading saves an evening.
Anima (base) is a 2-billion-parameter text-to-image model from CircleStone Labs, built in collaboration with Comfy Org on top of NVIDIA's Cosmos-Predict2-2B-Text2Image. It first appeared on Hugging Face on 29 January 2026 and has been updated steadily since — about 818,000 downloads in the last thirty days and 2,087 likes when we checked on 18 August. Its card says it was trained on several million anime images plus about 800k non-anime artistic images, with no synthetic data, and a September 2025 knowledge cutoff. The repo ships eight checkpoint variants at 4.18 GB each: base, three aesthetic tunes, three previews and a turbo distillation.
Anima-2.9B is the new one — a layer-expanded fine-tune by Gazingstars123, uploaded 12 August 2026 and last touched on the 15th. The trick is transformer depth expansion: 28 layers grown to 40 by deep-copying neighbouring layers with zeroed output projections, so the expanded model starts out functionally identical to the base and then trains from there. It adds 1.7M anime and illustration samples and pushes the knowledge cutoff to July 2026. In its first six days it took roughly 23,000 downloads and 238 likes.
Both use the same supporting cast: a Qwen3-0.6B base model as the text encoder (1.19 GB) and the Qwen-Image VAE (0.25 GB). If you have run Qwen-Image-Edit locally, you very likely already have that VAE on disk.
Every file and what it costs you
Three files are mandatory; everything else is optional. The numbers below are the actual repository file sizes.
| File | Size | Goes in |
|---|---|---|
Anima-2.9B-preview-v1_int8_convrot.safetensors | 3.08 GB | models/diffusion_models |
Anima-2.9B-preview-v1.safetensors (bf16) | 5.84 GB | models/diffusion_models |
anima-turbo-v1.0.safetensors (base, fast) | 4.18 GB | models/diffusion_models |
anima-base-v1.0.safetensors (train LoRAs on this) | 4.18 GB | models/diffusion_models |
qwen_3_06b_base.safetensors — required | 1.19 GB | models/text_encoders |
qwen_image_vae.safetensors — required | 0.25 GB | models/vae |
The int8 route is native, not a community workaround. ComfyUI added int8 convrot support in v0.27.0 on 30 June 2026 and int4 convrot in v0.28.0 two weeks later, so the quantised file loads with core nodes. This is the thing that makes Anima genuinely different from running Chroma or FLUX on a small card, where you end up in the GGUF custom-node ecosystem.
ComfyUI setup
Update ComfyUI to v0.33.1 or newer first. That release, dated 13 August 2026, contains "Support anima tunes with extra blocks" (PR #15555) — the change that teaches core ComfyUI to load the expanded 40-layer architecture. Without it the 2.9B file will not load. The base Anima checkpoints have been supported far longer and do not need it.
cd ComfyUI
git pull
pip install -r requirements.txt
python main.py --version # want v0.33.1 or newerFetch the three files
pip install huggingface_hub
# the model (int8 — swap the filename for the bf16 one if you have the VRAM)
hf download Gazingstars123/Anima-2.9B \
Anima-2.9B-preview-v1_int8_convrot.safetensors \
--local-dir ComfyUI/models/diffusion_models
# text encoder + VAE from the base repo
hf download circlestone-labs/Anima \
split_files/text_encoders/qwen_3_06b_base.safetensors \
--local-dir /tmp/anima
hf download circlestone-labs/Anima \
split_files/vae/qwen_image_vae.safetensors \
--local-dir /tmp/anima
mv /tmp/anima/split_files/text_encoders/*.safetensors ComfyUI/models/text_encoders/
mv /tmp/anima/split_files/vae/*.safetensors ComfyUI/models/vae/The node chain
It is an ordinary split-model graph, the same shape you use for any modern ComfyUI checkpoint:
UNETLoader -> Anima-2.9B-preview-v1_int8_convrot.safetensors
CLIPLoader -> qwen_3_06b_base.safetensors
VAELoader -> qwen_image_vae.safetensors
CLIPTextEncode (+) -> your Danbooru-tag prompt
CLIPTextEncode (-) -> negative prompt
EmptyLatentImage -> 812 x 1216 (or 1152 x 1536)
KSampler -> euler / sgm_uniform, 30 steps, CFG 4.5
VAEDecode -> SaveImageThe base repo ships a ready-made workflow embedded in its example.png — drag that image into the ComfyUI canvas and the graph builds itself. If any of this is unfamiliar, start with our complete ComfyUI guide.
One caveat straight from the model card: it is plug-and-play, but it "sometimes may not work with other custom nodes." If generation fails in a heavily modded install, test in a clean ComfyUI before debugging anything else.
Sampler settings that the author actually uses
Euler + sgm-uniform, 28-50 steps, CFG 3.5-5, at 812x1216. That is the author's own configuration for Anima-2.9B, described as a good balance between composition and fine detail. The base checkpoints want slightly different numbers.
| Setting | Anima-2.9B | Anima base / aesthetic | Anima Turbo |
|---|---|---|---|
| Sampler | euler, res-multistep, er-sde | er_sde, euler_a, dpmpp_2m_sde_gpu, euler | euler |
| Scheduler | sgm-uniform, beta, beta57, linear-quadratic | default; beta57 for painterly texture | default |
| Steps | 28-50 (50 for best quality) | 30-50 | 8-12 |
| CFG | 3.5-5 | 4-5 | 1 |
| Resolution | 812x1216, 1152x1536 (1536² iffy) | 512² to 1536² | as base |
The author also notes that res-multistep with linear-quadratic spends more time at high-noise steps, which visibly improves composition at the cost of speed — worth trying when a prompt keeps producing a good subject in a bad layout. And CFG is genuinely image-dependent here: they say some images do better at 3.5 than at 5 and vice versa, so treat it as a dial rather than a constant.
Prompting: Danbooru tags, with rules
Artist tags need an @ prefix, character names must be paired with their series, and long prompts beat short ones by a wide margin. Anima accepts Danbooru-style tags, natural language, or a mix of both in arbitrary order — the text encoder is a language model, so full sentences genuinely work.
The tag order the base card recommends:
[quality/meta/year/safety] [1girl/1boy/1other] [character] [series] [artist] [general tags]- •Artist tags need the @. The card is emphatic: prefix artist names with @, as in
@nnn yryr. Without it the effect is very weak. This is the single most common reason people conclude an artist tag "does not work." - •Lowercase, spaces not underscores. Score tags are the only exception. Where Danbooru and Gelbooru disagree on a tag, use the Gelbooru version.
- •Always pair a character with their series. Both cards warn the model gets confused otherwise, and it gets worse with multiple characters — attribute each one their own appearance tags.
- •Score tags: optional, and different per model. Anima-2.9B's dataset contains no score tags at all, though the author says you can still use them. The base Aesthetic variants recommend not using
score_*in either prompt, because it pushes an already-tuned model too far. - •Short prompts give bland results. The 2.9B card puts this in capitals: the more detailed the prompt, the better. Short prompts tend to produce a plain background and miss the intent.
- •Prompt weighting needs bigger numbers than SDXL. The base card's example is
(chibi:2)— roughly double what you would reach for out of habit.
A working base-model prompt shape:
positive:
masterpiece, best quality, year 2025, newest, highres, safe,
1girl, <character tag>, <series tag>, @<artist tag>,
solo, long hair, brown eyes, smile, looking at viewer,
detailed background, ...
negative:
worst quality, low quality, score_1, score_2, score_3,
artist name, blurry, jpeg artifacts, chromatic aberrationSafety tags (safe, sensitive, nsfw, explicit) are part of the tag vocabulary and the base card recommends using them in both the positive and negative prompt to steer output — the model will otherwise drift on short or vague prompts.
LLLite control models
Anima has pose, depth, lineart, scribble and inpainting control models, and they are tiny — 8 MB to 66 MB each. ComfyUI added support in v0.29.0 (29 July 2026, PR #14954). Comfy Org repacks kohya-ss's originals as Comfy-Org/Anima-LLLite, which had about 26,000 downloads in the last thirty days and was last updated on 17 August 2026.
| Patch | Size | Use for |
|---|---|---|
anima-lllite-pose-1 | 23.3 MB | Skeleton-driven posing |
anima-lllite-depth-1 | 7.9 MB | Depth-map composition control |
anima-lllite-lineart-1 | 7.8 MB | Colouring line art |
anima-lllite-scribble-1 | 7.9 MB | Rough-sketch to finished image |
anima-lllite-inpainting-v2 | 65.8 MB | Masked regeneration (v1 also published) |
anima-lllite-any-test-like-v2 | 16.4 MB | General-purpose experimental patch |
These go in ComfyUI/models/model_patches/, not the ControlNet folder — they are model patches, not classic ControlNets, which is why they are measured in megabytes. Names ending in -step1000, -step2000 or -beta-epoch-03 are training checkpoints of the same patch; take the plain v2 file unless you are comparing them deliberately.
Adding one costs you 8-66 MB of VRAM, which is noise. Even on a 6GB card you can keep a control model resident.
Anima vs Illustrious: the honest verdict
It is a dead heat on Civitai this month — six Anima-based checkpoints in the top 25 most-downloaded, and six Illustrious-based. What makes that notable is the timeline, not the tie: Illustrious has been the default anime base for a long time, and Anima went from obscure to level with it inside a single month.
| Anima-based checkpoint | Downloads | Published |
|---|---|---|
| MiaoMiao Harem | ~192,000 | 6 Aug 2026 |
| Animij | ~50,000 | 2 Aug 2026 |
| Nova Anime AM | ~36,500 | 5 Aug 2026 |
| RDBT | Anima | ~23,000 | 11 Aug 2026 |
| AnimaIka | ~20,000 | 25 Jul 2026 |
| JedpointReal | ~19,000 | 16 Aug 2026 |
Download counts read from the Civitai API on 18 August 2026 and rounded — they move every day, so treat them as a snapshot rather than a scoreboard.
Where Anima wins: size — about 4.5 GB of weights all-in — plus native int8 support with no GGUF detour, and a language-model text encoder that makes natural-language prompting work properly, and — for the 2.9B fine-tune — a July 2026 knowledge cutoff, meaning recent characters and series it has actually seen.
Where Illustrious wins: ecosystem depth. Years of LoRAs, embeddings, upscale workflows and community knowledge that Anima simply has not accumulated yet. If your work depends on a specific existing LoRA, that decides it.
Where neither wins: realism. Anima's card says outright that the model "will not work well at realism" and that this is intentional. For photographic output you want an entirely different model — see our local image models compared roundup, or Z-Image Base and Edit for the general-purpose side.
The licence, precisely
The weights are non-commercial. The images you generate are not restricted — the base model card says so explicitly. Both Anima and Anima-2.9B ship under the CircleStone Labs Non-Commercial License, with Anima-2.9B counting as a "Derivative Model" under the same terms.
Allowed, per the model card
- • Selling images you generate
- • Paid commissions
- • Concept art or assets for a paid product (game, visual novel)
- • Selling derivative model weights, if you operate as an individual (a specific carve-out in section 2.c)
Needs a separate licence
- • Hosting the model behind an API and charging for access
- • Putting it on a paid image-generation platform
- • Embedding the weights inside a monetised game or product
- • Using it to power a feature of a larger monetised product
One extra layer: because Anima derives from NVIDIA's Cosmos-Predict2-2B-Text2Image, the base card states it is also subject to the NVIDIA Open Model License Agreement insofar as that applies to derivative models. Commercial licensing enquiries go to CircleStone Labs directly. If the model licence itself is your blocker rather than the outputs, the Apache-2.0 route is Chroma — different strengths, no restriction on the weights. None of this is legal advice; read the licence file yourself before you build a business on it.
Honest limitations
- •Anima-2.9B is a preview, and the card says so. Status is "training in progress," and as of preview v1 only the newly inserted layers have been trained, with roughly 70% of compute spent at 1024px. Expect it to change under you.
- •No realism. Deliberate, per the base card. This is an illustration model.
- •Text rendering is weak. The base card says single words and sometimes short phrases work; anything longer will not.
- •1536x1536 is described as "iffy" on the 2.9B model. Stay at 812x1216 or 1152x1536 for reliable results.
- •The base model is genuinely a base model. Anima-Base has had no aesthetic tuning — its default style is plain and neutral without artist or quality tags. Use Aesthetic or Turbo unless you are training on it.
- •Short prompts can produce content you did not ask for. The base card recommends explicit safety tags in both prompts as the mitigation.
- •Custom-node conflicts. The 2.9B card notes it sometimes does not work alongside other custom nodes. A clean install is your first debugging step, not your last.
Training your own Anima LoRA
LoRA training is supported and unusually accessible for a model this current. The author ships Anima-Standalone-Trainer, a GUI trainer sitting at about 300 GitHub stars with its last push on 14 August 2026, plus an sd-scripts fork. The model card says Anima-2.9B itself was trained on an 8× RTX 5080 cluster with the Muon optimiser — which tells you the compute floor here is consumer hardware, not a datacentre.
Two rules from the base card that will save you a wasted run: train LoRAs on Anima-Base, not the aesthetic tunes, and do not train the LLM adapter — it carries a surprising amount of knowledge and degrades easily. Start a rank-32 LoRA at a learning rate around 2e-5.
Local LoRA training guide →Frequently asked questions
How much VRAM does Anima-2.9B actually need?
Do I need a custom node to run Anima-2.9B in ComfyUI?
What sampler and settings should I use?
Can I sell images I generate with Anima?
Anima or Illustrious — which should I use?
What is int8_convrot and why is there no GGUF?
Related
- → Complete ComfyUI guide — if the node graph above was unfamiliar, start here
- → Best image models for 8GB VRAM — what else fits in Anima's tier
- → Local image models compared — the full field, including realism models
- → Z-Image Base & Edit — the general-purpose model to pair with an anime specialist
- → Chroma local guide — the Apache-2.0 alternative if licensing is your constraint
- → Qwen-Image-Edit local guide — you probably already have the VAE Anima needs
- → AI-Toolkit LoRA training — the other trainer worth knowing
Go from reading about AI to building with AI
20 structured courses. Hands-on projects. Runs on your machine. Start free.
Written by the Local AI Master Team
The team behind Local AI Master
We build Local AI Master around practical, testable local AI workflows: model selection, hardware planning, RAG systems, agents, and MLOps. The goal is to turn scattered tutorials into a structured learning path you can follow on your own hardware.