Image model

How to run Anima locally.

Anima runs natively in ComfyUI with three small files: a 4.2 GB model, the 1.2 GB Qwen3 0.6B text encoder and the Qwen-Image VAE. That’s 5.6 GB in all, so a 6 GB card holds it at full precision. It draws anime and illustration, not photos.

Updated 29 Sep 20268 min read

Maker
CircleStone Labswith Comfy Org
Released
May 2026Base v1.0 on 14 May. Turbo in July
Licence
Non-commercialweights only. Images free to sell
Memory
6 GB and up5.6 GB of files. GGUF runs on 4 GB

Which version.

Anima is a 2B model from CircleStone Labs, made with Comfy Org and built on NVIDIA’s Cosmos-Predict2. It was trained on several million anime images and about 800,000 non-anime artworks, with no photos. All versions are the same size.

  • Turbo (anima-turbo-v1.1) is distilled for 8 to 12 steps at CFG 1. The author recommends starting here: slightly behind Aesthetic on average, and much faster.
  • Aesthetic (v1.1, or v1.0b without the merged style LoRAs) is the quality fine-tune for finished pictures.
  • Base (anima-base-v1.0) has a plain, neutral style. Train LoRAs on this one.

Files you need.

Everything is in the model’s own repository. Only bf16 is official.

  • Model anima-turbo-v1.1.safetensors ComfyUI/models/diffusion_models/ or anima-aesthetic-v1.1 / anima-base-v1.0, 4.2 GB each
    4.2 GB Download
  • Text encoder qwen_3_06b_base.safetensors ComfyUI/models/text_encoders/
    1.2 GB Download
  • VAE qwen_image_vae.safetensors ComfyUI/models/vae/ the Qwen-Image VAE. You may have it already
    0.3 GB Download
ComfyUI/models
models/
├── diffusion_models/
│   └── anima-turbo-v1.1.safetensors
├── text_encoders/
│   └── qwen_3_06b_base.safetensors
└── vae/
    └── qwen_image_vae.safetensors

Smaller files: GGUF

Community GGUF builds load through the ComfyUI-GGUF Unet Loader. They matter for 4 GB cards; above that, the full file fits anyway.

VersionQ8_0Q6_KQ5_K_MQ4_K_M
Base v1.02.2 GB1.7 GB1.6 GB1.4 GB

The same uploader has Aesthetic and Turbo builds. Its page names the NVIDIA Cosmos licence; CircleStone’s licence applies.

What fits your computer.

At 1024 × 1024. Anima is small, but its attention makes it slower per image than SDXL at the same size.

  • 4 GBSlow

    A GTX 970 runs the Q8_0 GGUF at under 7.5 s per step with fp16 compute.

  • 6 GBFits

    The full bf16 model. Comfy’s template puts the whole set at 5.6 GB.

  • 8 GBFits

    Full model with room for LoRAs.

  • 12 GBFits

    Comfortable, including hires passes.

  • Older GPUsUpdate

    GTX 10 and 16 series and RTX 20 cards lack bf16. Before February 2026 ComfyUI ran Anima in fp32 on them, very slowly or with a CUBLAS error. Current ComfyUI uses fp16 there.

  • MacUntested

    No Apple Silicon reports yet. The weights are bf16, not fp8, so they should load on current PyTorch.

Set it up.

  1. Update ComfyUI

    Anima is native. Errors about embed_tokens size mismatches or 'conv_in.weight' almost always mean an old ComfyUI. In a manual install:

    Terminal, in the ComfyUI folder
    git pull
    pip install -r requirements.txt
  2. Download the three files

    A model, the Qwen3 0.6B encoder and the Qwen-Image VAE from the list above.

  3. Put them in their folders

    Model in diffusion_models, encoder in text_encoders, VAE in vae. Restart ComfyUI.

  4. Open the template

    Pick Anima Base v1: Text to Image in the template browser. Load Diffusion Model gets your Anima file, Load CLIP the Qwen3 encoder. Its type is stable_diffusion in the template; cosmos or qwen make no difference in current ComfyUI.

  5. Match the sampler to the file

    The template is set for Base: 30 steps, CFG 4, er_sde, simple. For Turbo, change it to 8 to 12 steps and CFG 1.

  6. Prompt with tags or sentences

    Danbooru tags, plain English or both. The template’s prompts show the quality tags; the section below has the rest.

Settings that work.

Base and Aesthetic

Steps
30 to 50
CFG
4 to 5
Sampler
er_sde
Scheduler
simple
Size
1024 × 1024512² to 1536²
Negative
yes
Text encoder
Load CLIP
Latent
EmptyLatentImage

Turbo

Steps
8 to 12
CFG
1
Sampler
euler or er_sde
Negative
noneignored at CFG 1

