★ Reading this for free? Get 20 structured AI courses + per-chapter AI tutor — the first chapter of every course free, no card.Start free in 30 seconds

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.

📅 Published: August 23, 2026🔄 Last Updated: August 23, 2026✓ Manually Reviewed

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 cardBuildWeights totalRealistic verdict
6 GBint8_convrot~4.5 GBWorks. Stay at 812x1216 and skip loading a control model alongside.
8 GBint8_convrot~4.5 GBThe sweet spot. Full resolution range plus an LLLite patch with headroom.
8 GBbf16~7.3 GBTight but viable if ComfyUI offloads the text encoder after conditioning.
12 GBbf16~7.3 GBEverything at once: 1536px, inpainting patch, no juggling.
16 GB+bf16~7.3 GBOverkill for inference. Spend the extra on batch size or LoRA training.
Apple unifiedbf16 or int8~7.3 / ~4.5 GBFine 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.

FileSizeGoes in
Anima-2.9B-preview-v1_int8_convrot.safetensors3.08 GBmodels/diffusion_models
Anima-2.9B-preview-v1.safetensors (bf16)5.84 GBmodels/diffusion_models
anima-turbo-v1.0.safetensors (base, fast)4.18 GBmodels/diffusion_models
anima-base-v1.0.safetensors (train LoRAs on this)4.18 GBmodels/diffusion_models
qwen_3_06b_base.safetensors — required1.19 GBmodels/text_encoders
qwen_image_vae.safetensors — required0.25 GBmodels/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 newer

Fetch 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 -> SaveImage

The 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.

SettingAnima-2.9BAnima base / aestheticAnima Turbo
Samplereuler, res-multistep, er-sdeer_sde, euler_a, dpmpp_2m_sde_gpu, eulereuler
Schedulersgm-uniform, beta, beta57, linear-quadraticdefault; beta57 for painterly texturedefault
Steps28-50 (50 for best quality)30-508-12
CFG3.5-54-51
Resolution812x1216, 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 aberration

Safety 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.

PatchSizeUse for
anima-lllite-pose-123.3 MBSkeleton-driven posing
anima-lllite-depth-17.9 MBDepth-map composition control
anima-lllite-lineart-17.8 MBColouring line art
anima-lllite-scribble-17.9 MBRough-sketch to finished image
anima-lllite-inpainting-v265.8 MBMasked regeneration (v1 also published)
anima-lllite-any-test-like-v216.4 MBGeneral-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 checkpointDownloadsPublished
MiaoMiao Harem~192,0006 Aug 2026
Animij~50,0002 Aug 2026
Nova Anime AM~36,5005 Aug 2026
RDBT | Anima~23,00011 Aug 2026
AnimaIka~20,00025 Jul 2026
JedpointReal~19,00016 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?
The int8 build is 3.08GB, the Qwen3-0.6B text encoder is 1.19GB and the Qwen-Image VAE is 0.25GB — about 4.5GB of weights in total, which sits comfortably on a 6GB card and leaves real headroom on 8GB. The bf16 build is 5.84GB, so the same three files come to roughly 7.3GB; that is an 8GB-card job at moderate resolutions and a 12GB-card job if you want 1536px and a control model loaded at the same time. ComfyUI can also swap the text encoder out of VRAM after conditioning is computed, which buys back another gigabyte or so on tight cards.
Do I need a custom node to run Anima-2.9B in ComfyUI?
Not if you are current. ComfyUI v0.33.1, released 13 August 2026, includes "Support anima tunes with extra blocks" (PR #15555) — that change exists specifically to load the 40-layer expanded architecture, so the 2.9B model works with core nodes. The model card puts it plainly: plug and play, no custom node needed. If you are on an older ComfyUI and cannot update, the author maintains gazingstars123/ComfyUI-Anima-2.9B as a fallback loader. The base Anima models have been natively supported far longer — core support for those landed within weeks of the base model's January 2026 release, and the LLLite control models were added in v0.29.0 on 29 July 2026.
What sampler and settings should I use?
For Anima-2.9B the author recommends Euler, Res-multistep or Er-sde as the sampler, with sgm-uniform, beta, beta57 or linear-quadratic as the scheduler, 28-50 steps, CFG 3.5-5, at 812x1216 or 1152x1536 (1536x1536 is described as iffy). Their personal setting is Euler plus sgm-uniform, and they call 50 steps the highest-quality choice. For the base circlestone-labs checkpoints the guidance is slightly different: 30-50 steps at CFG 4-5, anywhere between 512 and 1536 pixels square, with er_sde as a sensible default. The Turbo base variant is a separate case entirely — CFG 1 and 8-12 steps.
Can I sell images I generate with Anima?
Yes, and this is the part most licence warnings get wrong. The CircleStone Labs Non-Commercial License restricts the model weights, not the outputs. The base model card states directly that the non-commercial restriction applies only to the Model and not to Outputs, and lists selling images, paid commissions, and generating concept art or assets for a paid product as allowed. What you cannot do without a separate licence is host the model behind a paid API, put it on a paid generation platform, or embed the weights in a monetised product. As a derivative of NVIDIA Cosmos-Predict2-2B-Text2Image it also inherits the NVIDIA Open Model License insofar as that applies to derivatives. Anima-2.9B is a derivative model under the same terms.
Anima or Illustrious — which should I use?
Judge it by what the fine-tuners are actually building on. On Civitai this month, six of the twenty-five most-downloaded checkpoints are Anima-based and six are Illustrious-based — a dead heat, which is remarkable given how much longer Illustrious has been the default. The Anima entries, with download counts read on 18 August 2026, are MiaoMiao Harem (~192k), Animij (~50k), Nova Anime AM (~36k), RDBT|Anima (~23k), AnimaIka (~20k) and JedpointReal (~19k). The practical differences: Anima is small enough that the int8 build plus its encoder and VAE come to about 4.5GB, it uses a Qwen3-0.6B text encoder so natural-language prompting works alongside Danbooru tags, and Anima-2.9B carries a July 2026 knowledge cutoff against September 2025 on the base. Against that, Illustrious has years of LoRAs and workflows behind it, and Anima explicitly does not do realism.
What is int8_convrot and why is there no GGUF?
It is ComfyUI's native int8 quantisation path for diffusion models, added in v0.27.0 on 30 June 2026, with int4 following in v0.28.0. Because Anima ships an int8_convrot safetensors file that core ComfyUI loads directly, there is no reason for a GGUF conversion — the quantised route is already first-party. The practical upshot is that you skip the ComfyUI-GGUF custom node dance that FLUX and Chroma users go through on low-VRAM cards. Download the int8 file, drop it in diffusion_models, done.

Related

🎯
AI Learning Path

Go from reading about AI to building with AI

20 structured courses. Hands-on projects. Runs on your machine. Start free.

Or own it for life — Lifetime $149 $599, pay once
LM

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.

✓ Local AI Curriculum✓ Hands-On Projects✓ Open Source Contributor
More on AI Models Directory
See the full AI Models Directory guide.
📚
Free · no account required

Grab the AI Starter Kit — career roadmap, cheat sheet, setup guide

No spam. Unsubscribe with one click.

🎯
AI Learning Path

Found your model? Now build something with it.

25 hands-on courses — RAG, agents, fine-tuning — all running locally. First chapter free, no card.

Or own it for life — Lifetime $149 $599, pay once
Free Tools & Calculators