DEV Community

AI-KSK
AI-KSK

Posted on Originally published at huggingface.co

Anima Preview 3: When the Encoder Type Finally Agrees With Itself

The Anima family has a recurring problem: the CLIP loader type is inconsistent between workflows in the same release, and getting it wrong fails silently. Preview 3 is the first version in this lineage where all four workflows agree — and that alone makes it a better starting point than its predecessors.

The consistency result

Workflow Nodes CLIP type
Text-to-image 10 stable_diffusion
Image-to-image 13 stable_diffusion
Inpainting 16 stable_diffusion
Block/tiled upscale 52 stable_diffusion

All four use stable_diffusion with qwen_3_06b_base.safetensors. Compare that against earlier Anima releases where the same encoder file was loaded as qwen_image in some graphs and stable_diffusion in others.

This is worth calling out because it changes the debugging experience. With a consistent type, a bad result is your prompt or your LoRA. With an inconsistent type, a bad result might be an invisible configuration difference between two workflows that look identical.

The node counts tell you the shape

Workflow Nodes
Text-to-image 10
Image-to-image 13
Inpainting 16
Block upscale 52

Ten nodes for text-to-image is close to minimal — loader, prompt, latent, sampler, decode, save. There is no face repair, no hand repair, no control network. Preview 3 is the base, and the release treats it as such.

The 52-node upscale graph is the outlier, and upscaling is where the complexity actually lives.

The latent size picker

The text-to-image graph uses SDXLEmptyLatentSizePicker+ with 896x1088 (0.82).

That is 0.82 megapixels at an aspect of 0.824 (roughly 4:5). Not a square, not 16:9 — a portrait-ish aspect that suits illustration.

The picker node rather than a raw EmptyLatentImage is a small but useful design choice: it front-loads the resolution/aspect decision instead of leaving it as two typed numbers.

The persistent Flux LoRA

The block-upscale graph still loads:

LoraLoader → Gundam_RX78_Flux.safetensors at weight 0.85

This is a Flux-architecture LoRA inside an Anima model, carried over from an earlier release. Flux and Anima are different architectures; a Flux LoRA is not architecturally valid for an Anima base.

It loads, it applies something, and the output looks styled. That is the problem — a wrong-architecture LoRA produces a plausible result rather than an error, so you cannot tell whether the effect you see is intended or an artifact.

If you use the upscale workflow as a template, clear that slot. It is left over from testing.

Where Preview 3 is weak

  1. Ten nodes means no safety net. No face repair, no hand repair, no control. Fine for a base, inconvenient for production.
  2. The Flux LoRA is still in the upscale graph.
  3. 0.82 MP base. Upscaling is not optional if you need detail; the base alone will not carry it.
  4. Only four workflows. No sampler variants, no style presets — the release covers the base and expects you to build on it.

Practical order

Text-to-image first (10 nodes, nothing to get wrong), then inpainting (16 nodes, the most useful in practice), then upscale. Clear the LoRA slot in the upscale graph before you touch anything else.

Workflows

Four graphs, published on RunningHub with invite code rh-v1111:

  • Anima Preview 3 text-to-image
  • Anima Preview 3 image-to-image
  • Anima Preview 3 inpainting
  • Anima Preview 3 block/tiled upscale

Files

https://huggingface.co/AI-KSK/ksk-video-219-comfyui-workflows

Notes

  • Workflow files only. Model weights are not included; each keeps its own licence.
  • Tutorial exports, not a product.
  • Node counts, CLIP types and LoRA values quoted above are read from the published JSON files.
  • Independent AI-KSK release. Not affiliated with the model authors or RunningHub.

Top comments (1)

Collapse
 
alexshev profile image
Alex Shev •

Encoder agreement is a good reminder that type metadata is part of reproducibility. I’d persist the resolved encoder class, model revision, and graph serialization with each render, then fail early when a node receives an incompatible representation. That saves users from debugging a visually plausible result that cannot be recreated after one component updates.