The card calls er_sde a reasonable default: neutral style, flat colours, sharp lines. euler is a bit more creative and suits Turbo and Aesthetic, euler_a gives softer lines. For a painterly look the author likes the beta57 scheduler from the RES4LYF pack.

Prompting.

Lowercase tags with spaces, not underscores (score tags keep theirs). Order: quality and safety, then 1girl or 1boy, character, series, artist, the rest. Put @ before artist names, or they barely register. Weights need to be higher than on SDXL, for example (chibi:2). For plain English, write at least two sentences and name each character before describing them.

Start of the prompt, from the card
masterpiece, best quality, score_7, safe, 
Negative, from the card
worst quality, low quality, score_1, score_2, score_3, artist name, blurry, jpeg artifacts, chromatic aberration

Leave the score_ tags out with Aesthetic. The safety tags are safe, sensitive, nsfw and explicit. Putting ye-pop or deviantart on the first line switches to the non-anime art styles.

How fast.

GPUSetupSpeed
Intel Arc B5801216 × 8321.3 it/s[1]
Intel Arc B5801216 × 832, torch.compile2 it/s[1]
RTX 4060 Tivs SDXLabout 3× slower[2]
GTX 970 4 GBQ8_0 GGUF, 1 MPunder 7.5 s/it[3]

bf16 unless noted. The GTX 970 ran with fp16 compute. Turbo at 8 steps and CFG 1 needs a fraction of the model passes that 30 steps at CFG 4 do, since CFG above 1 runs two passes per step.

When it goes wrong.

size mismatch for model.embed_tokens.weight: copying a param with shape torch.Size([151936, 1024])
ComfyUI is too old to know the Qwen3 0.6B encoder. Update it; the files are fine.
'conv_in.weight' when loading the model
Also an old ComfyUI. Update.
RuntimeError: CUDA error: CUBLAS_STATUS_NOT_SUPPORTED on an older card
A GPU without bf16. Update ComfyUI (fixed in February 2026), or start it with --fp16-unet.
Hours per image on a GTX 1060 or similar
Same cause: fp32 fallback on a card without bf16. Update ComfyUI.
TAESD preview fails with a size mismatch
Use taew2_1 for previews.
lora key not loaded: lora_te_layers_…
A kohya LoRA with text encoder layers. Fixed in ComfyUI; update.
Plain, generic-looking pictures from Base
Base has a neutral default style by design. Add @artist tags, or use Aesthetic or Turbo.

It’s only a 2B model, so why is it slower than SDXL?

Hugging Face, circlestone-labs/Anima

Which clip type is right: stable diffusion, cosmos or qwen?

Hugging Face, circlestone-labs/Anima

Questions.

Which Anima file should I download?

Start with Turbo: 8 to 12 steps at CFG 1, and only slightly behind Aesthetic on average. Use Aesthetic for finished pictures and Base for training LoRAs or a neutral style.

What sampler and settings does Anima use?

Base and Aesthetic: 30 to 50 steps, CFG 4 to 5, er_sde with the simple scheduler, which is what the model card and Comfy’s templates use. Turbo: 8 to 12 steps at CFG 1, where euler also works well.

Why is Anima slower than SDXL?

It’s a diffusion transformer, and its attention costs more per step than SDXL’s UNet. On an RTX 4060 Ti it takes about three times as long. Turbo, torch.compile and int8 conversions are the usual ways to speed it up.

Can I sell images made with Anima?

Yes. The weights are non-commercial, but the licence lets you use outputs for any purpose, including commercial ones. Running Anima as a paid service needs a licence from CircleStone Labs.

Which clip type do I pick for the Anima text encoder?

Comfy’s template uses stable_diffusion. In current ComfyUI, cosmos and qwen give the same result, so it doesn’t matter.

Does Anima run on an old GPU?

Yes, once ComfyUI is up to date. Cards without bf16, such as the GTX 10 and 16 series, used to fall back to fp32 and take minutes or hours per image; since February 2026 ComfyUI uses fp16 on them. A GTX 970 with 4 GB runs the Q8_0 GGUF.

Sources: Anima model card, licence, ComfyUI Anima tutorial, Arc B580 report [1], SDXL comparison [2], GTX 970 and 1060 thread [3], ComfyUI issue #12477, sampler and hires thread.

HEISS UI

Anime, without the loader hunt.

HEISS UI runs Anima on the ComfyUI you already have. Drop in the file and it brings the small text encoder and VAE that go with it.

  • Renamed downloads still work. It knows Anima from the file itself, whatever the download is called.
  • Your LoRAs, sorted. The ones made for this model come first, with their trigger words.
  • Missing parts, shown first. Each one listed with its size and a button. Get all checks free space, and downloads resume and are verified.
  • Start from a sketch. Add a start image and a slider sets how far the result may move from it.

Free and open source. macOS, Windows and Linux. Runs on your ComfyUI.

HEISS UI with a gallery of generated images and the prompt composer at the bottom.