ComfyUI-Anima-Remap Introduction
ComfyUI-Anima-Remap is a collection of ComfyUI nodes that helps you reuse LoRAs, blend models, and apply ControlNets across different generations of the Anima model family.
The supported generations described here are:
- Original Anima: 28 blocks.
- Anima-2.9B: 40 blocks.
- Anima-3.8B: 52 blocks.
A block is one stage of the model’s image-processing network. Newer Anima generations were expanded by inserting additional blocks between existing ones. This changes the positions where a LoRA, another model’s weights, or a ControlNet should connect.
Without correcting those positions, an older LoRA can affect the wrong parts of a newer model. The result may be severely distorted images, scribble-like output, noisy merges, or weaker ControlNet guidance.
ComfyUI-Anima-Remap automatically corrects these block positions using mapping files called manifests.
What you can do
- Reuse older Anima LoRAs on newer Anima models without manually converting each file.
- Mix LoRAs from different Anima generations in one prompt, with the correct mapping selected separately for each LoRA.
- Merge Anima models with different block counts while preserving the larger model’s structure.
- Explore random LoRA combinations from folders or keyword-filtered collections.
- Use Anima ControlNet-LLLite weights across supported block layouts.
- Correct VACE ControlNet connection points for 40- and 52-block Anima models.
- Experiment with extending older LoRA or model effects into newly added blocks.
Scope: This is an Anima-family compatibility tool, not a general converter for SD1.5, SDXL, Flux, or unrelated model architectures. Correct block alignment also does not guarantee that every LoRA will look identical across models or text encoders.
Compatibility with older workflows
This extension succeeds ComfyUI-Anima29B-Remap, which is no longer updated. The author retained the existing node IDs so workflows created with the earlier package can continue loading.
Do not keep both packages active. They register the same node IDs and will conflict. For migrated workflows, review the manifest setting and use Auto (Recommended) unless you intentionally need a particular mapping.
How ComfyUI-Anima-Remap Works
1. Why block positions need correction
Imagine a book that originally contained 28 chapters. A revised edition adds new chapters between the existing ones, bringing the total to 40. Instructions that say “edit chapter 14” may now point to the wrong chapter.
Anima’s expansion works similarly:
Original Anima: 28 blocks
↓ 12 inserted blocks
Anima-2.9B: 40 blocks
↓ 12 more inserted blocks
Anima-3.8B: 52 blocks
A LoRA contains small sets of learned adjustments aimed at particular parts of the model. Remapping changes the addresses of those adjustments so they reach the corresponding blocks in the expanded model.
It does not retrain the LoRA.
2. The extension identifies the block layouts
For LoRA loading, the extension examines the connected model and each LoRA’s block references. Detection is based on the highest referenced block index, plus one.
For example, when you connect a 52-block model and use both a 28-block LoRA and a 40-block LoRA:
- The 28-block LoRA uses a 28 → 52 mapping.
- The 40-block LoRA uses a 40 → 52 mapping.
- A matching 52-block LoRA does not need remapping.
This decision happens independently for every LoRA, including LoRAs chosen by the random loaders.
3. A manifest supplies the translation
A manifest is a small JSON file describing how block positions changed during expansion. It contains mapping information, not model weights.
| Mapping file | Purpose | Source |
|---|---|---|
expand_manifest_28_40.json | Original Anima → Anima-2.9B | Official expansion mapping |
expand_manifest_40_52.json | Anima-2.9B → Anima-3.8B | Reconstructed mapping |
expand_manifest_28_52_composed.json | Original Anima → Anima-3.8B | Automatically composed from the two mappings above |
Leave manifest on Auto (Recommended) for ordinary use. Selecting a specific file forces that mapping instead of letting the node choose the appropriate one for each input.
Mapping provenance matters: no official 40 → 52 mapping was available in the supplied documentation. The author reconstructed it by comparing corresponding blocks in Anima-2.9B and anima38B_base.safetensors, using two different weight groups to cross-check the result.
Future block-expanded generations can be supported through additional compatible manifests, but an unknown architecture is not automatically supported merely because it has more blocks.
4. Newly inserted blocks are treated separately
An older LoRA has no trained adjustment for blocks that did not exist when it was trained.
By default:
- LoRA loading: adjustments are moved to their corresponding existing blocks; newly inserted blocks receive no projected LoRA effect.
- Model merging: newly inserted blocks retain the larger-generation model’s own values.
- LLLite: newly inserted blocks receive no control effect unless extension is enabled.
Optional extension settings estimate what to apply to these new blocks. These settings are experimental approximations, not recovered training data.
5. Not every component is remapped
Main-model detection and remapping target Anima’s net.blocks.N structure. The separate llm_adapter.blocks structure is excluded.
For Anima-3.8B v1.1 and later, the Qwen3.5 4B semantic connector may be bundled into the main checkpoint rather than supplied separately. Its semantic_attentions.* and related connector keys do not match the main block pattern and are not remapped.
ComfyUI-Anima-Remap Features
Choosing the right node
Double-click the ComfyUI canvas and search for Anima.
| Node | Best suited to |
|---|---|
| Anima LoRA Tag Loader (Auto Remap) | Applying named LoRAs written in a prompt |
| Anima Model Merge (Auto Remap) | Blending two Anima models |
| Anima LoRA Tag Loader Extended (Experimental) | Exploring neighboring-block projection for LoRAs |
| Anima Model Merge Extended (Experimental) | Exploring neighboring-block projection in model merges |
| Anima Random LoRA Loader (28/40/52 Auto) | Selecting LoRAs from up to three folder groups |
| Anima Filtered Random LoRA Loader (28/40/52 Auto) | Selecting LoRAs from one folder using keywords |
| Apply Anima ControlNet-LLLite (Auto Remap) | Applying lightweight image guidance with block correction |
| Anima VACE ControlNet Remap | Correcting VACE ControlNet injection positions |
Anima LoRA Tag Loader (Auto Remap)
This node reads LoRA tags from your prompt, applies the LoRAs, and returns a clean prompt with those tags removed.
Anima LoRA Tag Loader interface
Basic workflow
- Connect your Anima model to
model. - Connect
clipif you want the node to apply any supported text-encoder LoRA adjustments. - Write your prompt and LoRA tags in
text. - Leave
auto_remapON andmanifeston Auto. - Send the output
modelonward through your generation workflow. - Send the output
textto your downstream text encoder. - View
remap_infoto confirm what happened.
portrait, outdoors, soft lighting <lora:my_anima_style:0.8>
The output text becomes:
portrait, outdoors, soft lighting
The LoRA has already been applied to the model; the text encoder does not need to read its filename as prompt text.
Settings
| Input | What it does |
|---|---|
model | The Anima model receiving the LoRAs |
clip | Optional text-encoder connection |
text | Your prompt containing LoRA tags |
default_weight | Strength used when a tag omits its weight |
weight_multiplier | Scales every LoRA’s weight together |
auto_remap | Enables automatic block correction; default ON |
save_remapped | Writes a newly remapped LoRA to disk; default OFF |
extend_to_new_layers | Experimentally projects the LoRA effect onto inserted blocks; default OFF |
extend_strength | Scales that projected effect together with the tag’s weight |
manifest | Automatic or manually selected block mapping |
For example, a tag weight of 0.8 with weight_multiplier = 0.5 gives an effective model weight of 0.4.
You can specify model and CLIP weights separately:
<lora:my_anima_style:0.8:0.6>
If the CLIP weight is omitted, it defaults to the model weight. A CLIP connection and weight do not create text-encoder adjustments that are absent from the LoRA file.
Outputs
model: model with the LoRAs applied.clip: text encoder with applicable LoRA adjustments.text: prompt with LoRA tags removed.remap_info: one status line per LoRA, such as a cache hit,28->52, extension information, orapplied as-is.
Accepted LoRA names
The safest format is the filename without its extension:
<lora:mylora:0.8>
These forms are also accepted:
<lora:mylora.safetensors:0.8>
<lora:style/mylora:0.8>
<lora:style\mylora.safetensors:0.8>
<lora:STYLE/MyLora:0.8>
Matching ignores letter case. If different subfolders contain files with the same name, include the subfolder to choose the intended one. Otherwise, the first match is used and a warning lists the alternatives.
LoRA name autocomplete
The regular and Extended Tag Loaders can suggest LoRAs while you type directly into their text boxes.
LoRA autocomplete with preview and trigger words
- Type at least three characters from a filename.
- Browse suggestions with the mouse or
↑/↓. - Inspect available previews and trigger words.
- Press
Enter,Tab, or click a candidate to insert it. - Press
Escto close the list.
An insertion can look like:
<lora:my_style:1>, declared trigger words
You can edit the weight and surrounding text afterward.
Suggestions prioritize filename-prefix matches, then filename-substring matches, then subfolder-name matches. Cache files are excluded. Suggestions are not shown while editing inside an existing LoRA tag or typing a number.
Autocomplete is available only when typing in the node itself. When another node supplies the text input, there is no local text box to autocomplete.
Text supplied by an upstream node
Autocomplete trigger-word sources
The first source containing declared trigger words is used:
civitai.trainedWordsin<name>.metadata.json.trainedWordsin<name>.civitai.infoor<name>.info.modelspec.trigger_wordembedded in the LoRA.
Duplicates are removed. Autocomplete deliberately does not use training-tag frequencies or training output names as declared trigger words.
Autocomplete preview sources
Files next to the LoRA are checked in this order:
<name>.preview.png,.webp,.jpg, or.jpeg.<name>.png,.webp,.jpg, or.jpeg.<name>.preview.mp4,.preview.webm,.mp4, or.webm.
Still images take priority. Videos play muted in a loop and must use a format your browser can decode.
Saving and reusing remapped LoRAs
save_remapped controls writing a remapped file, not whether remapping is enabled.
When a LoRA needs remapping, the node checks for a matching saved conversion. If one exists, it is loaded directly—even when save_remapped is OFF. Otherwise, the original LoRA is remapped in memory, and saved only if the toggle is ON.
A cache filename looks like:
my_style_animaremap52_a7f6b0.safetensors
It records the target block count and a short settings hash.
| Setting | Included in the cache identity? |
|---|---|
| Target block count | Yes |
| Resolved manifest filename | Yes |
extend_to_new_layers | Yes |
extend_strength | Only when extension is ON |
blend_ratio in the Extended loader | Only when extension is ON |
Auto and manual selection of the same resolved manifest share the same cache identity. Extension sliders do not generate different caches when extension is OFF.
Recommended workflow:
- Keep
save_remappedOFF while experimenting. - Settle on your mapping and extension settings.
- Turn it ON for one run if you want a reusable conversion.
- Periodically remove unwanted
_animaremap*files.
Important cautions:
- Files are saved beside the original LoRA and are not automatically deleted.
- Different settings can create many files, each often roughly the original LoRA’s size.
- Extending an fp8 LoRA can produce a larger cache because the projected adjustments are calculated and stored in float32.
- Replacing a source LoRA under the same filename does not invalidate its cache. Delete the corresponding cache files after replacing or retraining that LoRA.
- The documented hash tracks the resolved manifest filename, not the contents of an edited mapping file.
- Legacy un-hashed files such as
_animaremap52and_animaremap52_extare no longer loaded. They generate a warning and can be removed.
Anima Model Merge (Auto Remap)
This node blends two Anima models while correcting differences in their block layouts.
| Input | Meaning |
|---|---|
model_1 | First model, in the top slot |
model_2 | Second model, in the bottom slot |
merge_ratio | Contribution of model_1, from 0.0 to 1.0 |
extend_ratio | Experimental contribution from the smaller model to inserted blocks; default 0.0 |
manifest | Automatic or forced mapping |
For corresponding shared blocks:
merge_ratio = 1.0: usemodel_1.merge_ratio = 0.0: usemodel_2.merge_ratio = 0.5: blend them equally.
When block counts differ, the output always retains the larger architecture. By default, its inserted blocks keep the larger model’s own values, regardless of merge_ratio.
For example, merging a 28-block model with a 52-block model produces a 52-block model. Even at a ratio favoring the smaller model entirely, this does not become a 28-block checkpoint.
Extending the merge into new blocks
With extend_ratio = 0.0, inserted blocks are unchanged. Raising it blends in an approximation from the smaller model:
new block =
larger model’s own value × (1 − extend_ratio)
+ smaller model’s corresponding source value × extend_ratio
At 1.0, the inserted block uses the approximated smaller-model value entirely. There is no universally correct setting; compare results visually.
If no manifest covers a differing block-count pair, the merge node warns and falls back to a direct, unremapped merge. Do not assume that this fallback is compatible.
Saving and bypassing a merge
The node outputs a MODEL and does not save files automatically.
To save it:
[Anima Model Merge] → MODEL → [ModelSave]
ComfyUI’s built-in ModelSave, under advanced/model_merging, saves the diffusion-model portion only—not CLIP or VAE. Its default destination is ComfyUI/output.
Bypass mode passes through model_1, the top input.
Extended LoRA and Model Merge nodes
The Extended variants add control over how effects are estimated for inserted blocks. They are separate experimental nodes; you do not need them for ordinary remapping.
Their extra setting, blend_ratio, combines the preceding and following corresponding older blocks:
estimated value =
preceding block × blend_ratio
+ following block × (1 − blend_ratio)
blend_ratio | Result |
|---|---|
1.0 | Preceding block only; numerically matches the regular node |
0.5 | Equal contribution from both neighbors |
0.0 | Following block only |
Where only one neighbor is available, that neighbor is used at full strength.
- In the Extended LoRA loader, enable
extend_to_new_layersfor this projection to matter. - In Extended Model Merge,
extend_ratiocontrols how much projected material replaces the larger model’s value;blend_ratiocontrols how that projected material is constructed.
Extended LoRA caches use a separate name, such as:
my_style_animaremap52_ext_a7f6b0.safetensors
They do not collide with regular-loader caches.
Random LoRA loaders
These nodes select Anima LoRAs from folders and automatically remap each selected file.
Three-folder Anima Random LoRA Loader
Anima Filtered Random LoRA Loader
Three-folder loader
Use Anima Random LoRA Loader (28/40/52 Auto) when your collection is organized into categories.
For example:
| Group | Folder contents | Count | Model strength |
|---|---|---|---|
| 1 | Style LoRAs | 1 | 0.4-0.8 |
| 2 | Character LoRAs | 1 | 1.0 |
| 3 | Concept LoRAs | 0 | Unused |
Each group provides:
lora_folder_path_1..3: folder to search.include_subfolders_1..3: whether to search inside subfolders.unique_by_filename_1..3: whether to exclude duplicate filenames within that group’s search.model_strength_1..3andclip_strength_1..3: fixed strengths or ranges.num_loras_1..3: number of selections.
Filtered loader
Use Anima Filtered Random LoRA Loader (28/40/52 Auto) for a mixed collection in one folder.
| Setting | Meaning |
|---|---|
keyword_filter | Space-separated keywords or quoted phrases |
filter_mode = AND | Every keyword must match |
filter_mode = OR | At least one keyword must match |
filter_mode = OFF | Ignore filtering without deleting the entered keywords |
search_in_metadata | Also search metadata; default OFF |
num_loras | Number to select, from 0 to 20 |
Example:
keyword_filter: "anime style" red
filter_mode: AND
This requires both the phrase anime style and red to match. Matching ignores case.
Metadata search can be much slower on the first scan because file headers must be read. Results are cached per node instance afterward.
Shared controls
Both random loaders include:
- Positive and negative additional prompt text.
- A selection
seed. trigger_word_sourceoptions:json_combined: combine available trigger-word patterns.json_random: select a trigger-word pattern.json_sample_prompt: select a sample prompt.metadata: read embedded metadata.
- Shared remap settings:
auto_remap,manifest,extend_to_new_layers,blend_ratio, andextend_strength.
These remap controls apply across the node, but Auto still selects the mapping separately for each LoRA.
Strength fields accept values such as:
1.0 fixed
0.4-0.8 random range
-0.8--0.3 negative random range
Ranges use 0.1 increments; fixed values are rounded to two decimal places.
Unlike autocomplete’s declared-trigger-word lookup, the random loaders inherit broader metadata and sample-prompt handling from RandomLoRALoader.
Outputs and correct connections
Both loaders provide:
| Output | Use |
|---|---|
MODEL | Model with selected LoRAs applied |
CLIP | Text encoder with applicable adjustments |
positive_text | Clean positive prompt, without LoRA tags |
negative_text | Negative prompt text |
positive | Encoded positive conditioning |
negative | Encoded negative conditioning |
preview | Preview images for selected LoRAs |
lora_text | Prompt containing selected LoRA tags and strengths, for recording |
The filtered loader also provides keyword, containing matched filter terms joined with underscores.
For example, aaa bbb in OR mode might output aaa if only that term matched. If both matched across the selected LoRAs, the output is aaa_bbb. It is empty when filtering is OFF, the filter is empty, no match exists, or the selection count is zero.
Use positive and negative for ready-made sampler conditioning, or positive_text and negative_text if you want to encode the text separately. Use lora_text for records and metadata—not as clean text-encoder input.
Folder and compatibility behavior
- Supported scanned extensions:
.safetensors,.pt, and.ckpt. - Symbolic-link subfolders are followed; link loops are skipped.
- Current and legacy
_animaremap*cache files are excluded from selection. - Remapping happens in memory each run; these nodes do not save remapped files.
- These are Anima-only loaders.
- SD1.5/SDXL-style LoRA Block Weight presets are not supported.
Apply Anima ControlNet-LLLite (Auto Remap)
LLLite is a lightweight form of image guidance. It adds small corrections that help the generated image follow a conditioning image, such as lineart or depth.
This node incorporates the required implementation from ComfyUI-Anima-LLLite, with block remapping added. The upstream package is not required for this node.
Apply Anima ControlNet-LLLite interface
| Input | Meaning |
|---|---|
model | Target Anima model |
lllite_name | LLLite weights from models/controlnet |
image | Conditioning image appropriate to the weights |
strength | Overall control strength; default 1.0, range −10 to 10 |
start_percent / end_percent | Active portion of sampling, from 0.0 to 1.0 |
auto_remap | Correct block positions; default ON |
manifest | Automatic or forced mapping |
extend_to_new_layers | Copy control modules into inserted blocks; default OFF |
extend_strength | Scale the copied modules’ effect; default 0.5, range 0–2 |
preserve_wrapper | Preserve compatible earlier model wrappers; default ON |
mask | Required for 4-channel inpainting weights |
Outputs are the patched model and a remap_info report.
How its remapping differs
- Smaller → larger model: trained modules move to their corresponding blocks.
- Extension enabled: inserted blocks receive a copy of the mapped predecessor’s module.
- Larger → smaller model: modules for inserted blocks are dropped.
- No matching manifest: the node stops rather than applying an unsafe mapping.
LLLite extension copies whole modules instead of averaging neighboring module weights. Its low-rank factors do not produce a meaningful correction when averaged that way. extend_strength scales the copied module’s final layer.
Inpainting masks
For 4-channel inpainting weights:
- White: repaint this region.
- Black: keep this region.
A missing mask causes an error. A mask connected to ordinary 3-channel weights is ignored with a warning.
Stacking and scheduling
You can chain nodes:
[Anima model] → [LLLite A] → [LLLite B] → [KSampler]
Keep preserve_wrapper ON so later nodes do not replace earlier compatible wrappers.
A useful starting experiment is:
| Node | Strength | Start | End |
|---|---|---|---|
| A | 1.5–2.0 | 0.0 | 0.4 |
| B | 0.5–0.8 | 0.4 | 1.0 |
Choose an individual strength within each suggested range. The first stage establishes composition; the second keeps lighter guidance through the remaining steps.
High control strength through the final steps can damage fine detail. Ending control too early can let the image drift away from the guide.
Anima VACE ControlNet Remap
VACE-type ControlNets use a separate control network and add its guidance at selected positions in the Anima model. This node moves those connection points to the corresponding positions in expanded models.
Anima VACE ControlNet Remap workflow
For the currently documented 28-block VACE models:
| Target Anima model | Correct injection blocks |
|---|---|
| 28 blocks | 0, 7, 14, 21 |
| 40 blocks | 0, 10, 20, 31 |
| 52 blocks | 0, 13, 26, 41 |
Without correction, a loader may continue using 0, 7, 14, 21 on larger models without reporting an error.
Required companion functionality
This workflow requires PineCookie’s fix/anima-vace-hardening branch of ComfyUI-Advanced-ControlNet.
The fork recognizes these VACE models and fixes a problem where an interrupted generation could leave control attached and cause later images to become noisy. The remap extension itself can load without this companion package; it is needed when using the VACE workflow.
Wiring
[Load Advanced ControlNet Model]
│ CONTROL_NET
▼
[Anima VACE ControlNet Remap] ──→ [Apply Advanced ControlNet]
▲
│ MODEL
[Anima model loader]
Use Load Advanced ControlNet Model, identified by its 🛂🅐🅒🅝 suffix—not the built-in ControlNet loader or ControlNet++ Loader. Connect the remap node to the same Anima model used by your sampler.
Inputs are control_net, model, auto_remap, and manifest. Outputs are the corrected control_net and remap_info.
Only the injection positions change. The control network’s weights and computation remain untouched, and the loader’s cached ControlNet is not modified.
A ControlNet trained for more blocks than the target model is unsupported and stops the node.
ComfyUI-Anima-Remap Models
The extension does not supply a new image-generation model. It adapts compatible Anima-family assets.
Anima model generations
| Model family | Blocks | When it matters |
|---|---|---|
| Original Anima / Anima-Base | 28 | Original layout; source generation for many older LoRAs and ControlNets |
| Anima-2.9B | 40 | Requires remapping when receiving 28-block assets |
| Anima-3.8B | 52 | Can receive mapped 28- or 40-block assets using the supplied mappings |
Choose your generation based on the checkpoint and workflow you want to use. The extension addresses block compatibility; it does not establish a universal quality or speed ranking between generations.
Anima-3.8B and text encoders
Anima-3.8B includes an optional Qwen3.5 4B cross-attention path. Depending on the release, its connector may be separate or bundled into the diffusion checkpoint.
Important distinctions:
- Block remapping and text-encoder behavior are separate issues.
- The connector keys are not part of the remapped main-block structure.
- The author confirmed generation with Qwen3.5 disconnected, using the native Qwen3 0.6B path.
- A LoRA or prompt can behave differently with Qwen3.5 even when block mapping is correct, because prompt interpretation differs.
- The adapter’s cross-attention connection is not inherently exclusive to 52-block models; the documented architecture provides that slot across the Anima generations.
ControlNet models
| Type or model | Use |
|---|---|
| Anima LLLite v2 | Lightweight guidance; choose weights trained for your desired task |
| Anima LLLite v2, 4-channel | Inpainting guidance requiring a mask |
| TaihoC/Anima-ControlNet-VACE-Depth | Depth-based guidance |
| khanghy1000/Anima-ControlNet-VACE-Canny | Edge-based guidance using Canny images |
Match the conditioning image to the model’s task. A depth model expects depth guidance; a Canny model expects edge guidance.
LLLite is comparatively lightweight and may provide a weaker constraint than a conventional VACE-type ControlNet, particularly when the prompt or a LoRA contradicts the guide.
What’s New with ComfyUI-Anima-Remap
The supplied documentation identifies specific version numbers for some random-loader changes, but does not provide a complete versioned release history for the extension. The following summarizes the documented changes without assigning unsupported dates or versions.
Successor to ComfyUI-Anima29B-Remap
- Expanded from 28/40-block handling to 28/40/52-block workflows.
- Added automatic manifest selection for supported generation pairs.
- Preserved node IDs for existing workflows.
- Added separate LLLite and VACE remapping nodes.
- Added clearer per-LoRA reporting through
remap_info.
LoRA loading and browsing improvements
- LoRA tags now accept extensions, subfolders, Windows separators, and case-insensitive names.
- Ambiguous names produce warnings listing alternatives.
- Missing-file warnings distinguish name problems from an empty or unavailable LoRA collection.
- Tag loaders provide autocomplete with previews and declared trigger words.
- Mixed-generation LoRAs resolve their mappings independently.
- LoRAs referencing more blocks than the target model stop the run instead of being applied partially.
Cache improvements
- Cache names now include the target generation and a settings hash.
- Changing relevant remap settings selects a different cache rather than silently reusing an incompatible one.
- Old un-hashed caches are ignored with a warning.
- Regular and Extended caches remain separate.
Random-loader improvements
- Symbolic-link subfolders are included.
- Remapped cache files are excluded from random selection.
v1.4.0: cleaner prompt outputs
positive_textno longer includes LoRA tags.lora_textsupplies the tag-containing version for recording selected LoRAs.- Existing text-encoder connections can remain on
positive_text. - Connections used to save LoRA syntax should move to
lora_text. - Images can differ at the same seed because the encoded prompt no longer contains tag text.
v1.5.0: easier filter management
- Added
OFFmode so you can temporarily disable filtering without deleting keywords. - Added the filtered loader’s final
keywordoutput, allowing matched terms to be recorded. - Existing output connections remain in place because the new output was appended.
Anima-3.8B v1.1+ clarification
The model’s “Semantic Connector v2” changed how its Qwen3.5 component may be packaged. This is a model-side change, not an extension version. Bundled connector keys remain outside block remapping.
Troubleshooting ComfyUI-Anima-Remap
Images become scribbles or a merge produces noise
- Confirm that the assets belong to the Anima family.
- Enable
auto_remapwhere available. - Set
manifestto Auto (Recommended). - Read
remap_infoor the console for detected block counts. - Turn experimental extension settings OFF, or set merge
extend_ratioto0.0. - Test one LoRA at a time.
- If merging reports that no manifest exists, do not rely on the unremapped fallback.
- If the source LoRA was replaced under the same filename, delete its saved remap caches.
If block alignment is correct but the style still differs, compare the text-encoder path as well.
“LoRA not found”
- Try the bare filename without an extension:
<lora:my_style:0.8> - Check spelling.
- If duplicate names exist, include the subfolder:
<lora:styles/my_style:0.8> - Read the warning:
- Visible LoRA files usually indicate a name-matching problem.
- Zero visible files indicates a folder or path configuration problem.
The node says the LoRA has more blocks than the model
This is a deliberate safety stop.
- Check which generation the LoRA was trained for.
- Use a compatible target with the same or a larger supported layout.
- Alternatively, select a LoRA trained for your current model generation.
The LoRA loaders do not support downward remapping. VACE follows the same restriction. LLLite is different: it can drop inserted-block modules when mapping downward.
Autocomplete is missing or outdated
- Type at least three filename characters.
- Make sure you are typing directly in the Tag Loader’s text box.
- Do not test from inside an existing
<lora:...>tag. - After adding a LoRA, wait for the 30-second candidate cache to refresh, then click back into the field.
- After an extension update, restart ComfyUI and hard-refresh the browser with
Ctrl+F5.
Autocomplete has no preview or trigger words
- Check that sidecar files share the LoRA’s base filename.
- For trigger words, check the declared fields listed in the autocomplete section.
- For previews, use one of the documented adjacent image filenames.
- If video fails, try a still-image preview; browser codec support varies.
Missing metadata does not prevent the LoRA itself from loading.
Changes to the LoRA file seem to have no effect
- Check whether
remap_inforeports a cache hit. - Delete the corresponding
_animaremap*files. - Run again to remap the current source file.
Turning save_remapped OFF does not disable reading an existing matching cache.
The LoRA folder is filling with converted files
- Turn
save_remappedOFF while tuning settings. - Remove unwanted
_animaremap*cache files. - Keep only conversions you intend to reuse.
- Remove legacy un-hashed caches, which are no longer loaded.
These generated cache files are separate from your original LoRA; check filenames carefully before deleting anything.
The random loader finds no candidates
- Verify the folder path.
- Check for
.safetensors,.pt, or.ckptfiles. - Enable
include_subfolderswhen needed. - Set the selection count above zero.
- Temporarily set filtered mode to
OFF. - If that works, simplify the filter or switch from
ANDtoOR. - Check console warnings for file-access problems.
LoRA tags appear in the encoded prompt
- For Tag Loaders, use the cleaned
textoutput downstream. - For random loaders, use
positive_textor the ready-madepositiveconditioning. - Reserve
lora_textfor saved prompts, metadata, or inspection.
LLLite gives a depth_embed slices missing error
- Check that you selected Apply Anima ControlNet-LLLite (Auto Remap).
- Enable automatic remapping.
- Use Auto manifest selection.
- Confirm that the weights use the supported Anima LLLite v2 format.
The remap node addresses the missing-depth-embedding issue caused by applying 28-block weights to expanded models. Legacy pre-v2 LLLite weights are not supported by the underlying implementation.
LLLite guidance is weak or damages detail
- Remove prompt terms or LoRAs that contradict the conditioning image.
- Increase
strengthgradually. - Try lowering CFG if prompt guidance is overpowering the control.
- If late detail deteriorates, reduce late-stage control strength.
- Consider two stacked nodes with strong early and lighter late guidance.
- Keep
preserve_wrapperON when stacking. - Consider VACE if a stronger constraint is needed.
Inpainting reports a missing mask
- Confirm whether the selected LLLite weights are 4-channel inpainting weights.
- Connect a mask.
- Use white for the repaint area and black for the preserved area.
A mask attached to 3-channel weights does not turn those weights into an inpainting model.
VACE is not recognized, or later images become noisy after cancellation
- Confirm that the documented PineCookie fork and branch are active.
- Use Load Advanced ControlNet Model.
- Place the remap node between loading and applying the ControlNet.
- Connect the same Anima model used by the sampler.
- Check that a manager repair or reinstall has not replaced the fork with upstream.
The required fork includes interruption cleanup; changing injection positions alone does not provide that fix.
VACE fails at a particular image size
- Use width and height divisible by 16.
- Try dimensions such as
832,1024,1216, or1536. - Verify that the documented fork is active.
The fork supports additional sizes, but multiples of 16 remain the safer choice.
Frequently asked questions
Can I use a 28-block and a 40-block LoRA together on Anima-3.8B?
Yes. Leave the manifest on Auto so each LoRA receives its own mapping.
Does remapping train the LoRA for the newer model?
No. It corrects block addresses. Experimental extension estimates effects for new blocks without retraining.
Should I enable new-layer extension?
Start with it OFF. Enable it when you want to compare its effect, not because it is required for basic compatibility.
Will the same LoRA look identical across generations?
Not necessarily. Correct alignment prevents one kind of mismatch, but model weights, text encoders, prompts, and other settings still affect the result.
What if a LoRA only affects early blocks?
Detection uses the highest block referenced by the file, not an authoritative generation label. A later-generation LoRA that touches only early or middle blocks can be misidentified. There is no dedicated force-generation control. Manually selecting a manifest is not the same as supplying a reliable generation label.
Can every LoRA naming format be detected?
No. Detection supports dot-separated net.blocks.N. and kohya-style underscore-separated block keys. Unrecognized formats may be applied without remapping.
Does this overwrite my source LoRA?
Saved conversions use separate cache filenames. Model merges are not saved unless you explicitly use a saving node.
ComfyUI-Anima-Remap Licensing and Usage Notes
The extension’s code license and the model-weight licenses are separate.
Extension code
- Most repository code uses the MIT License.
- Bundled LLLite code and its adapted apply node use Apache License 2.0; see the bundled license.
- ComfyUI-Advanced-ControlNet uses GPL-3.0. This extension does not bundle that package’s code.
Models, remapped LoRAs, and merged files
The supplied documentation states that Anima, Anima-2.9B, and Anima-3.8B follow the CircleStone Labs Non-Commercial License, and that remapped LoRAs and merged model files inherit the applicable derivative restrictions.
Important distinctions include:
- Model weights and derivatives are subject to non-commercial restrictions.
- Generated images are excluded from the license’s definition of derivatives and may be used commercially under the described terms.
- Section 2.c contains a specific exception concerning an individual selling model weights themselves; this does not authorize a commercial product or service built around the model.
- Applicable NVIDIA terms also matter because Anima derives from Cosmos-Predict2-2B-Text2Image.
- ControlNet weights have their own distribution-page license terms.
Always check the current license on each model’s distribution page before using or sharing weights. This summary is not legal advice.
Learn More about ComfyUI-Anima-Remap
Extension documentation
- ComfyUI-Anima-Remap repository — current documentation, source, and project updates.
- Repository issues — check existing reports for similar behavior.
- Previous ComfyUI-Anima29B-Remap repository — useful for migration context, but no longer maintained.
Model information
- Anima-2.9B model page — generation-specific information and the official expansion mapping source.
- Anima-3.8B model page — releases, text-encoder notes, and model license information.
- VACE Depth model — depth-guidance model details.
- VACE Canny model — edge-guidance model details.
Related workflow resources
- RandomLoRALoader — detailed explanations of shared random-selection, metadata, strength, and preview behavior. Its own architecture restrictions and LBW features do not describe the Anima-specific ports.
- ComfyUI-Anima-LLLite — LLLite v2 format, masks, and lightweight control concepts.
- Required Advanced-ControlNet VACE fork — the companion implementation required by the documented VACE workflow.
- ComfyUI-Advanced-ControlNet — background on scheduling, masks, and advanced control features.
- ControlNet preprocessors — tools for preparing conditioning images such as depth maps and edge maps.
Support expectations
The author provides the extension as-is, without guaranteed individual technical support, fixes, new features, or future ComfyUI compatibility. Community discussion is welcome, but a response is not guaranteed.
Before reporting a problem, review the troubleshooting steps and inspect remap_info and the console. These reports help distinguish a block-mapping problem from a missing file, unsupported asset, cache issue, or text-encoder difference.
