# Anima

Anima is a **2B-parameter**, anime-focused text-to-image model built on NVIDIA's **Cosmos Predict2**
diffusion transformer. Instead of a large text encoder, it pairs a small **Qwen3 0.6B** encoder with a
built-in **LLM adapter** that translates the encoder's output for the transformer. It decodes with the
16-channel Wan 2.1 / Qwen Image VAE.

InvokeAI supports Anima for text-to-image, and on the Canvas for image-to-image, inpainting, outpainting
and regional prompts. Two community finetunes are supported as well: **Anima-2.9B** and **Anima-3.8B**
(see [below](#community-finetunes)).

## License

Anima is released under the **CircleStone Labs Non-Commercial License**, and, because it is built on Cosmos-Predict2, the NVIDIA Open Model License also applies. The weights may not be used commercially; the model card says images you generate may be. The download is not gated.

This is a summary, not legal advice. Read the full license on the model's HuggingFace page before using a model commercially.

## Hardware

Anima is small by current standards: the transformer is a ~4.5 GB download (1.0–2.2 GB as a
[GGUF](#gguf-builds), ~2.6 GB as [int8](#int8-builds) or [fp8](#fp8-builds)), the Qwen3 encoder ~1.2 GB and the VAE ~200 MB. On low-VRAM GPUs,
[Low-VRAM mode](/configuration/optimization/low-vram-mode/) and
[FP8 Storage](/configuration/optimization/fp8-storage/) both apply to Anima.

## Installing

Install the **Anima** bundle from the Model Manager's Starter Models. It contains:

- **Anima Base 1.0** — the main model (single-file checkpoint, ~4.5 GB)
- **Anima Qwen3 0.6B Text Encoder** (~1.2 GB)
- **Anima QwenImage VAE** (~200 MB)
- **Anima LLLite Inpainting** and **Anima LLLite Sketch** — ControlNet-LLLite adapters (see
  [below](#controlnet-lllite-adapters))

Installing *Anima Base 1.0* on its own also installs the encoder and VAE as dependencies. Anima is
distributed as single files only, a checkpoint or a GGUF, so the three components are always separate models:

| Component    | Model                                                          |
| ------------ | -------------------------------------------------------------- |
| Transformer  | the Anima checkpoint or GGUF (Cosmos Predict2 DiT + LLM adapter) |
| Text encoder | a **Qwen3 0.6B** encoder                                       |
| VAE          | the 16-channel Wan 2.1 / Qwen Image VAE                        |

Select the **Qwen3 Encoder** and **VAE** in the **Components** section next to the model; both are
required. Only the 0.6B Qwen3 encoder is offered — the larger Qwen3 encoders used by Z-Image and FLUX.2
are not compatible. The same VAE file may be installed under the Anima, Qwen Image or Wan base, and all
three are listed. FLUX VAEs are **not** compatible.

Anima also needs a T5-XXL tokenizer, which ships with InvokeAI; no T5 model has to be installed.

## Community finetunes

Both finetunes keep Anima's VAE, schedulers and Canvas support, and install from the Starter Models.

| Model | What changes | Components |
| ----- | ------------ | ---------- |
| **Anima-2.9B** (Preview v1) | 40 transformer blocks instead of 28, trained on 1.7M more images (cutoff July 2026). An int8 build (~3.1 GB) halves the memory of the bf16 one (~5.8 GB); by default it is not faster ([int8 Compute](/configuration/optimization/int8-compute/) can run its convrot layers on the int8 tensor cores; not measured on Anima). | Same as Anima |
| **Anima-3.8B** (v1.1) | 52 blocks, plus a **semantic connector** bundled in the checkpoint that adds a second text encoder, **Qwen3.5 4B**, for better prompt adherence, multi-character binding and mixed natural-language/tag prompts. | Qwen3 0.6B **and** Qwen3.5 4B encoder, VAE |

With an Anima-3.8B model selected, the **Components** section shows a third picker, **Qwen3.5 Encoder**,
and generation needs it. Its starter model (~4.8 GB) installs together with Anima-3.8B. The picker lists
only Qwen3.5 4B encoders: MOSS-Image's Qwen3.5 9B installs under the same type but does not work with Anima-3.8B. The connector
runs once per denoising step, so Anima-3.8B is slower per step than Anima-2.9B (about 1.3 against 1.7
iterations per second at 832×1216 on an RTX 4090), and its Qwen3.5 encoder adds memory while the prompt
is encoded. **Reset all to model defaults** sets 40 steps at CFG 6, the settings of the author's reference
workflow.

[FP8 Storage](/configuration/optimization/fp8-storage/) changes Anima-3.8B's images more than Anima's: at
the same seed the composition can change, where Anima keeps it and only details differ.

Only the v1.1 checkpoint of Anima-3.8B is supported. The earlier v1.0 transformer needs a separate adapter
file and is refused at install with a message that says so.

Both finetunes are derivatives of Anima and fall under the same non-commercial license.

:::note[LoRAs and LLLite adapters]
LoRAs and ControlNet-LLLite adapters address the transformer's blocks by position, and the finetunes
insert their extra blocks between the original ones. Invoke moves an adapter trained on Anima to the
blocks the finetune kept from Anima, and one trained on Anima-2.9B to its blocks in Anima-3.8B.
Anima-2.9B keeps Anima's blocks unchanged, so Anima adapters work there as on Anima itself.
Anima-3.8B changed them slightly and adds the semantic connector, so results there can differ more.
:::

## GGUF builds

Community GGUF conversions of the transformer install and generate like the checkpoint, with the same Qwen3
encoder and VAE as separate components, and LoRAs apply to them. FP8 Storage does not: the weights are already
quantized. The **Anima Turbo 1.1 (GGUF, Q8_0)** starter model is one: Anima Turbo, the distilled version of
Anima for fast generations, at about half the memory of the bf16 checkpoint (~2.2 GB). Like any Anima model
whose name contains "turbo", it is set to 10 steps at CFG 1 when selected; its model card recommends CFG 1 and
8–12 steps.

These builds are known to install and load:

| Repository | Model | Notes |
| ---------- | ----- | ----- |
| `vanes430/Anima-Turbo-V1.1-GGUF` | Anima Turbo v1.1 | ComfyUI-GGUF conversion; Q8_0 and Q4_K_M checked |
| `Bedovyy/Anima-GGUF` | Anima Preview | `anima-preview-Q8_0.gguf` checked; the repository also holds Preview 2 and Preview 3 builds |
| `JusteLeo/Anima2-GGUF` | Anima Preview 2 | stable-diffusion.cpp conversion; Q8_0 checked |
| `n-Arno/Anima-P3-Turbo-AIO-Q4_K` | UnNamedA V1, a community Anima model | stable-diffusion.cpp all-in-one file, which also holds a Qwen3 encoder and the VAE. Only the transformer is read: the bundled encoder, a modified one, is not used, and the encoder and VAE you select replace it. `UNNAMED-ANIMA-V1-Turbo-AIO-SdCpp-Q4_K.gguf` checked; the repository's other all-in-one files are not |

`Abiray/Anima-base-v1.0-GGUF`, a ComfyUI-GGUF conversion of Anima Base 1.0, is recognized from its Q3_K_M and
Q8_0 headers but has not been loaded.

The GGUFs in `vanes430/Anima-2.9B-GGUF` are broken conversions: every quantized tensor holds the bf16 weights'
raw bytes and is twice as wide as the model's, so the weights cannot be recovered. They are refused at install;
use the **Anima-2.9B (Preview v1)** starter model instead, or its int8 build for about half the memory.

No GGUF of Anima-3.8B has been verified, so one is refused at install as well; use its safetensors starter
model. A 52-block GGUF without Anima-3.8B's semantic connector is refused too, because it cannot be told apart
from the unsupported v1.0 transformer.

## int8 builds

Two starter models install Bedovyy's `int8_convrot` builds with the same Qwen3 encoder and VAE as dependencies:
**Anima Base 1.0 (int8)** and **Anima Turbo 1.1 (int8)**, ~2.6 GB each. Their int8 layers stay int8 on every
supported GPU, about 2.7 GB once loaded. By default they are not faster than the bf16 checkpoint;
[int8 Compute](/configuration/optimization/int8-compute/) can run their layers on NVIDIA int8 tensor cores. Like
the Turbo GGUF, the Turbo build is set to 10 steps at CFG 1 when selected.

## fp8 builds

Two starter models install Bedovyy's fp8 builds with the same Qwen3 encoder and VAE as dependencies: **Anima Base
1.0 (fp8)** and **Anima Turbo 1.1 (fp8)**, ~2.6 GB each, about half the size of the bf16 checkpoint. FP8 Storage is
switched on when they are installed. Like the Turbo GGUF and int8 build, the Turbo build is set to 10 steps at CFG 1 when selected.

## Generation settings

Selecting an Anima model applies these defaults:

- **Steps:** 35
- **CFG Scale:** 4.5 (the minimum is 1, which turns CFG off)
- **Scheduler:** Euler
- **Size:** 1024×1024; width and height snap to multiples of 8.

A model whose name contains "turbo", such as Anima Turbo, gets **10 steps** at **CFG 1** instead. Anima-3.8B's
defaults are given [above](#community-finetunes).

The **Scheduler** menu offers Anima's own set: **Euler**, **Heun (2nd order)**, **DPM++ 2M**,
**DPM++ 2M SDE**, **ER-SDE** and **LCM**.

The **negative prompt** is used only when CFG Scale is above 1; at CFG 1 it is ignored.

## Regional prompting

On the Canvas, **Regional Guidance** layers support positive and negative prompts: each prompt is steered to
its masked area, alongside the global prompt. The global positive prompt covers the area outside the regions,
while the global negative prompt applies to the whole image. **Auto-Negative** uses the region's positive
prompt as a negative outside its mask. Regional negatives and auto-negative take effect only when **CFG
Scale** is above 1; Turbo's default CFG 1 ignores them. The restriction is applied on alternating transformer
blocks, leaving the others unrestricted to keep the image coherent. Regional reference images are not
supported.

In the workflow editor, the **Prompt - Anima** node has an optional **mask** input, and **Denoise -
Anima** accepts a collection of conditionings for its positive and negative inputs.

## LoRA

Anima LoRAs in Kohya / LyCORIS and Diffusers PEFT formats are supported. They apply to the transformer and, where the LoRA
includes text-encoder layers, to the Qwen3 encoder. In the workflow editor use **Apply LoRA - Anima** or
**Apply LoRA Collection - Anima**.

## Character reference (IP-Adapter)

The **Anima IP-Adapter (Character Reference)** starter model, by LuciferTC (~500 MB), carries a character
from reference images into the generation. It was trained on anime images. Installing it also installs
the **SigLIP2** image encoder it reads the reference with (google/siglip2-base-patch16-512, ~1.5 GB). If the
adapter came from somewhere else, Invoke installs the encoder the first time a reference is used; in
multi-user mode only an administrator's generation does, and anyone else is asked to have it installed
from the Model Manager.

To use it, select an Anima model and add a reference image in the **Guidance** section; the first installed
Anima IP-Adapter is selected for it. The card has one main control, **Strength**, from 0 to 2 (default 1),
and **Active steps** under **Advanced**. There is no **Mode** or CLIP Vision choice as there is for SD
IP-Adapters.

- **Strength** scales how much of the reference the image carries. **0** turns the reference off, and the
  image is exactly what you would get without it. Higher values carry more of the character, and also more
  of the reference's composition.
- **Active steps** limit when the reference image is attended. The adapter's built-in LoRA stays on for the
  whole generation, so even a range that leaves out every step does not give the same image as no reference.
- **Up to four reference images** (experimental: the adapter was trained on single images). References that
  use the same adapter are attended together, each with its own **Strength** and **Active steps**, and the
  built-in LoRA is applied once.
  - Several images of the **same** character work well together.
  - Images of **different** characters blend. The adapter cannot assign an image to one figure, even with a
    prompt such as "2girls", so expect hair, outfits and accessories to mix.
  - Each image's **Strength** sets how much of it goes into the mix. A low but non-zero Strength still takes
    attention away from the other images, so remove a reference rather than turning it down near 0.
- **Anima and Anima-2.9B only.** The adapter was trained on Anima's 28-block releases. Invoke applies it to
  the blocks Anima-2.9B kept from Anima, the same way it maps LoRAs, but that combination is untested.
  With an **Anima-3.8B** model selected, reference images are not offered.

What it carries, from our tests on Anima Base 1.0:

- A character's **appearance** transfers: hair colour and style, outfit and accessories. At strength 1.5,
  even details such as the skirt carried over.
- Fine details can be lost. A character's **heterochromia** (two different eye colours) did not carry.
- A **stylized reference** brings its composition and content along, not only its style. The adapter is
  not a style transfer: expect the pose, framing and objects of the reference to show up as well.

In the workflow editor, add an **IP-Adapter - Anima** node, give it the reference image and the adapter
model, and connect its output to the **IP-Adapter** input of **Denoise - Anima**. For several references, add
one node per image and collect them into that input.

The adapter is a derivative of Anima and falls under the same **CircleStone Labs Non-Commercial License**:
it may not be used commercially. Images you generate may be.

## ControlNet-LLLite adapters

Anima supports kohya-ss's **ControlNet-LLLite** adapters, small models (8–66 MB) that condition the
transformer on an image. Each adapter model may be used only once per generation, and each has
**Weight**, **Begin Step Percent** and **End Step Percent** settings.

- **On the canvas**, add a control layer while an Anima model is selected. Its adapter type is **Anima
  ControlNet-LLLite**, its pixels are the control image, and several control layers combine as long as
  each uses a different model. The **Model** list holds the control adapters (Sketch, Depth, Scribble,
  Lineart, Pose); the Inpainting adapter needs an inpaint mask rather than a control image, so it is not
  offered there. An adapter installed before Invoke recorded which kind it is appears as a disabled entry
  marked **Needs re-identify**. Its page in the Model Manager explains this and offers **Re-identify model**;
  after you confirm, Invoke re-probes the file and the adapter becomes usable (or is hidden, if it is the
  Inpainting adapter). Re-identifying resets the model's custom variant and default settings. Users who
  cannot manage models see the explanation and are asked to contact an administrator.
  A control layer from an older project may still be set to **ControlNet**, which Anima cannot run; its
  settings say so and offer **Switch to Anima ControlNet-LLLite**, which keeps the selected adapter.
- **When inpainting or outpainting on the canvas**, pick the Inpainting adapter as the optional **Inpaint
  Adapter** in the Generate panel's **Components** section, and set its **Inpaint adapter weight** (1 by
  default). Invoke then conditions the adapter on the raster image and the region being generated; the
  setting is ignored for text-to-image and image-to-image. Turn off **Use inpaint adapter** to inpaint
  without it; the selected adapter and its weight are kept for when you turn it back on. The adapter and its
  weight are recorded in the image's metadata and restored by **Recall All** and **Remix Image**; recalling an
  inpaint or outpaint image made without the adapter turns **Use inpaint adapter** off.
- **In the workflow editor**, add an **Anima ControlNet-LLLite** node, give it the conditioning image and
  a control model, and connect it to the **Control LLLite** input of **Denoise - Anima**, collecting
  several nodes to combine them.

| Starter model                       | Purpose                                                        |
| ----------------------------------- | -------------------------------------------------------------- |
| **Anima LLLite Inpainting**         | Conditions on the masked image during inpainting/outpainting. Requires the node's **mask** input (white = area to inpaint). |
| **Anima LLLite Sketch**             | Mixed scribble / HED / lineart / grayscale conditioning        |
| **Anima LLLite Depth (Preview3)**   | Depth                                                          |
| **Anima LLLite Scribble (Preview3)**| Scribble                                                       |
| **Anima LLLite Lineart (Preview3)** | Lineart                                                        |
| **Anima LLLite Pose (Preview3)**    | Pose                                                           |

:::caution[Preview3 adapters]
The four *Preview3* adapters were trained on an earlier Anima build and give reduced quality on Anima
Base 1.0; the pose adapter is notably weak. Only the Inpainting and Sketch adapters are in the bundle.
:::

## Workflow nodes

| Node                         | Purpose                                                   |
| ---------------------------- | --------------------------------------------------------- |
| **Main Model - Anima**       | Loads the transformer, Qwen3 encoder and VAE, and for Anima-3.8B the Qwen3.5 encoder |
| **Prompt - Anima**           | Encodes a prompt, with an optional regional mask; connect the Qwen3.5 encoder for Anima-3.8B |
| **Denoise - Anima**          | Runs sampling; accepts img2img latents, masks, LLLite adapters and an IP-Adapter |
| **Image to Latents - Anima** | VAE encode                                                |
| **Latents to Image - Anima** | VAE decode                                                |
| **Anima ControlNet-LLLite**  | Configures one ControlNet-LLLite adapter                  |
| **IP-Adapter - Anima**       | Encodes a reference image for the Anima IP-Adapter        |