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

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, ~2.6 GB as int8 or fp8), the Qwen3 encoder ~1.2 GB and the VAE ~200 MB. On low-VRAM GPUs, Low-VRAM mode and 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)

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

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

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

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