README.md

---
license: other
license_name: mixed-license
base_model:
  - circlestone-labs/Anima
base_model_relation: finetune
pipeline_tag: text-to-image
tags:
  - anime
  - noob2-project
  - character-reference
  - multi-reference
  - image-conditioned-generation
  - native-reference
  - text-to-image
  - anima
  - research
---

# NOOB2 Project — Anima Native Reference V2 (E180)


![cover-0721](https://cdn-uploads.huggingface.co/production/uploads/63d3a01ae149f591b950f5e8/CzXYAhk7i51-cgqo4pyru.png)

**Anima Native Reference V2 E180** is an experimental two-reference,
image-conditioned generation checkpoint developed as part of the
**NOOB2 Project — Character Reference Bypass Injector Research**.

The model generates a new anime illustration from pure noise while conditioning
on:

- a text prompt;
- Reference Image 1, assigned to ordered slot `0`;
- Reference Image 2, assigned to ordered slot `1`.

The two reference slots do not have permanently assigned scene, character,
identity, source, or style roles. Their order is preserved exactly, while the
prompt determines how the model should interpret and combine them.

The Native Reference V2 modules are already integrated into the E180 diffusion
checkpoint. No external LoRA, IP-Adapter, or separate reference-adapter weight
file is required.

> **Research preview:** This repository contains an experimental checkpoint,
> ComfyUI integration, reproducible workflows, and validation artifacts. It is
> not yet intended as a final production release.

## About the “Bypass Injector” Name

In this project, **bypass injector** refers to an auxiliary visual-conditioning
path that injects ordered reference features into the diffusion model through
its native reference sequence and reference-attention modules.

It does not refer to bypassing safety systems, content filters, platform
restrictions, or access controls.

## Release Information

| Item | Value |
|---|---|
| Model version | Native Reference V2 E180 |
| Base architecture | Anima |
| Integrated checkpoint | `anima-native-ref-v2-e180-step64080-256px.safetensors` |
| Checkpoint step | `64,080` |
| Training/validation bucket | 256-pixel-area buckets |
| Checkpoint size | `4,271,362,542` bytes |
| Reference inputs | Exactly two ordered images |
| Generation path | Pure-noise text-to-image generation |
| Primary interface | ComfyUI |
| Status | Experimental research preview |

## Key Properties

- One integrated Native Reference V2 diffusion checkpoint
- Two explicitly ordered reference-image inputs
- Prompt-defined reference semantics
- Pure-noise generation rather than img2img
- Native V2 reference-latent sequence
- Native V2 reference-attention route
- No denoise-strength control
- No external LoRA or reference-adapter weight
- No stock ComfyUI `KSampler` path
- UI and local `/prompt` API workflows included
- Bounded runtime, prompt-embedding, and reference-latent caches
- Optional release SHA-256 verification

## Model Architecture

This release uses the following integrated diffusion checkpoint:

```text
anima-native-ref-v2-e180-step64080-256px.safetensors
```

This file is the diffusion model used for generation. It replaces the stock
Anima diffusion-model checkpoint in this workflow.

**Do not load an additional stock Anima diffusion checkpoint alongside it.**

The following auxiliary Anima assets are still required:

```text
qwen_3_06b_base.safetensors
qwen_image_vae.safetensors
```

The complete runtime consists of:

```text
Integrated E180 Native Reference V2 DiT
+ Anima Qwen3-0.6B text encoder
+ Qwen-Image VAE
```

The two reference images are encoded by the VAE into two ordered reference
latent streams. These streams are supplied to the diffusion model through its
integrated Native Reference V2 sequence and reference-attention modules.

Generation starts from pure noise. The reference images are not used as an
initial denoising canvas.

Consequently:

- this is not a conventional img2img workflow;
- there is no denoise-strength parameter;
- the workflow does not use the stock ComfyUI `KSampler`;
- the workflow does not load an external LoRA;
- the workflow does not load an external IP-Adapter;
- the workflow does not load a separate learned reference adapter.

A custom inference plugin is still required because the standard Anima runtime
does not implement the additional Native Reference V2 modules contained in the
integrated checkpoint.

## Reference Semantics

![Workflow overview](comfyui/examples/anima_ref_v2_e180-workflow-thumbnail.jpg)
The two reference inputs are defined only by their order:

```text
Reference Image 1 → ordered slot 0
Reference Image 2 → ordered slot 1
```

The slots do not have hard-coded semantic roles.

They are not permanently defined as:

- scene and character;
- source and target;
- identity and style;
- foreground and background.

Instead, the prompt defines how the two references should be interpreted.

For example:

```text
Use the first image as the scene template and the second image as the
character template. Generate an edited result where the character matches
Image 2 and the scene remains faithful to Image 1.
```

A different prompt may assign entirely different roles to the same two ordered
slots.

The model preserves the input order, but the prompt determines the requested
relationship between the images.

## Included ComfyUI Nodes

The release contains two primary custom nodes.

| Node | Purpose |
|---|---|
| **Anima Reference V2 Loader (E180)** | Loads and caches the integrated E180 checkpoint, Anima Qwen3-0.6B text encoder, and Qwen-Image VAE. |
| **Anima Reference V2 Generate (2 Refs)** | Generates one image from a prompt and two explicitly ordered reference images. |

### Loader output

The Loader returns a custom pipeline object:

```text
ANIMA_NATIVE_REF_V2_PIPELINE
```

It does not expose conventional ComfyUI `MODEL`, `CLIP`, and `VAE` outputs.

### Generate inputs

The Generate node accepts:

- the loaded Native Reference V2 pipeline;
- Reference Image 1, ordered slot `0`;
- Reference Image 2, ordered slot `1`;
- positive prompt;
- negative prompt;
- seed;
- output width and height;
- sampling steps;
- CFG;
- flow shift;
- native reference scale;
- maximum preprocessing area for each reference.

The first release requires exactly two reference inputs.

Each input currently accepts exactly one image:

```text
IMAGE [1, H, W, 3]
```

Batched inputs with `B > 1` are rejected. For an animated or batched input,
select one frame first with `ImageFromBatch`.

## Repository Contents

```text
.
├── checkpoints/
│   └── v2-e180/
│       └── anima-native-ref-v2-e180-step64080-256px.safetensors
│
├── comfyui/
│   ├── custom_nodes/
│   │   └── ComfyUI-Anima-Native-Reference/
│   ├── examples/
│   │   ├── anima_ref_v2_e180-workflow-thumbnail.jpg
│   │   └── e180-heldout-000052-comfy-output.png
│   ├── releases/
│   │   └── v0.1.0-e180/
│   ├── workflows/
│   │   ├── anima_ref_v2_e180.json
│   │   └── anima_ref_v2_e180_api.json
│   ├── MANIFEST.json
│   ├── README.md
│   ├── SHA256SUMS
│   └── TEST_REPORT.md
│
├── .gitattributes
└── README.md
```

## Required Model Files

Place the required files in the following directories:

```text
ComfyUI/
└── models/
    ├── diffusion_models/
    │   └── anima-native-ref-v2-e180-step64080-256px.safetensors
    ├── text_encoders/
    │   └── qwen_3_06b_base.safetensors
    └── vae/
        └── qwen_image_vae.safetensors
```

### 1. Integrated E180 checkpoint

File:

```text
anima-native-ref-v2-e180-step64080-256px.safetensors
```

Repository path:

```text
checkpoints/v2-e180/anima-native-ref-v2-e180-step64080-256px.safetensors
```

Destination:

```text
ComfyUI/models/diffusion_models/
```

Size:

```text
4,271,362,542 bytes
```

SHA-256:

```text
1f970a7867dd7b65858d30b58135134ce84fd3b552ab27fc9f07e7f15209c6dd
```

This is the complete diffusion-model checkpoint used by the workflow.

Do not load a separate stock Anima diffusion checkpoint in addition to this
file.

### 2. Anima text encoder

File:

```text
qwen_3_06b_base.safetensors
```

Source:

[Anima text encoders](https://huggingface.co/circlestone-labs/Anima/tree/main/split_files/text_encoders)

Destination:

```text
ComfyUI/models/text_encoders/
```

Size:

```text
1,192,135,096 bytes
```

SHA-256:

```text
cd2a512003e2f9f3cd3c32a9c3573f820bb28c940f73c57b1ddaa983d9223eba
```

### 3. Qwen-Image VAE

File:

```text
qwen_image_vae.safetensors
```

Source:

[Anima VAE files](https://huggingface.co/circlestone-labs/Anima/tree/main/split_files/vae)

Destination:

```text
ComfyUI/models/vae/
```

Size:

```text
253,806,246 bytes
```

SHA-256:

```text
a70580f0213e67967ee9c95f05bb400e8fb08307e017a924bf3441223e023d1f
```

## Requirements

- A current ComfyUI installation
- Python 3.10 or newer
- NVIDIA CUDA GPU
- BF16 support
- Sufficient system RAM for the cached runtime
- The exact E180, Qwen, and VAE files listed above

The first release deliberately validates the expected checkpoint layouts
instead of silently loading similarly named but incompatible files.

## Installation

### 1. Install the custom node

Copy:

```text
comfyui/custom_nodes/ComfyUI-Anima-Native-Reference/
```

into:

```text
ComfyUI/custom_nodes/ComfyUI-Anima-Native-Reference/
```

Alternatively, use one of the packaged releases under:

```text
comfyui/releases/v0.1.0-e180/
```

### 2. Install dependencies

Use the same Python interpreter that starts ComfyUI:

```bash
cd ComfyUI/custom_nodes/ComfyUI-Anima-Native-Reference
python -m pip install -r requirements.txt
```

The package does not pin or install PyTorch.

Do not replace an existing working ComfyUI CUDA installation of `torch` or
`torchvision`.

### 3. Restart ComfyUI

Restart ComfyUI after installing the custom node and dependencies.

## Workflows

### Standard ComfyUI workflow

Load:

```text
comfyui/workflows/anima_ref_v2_e180.json
```

### Local API workflow

Use:

```text
comfyui/workflows/anima_ref_v2_e180_api.json
```

The UI workflow and API workflow use different ComfyUI JSON formats. They
should not be treated as interchangeable files.

## Basic Usage

1. Install the custom node and restart ComfyUI.
2. Place the integrated E180 checkpoint in `models/diffusion_models/`.
3. Place Qwen3-0.6B in `models/text_encoders/`.
4. Place the Qwen-Image VAE in `models/vae/`.
5. Load the provided standard ComfyUI workflow.
6. Select one image in the Reference Image 1 node.
7. Select one image in the Reference Image 2 node.
8. Write a prompt that explicitly describes how the two references should be
   used.
9. Select the validated generation settings.
10. Queue the workflow.

Do not load a separate Anima base diffusion model. The integrated E180
checkpoint is the diffusion model used by this workflow.

## Prompt Examples

### General two-reference generation

```text
Create a new anime illustration using both reference images. Preserve the
relevant visual information from Reference Image 1 and Reference Image 2 while
following this instruction: show the referenced character in a coherent new
composition with clean anime rendering and detailed eyes.
```

### Scene from Image 1 and character from Image 2

```text
Use the first image as the scene template and the second image as the
character template. Generate an edited result where the character matches
Image 2 and the scene remains faithful to Image 1.
```

### Character design from both references

```text
Create a new anime illustration that combines the character identity and
costume details shown across both reference images. Preserve the most
recognizable facial features, hairstyle, colors, and accessories while
placing the character in a new full-body composition.
```

These prompts are examples only. They do not permanently assign semantic roles
to either reference slot.

## Validated Settings

| Setting | Value |
|---|---:|
| Output size | `256 × 256` |
| Steps | `40` |
| CFG | `1.0` |
| Flow shift | `5.0` |
| Native reference scale | `1.0` |
| Maximum area per reference | `65,536` pixels |
| Ordered slot IDs | `[0, 1]` |
| Attention mode | `torch` |
| Default offload mode | `balanced` |

The checkpoint was trained and validated with 256-pixel-area buckets.

Larger dimensions that are multiples of 16 are accepted by the current
implementation, but they should be treated as experimental rather than as a
validated quality guarantee.

## Memory Modes

| Mode | Behavior |
|---|---|
| `balanced` | Keeps the DiT on the GPU and moves Qwen and the VAE to the GPU only during their respective phases. |
| `high_vram` | Keeps the DiT, Qwen, and VAE on the GPU for faster repeated generation. |
| `text_encoder_cpu` | Runs text encoding on the CPU as a slower fallback for constrained GPU memory. |

The plugin maintains bounded caches for:

- loaded model runtimes;
- prompt embeddings;
- preprocessed reference latents.

Changing the prompt, seed, reference images, or sampling settings does not
normally require reading the 4.27 GB checkpoint from disk again.

## Verified Held-Out Output

![Verified held-out output](comfyui/examples/e180-heldout-000052-comfy-output.png)

The image above is the generated-only result for held-out integration case
`000052`.

Prompt:

```text
Use the first image as the scene template and the second image as the
character template. Generate an edited result where the character matches
Image 2 and the scene remains faithful to Image 1.
```

Generation settings:

| Setting | Value |
|---|---:|
| Seed | `20260720` |
| Resolution | `256 × 256` |
| Steps | `40` |
| CFG | `1.0` |
| Flow shift | `5.0` |
| Native reference scale | `1.0` |
| Reference maximum area | `65,536` |
| Ordered slots | `[0, 1]` |

The release package contains the generated frame rather than a combined
Reference 1 / Reference 2 / Generated comparison sheet.

It should therefore be interpreted as a verified integration and
reproducibility artifact, not as a complete standalone qualitative comparison.

## Integration Verification

The packaged runtime was validated using the exact release files on an
NVIDIA RTX PRO 6000 Blackwell.

The validation covered:

- loading the complete integrated E180 checkpoint;
- loading the Qwen3-0.6B text encoder;
- loading the Qwen-Image VAE;
- two-reference pure-noise generation;
- fixed ordered slots `[0, 1]`;
- the native V2 reference sequence;
- the native V2 reference-attention route;
- prompt and reference-latent caching;
- repeated runtime reuse;
- UI workflow schema validation;
- local `/prompt` API execution;
- generated-image saving;
- Unicode Chinese and Japanese prompt preservation.

The generated ComfyUI output for held-out case `000052` was pixel-identical to
the accepted native command-line result when decoded to RGB pixels:

```text
Maximum absolute pixel difference: 0
Mean absolute pixel difference:    0
Nonzero channel values:            0
```

Pixel SHA-256:

```text
20ba2661e8667bea3448c05021d5694d470474f7d39105ef1ee54096c394d04f
```

These results verify runtime and workflow parity. They should not be
interpreted as a comprehensive benchmark of character-reference quality.

## Intended Uses

This release is intended for research and experimental creative workflows
involving:

- anime character-reference conditioning;
- two-reference character and scene composition;
- character appearance transfer;
- costume and accessory reference;
- prompt-controlled changes to pose and composition;
- visual-development workflows;
- evaluation of native multi-reference conditioning;
- research into alternatives to per-character LoRA training;
- development and testing of Anima Native Reference V2 inference.

## Out-of-Scope Uses

This release is not designed to guarantee:

- exact identity reconstruction;
- biometric identification;
- exact face replication;
- reliable photorealistic identity transfer;
- exact reproduction of small accessories;
- exact reproduction of complex clothing;
- reliable multi-character identity assignment;
- accurate text or logo rendering;
- unrestricted production deployment;
- compatibility with arbitrary Anima checkpoints;
- compatibility with unrelated diffusion architectures.

## Known Limitations

- Exactly two reference inputs are supported.
- Each reference input currently accepts one image only.
- Reference slots are ordered but have no automatically inferred semantic
  roles.
- The release accepts the exact E180 Native Reference V2 model layout.
- Arbitrary stock Anima or future Native Reference checkpoints are not
  automatically supported.
- CUDA BF16 is required by the initial release.
- The plugin does not expose the conventional ComfyUI
  `MODEL / CLIP / VAE / KSampler` workflow path.
- The trained and validated output scale is based on 256-pixel-area buckets.
- Larger outputs remain experimental.
- Fine facial features may drift.
- Hair ornaments and small accessories may be changed or omitted.
- Clothing information from the two references may become mixed.
- Complex backgrounds may leak into the generated image.
- Extreme poses or camera angles may reduce character consistency.
- Multiple characters may lead to identity mixing.
- The generated composition may over-copy one of the references.
- Output quality may vary between random seeds.
- Photorealistic references are outside the primary target domain.
- The model does not guarantee exact reconstruction of either reference.

## Responsible Use

Only use reference images that you own or are authorized to use.

Do not use this model to:

- impersonate real people;
- misrepresent generated content as authentic evidence;
- harass or defame individuals;
- violate privacy or publicity rights;
- reproduce private or sensitive imagery without permission;
- infringe copyright or contractual restrictions;
- create illegal or exploitative content.

This model is not a safety classifier and does not guarantee that generated
outputs will be appropriate, accurate, or lawful.

Users are responsible for applying suitable content moderation, human review,
and access controls in downstream applications.

## Runtime Provenance

The Native Reference V2 inference implementation includes a pinned and
namespaced runtime snapshot derived in part from:

[akatsuki-neo/anima-edit](https://github.com/akatsuki-neo/anima-edit.git)

Audited source commit:

```text
2ae811d296ff4159c6024c4a86415d19961a388c
```

The vendored runtime:

- contains no model weights;
- uses a private namespace to avoid collisions with other custom nodes;
- retains upstream provenance and licensing information;
- is verified against a per-file integrity manifest before import.

## License

### Integrated Model Checkpoint

The integrated E180 checkpoint is distributed separately from the custom-node
source code.

Its use remains subject to:

- the terms published with this repository;
- the applicable terms of the underlying Anima model and assets;
- the repository access conditions;
- any other applicable third-party licenses.

Access to the gated repository does not grant rights beyond the applicable
license terms.

Users should review the current upstream and repository licenses before:

- redistributing the checkpoint;
- creating or distributing derivative models;
- hosting a public inference service;
- using the model commercially.

### Required Anima Assets

The Qwen3 text encoder and Qwen-Image VAE are downloaded from the Anima
repository and remain subject to their corresponding upstream terms.

### Custom Node and Runtime Code

The packaged ComfyUI integration and its vendored inference-source components
are provided under the licenses included in their respective `LICENSE` files.

The included runtime source retains the Apache-2.0 license and upstream
attribution where applicable.

A software license applying to the inference code does not override the
license governing the model checkpoint or required upstream model assets.

## Access and Integrity

The model repository may require users to:

- sign in to Hugging Face;
- accept the repository access conditions;
- provide the information requested by the repository owner.

Keep Hugging Face access tokens outside workflow JSON files and scripts.

Checksum files are included for validating release artifacts:

```text
comfyui/SHA256SUMS
comfyui/custom_nodes/ComfyUI-Anima-Native-Reference/SHA256SUMS
comfyui/releases/v0.1.0-e180/SHA256SUMS
```

Verify downloaded files before installation or redistribution.

## Acknowledgements

This project was made possible through the contributions of many developers,
researchers, and testers.

- **Yidhar** and **Nebulae** contributed to model training and dataset
  development.
- **spawner** provided important inspiration and portions of the code through
  the [`akatsuki-neo/anima-edit`](https://github.com/akatsuki-neo/anima-edit.git)
  project.
- **potato** contributed to the early development of the project.
- **GHOSTLXH**, **年糕特工队**, **轻松**, **Free Will**, and **韩小强**
  contributed testing, feedback, and early validation.

We also thank **CircleStone Labs** and **Comfy Org** for the development and
release of Anima, and the broader **ComfyUI** developer community for the
inference framework and ecosystem.

**Special thanks to Comfy.org for providing GPU sponsorship.**

## Project Credits

- Project: **NOOB2 Project**
- Model and integration release: **LAXMAYDAY / Laxhar Lab**
- Base architecture: **Anima**
- Primary interface: **ComfyUI**

## Citation

```bibtex
@misc{noob2_anima_native_reference_v2_2026,
  title        = {NOOB2 Project: Anima Native Reference V2 E180},
  author       = {LAXMAYDAY and Laxhar Lab},
  year         = {2026},
  howpublished = {Hugging Face model repository},
  note         = {Experimental two-reference native-conditioning checkpoint for Anima}
}
```

## Changelog

### v0.1.0-e180

- Released the integrated Native Reference V2 E180 checkpoint.
- Added two explicitly ordered reference-image inputs.
- Added prompt-defined reference semantics.
- Added the Native Reference V2 Loader node.
- Added the Native Reference V2 Generate node.
- Added the standard ComfyUI workflow.
- Added the local `/prompt` API workflow.
- Added balanced, high-VRAM, and CPU text-encoder modes.
- Added bounded runtime and conditioning caches.
- Added fail-closed checkpoint-layout validation.
- Added optional release SHA-256 verification.
- Added runtime and workflow validation tests.
- Added a verified held-out generated output.
- Added pixel-exact comparison against the accepted native CLI result.
- Added manifests, provenance records, and release checksums.