Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-Anima-Remap

ComfyUI Extension: ComfyUI-Anima-Remap

Repo Name

ComfyUI-Anima-Remap

Author
shin131002 (Account age: 632 days)
Nodes
View all nodes(1)
Latest Updated
2026-11-10
Github Stars
0.03K

How to Install ComfyUI-Anima-Remap

Install this extension via the ComfyUI Manager by searching for ComfyUI-Anima-Remap
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-Anima-Remap in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

ComfyUI-Anima-Remap Description

ComfyUI-Anima-Remap automatically aligns blocks across 28-, 40-, and 52-block Anima models, enabling cross-generation LoRA reuse, model merging, and compatible LLLite and VACE ControlNet guidance.

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 filePurposeSource
expand_manifest_28_40.jsonOriginal Anima → Anima-2.9BOfficial expansion mapping
expand_manifest_40_52.jsonAnima-2.9B → Anima-3.8BReconstructed mapping
expand_manifest_28_52_composed.jsonOriginal Anima → Anima-3.8BAutomatically 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.

NodeBest 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 RemapCorrecting 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

  1. Connect your Anima model to model.
  2. Connect clip if you want the node to apply any supported text-encoder LoRA adjustments.
  3. Write your prompt and LoRA tags in text.
  4. Leave auto_remap ON and manifest on Auto.
  5. Send the output model onward through your generation workflow.
  6. Send the output text to your downstream text encoder.
  7. View remap_info to 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

InputWhat it does
modelThe Anima model receiving the LoRAs
clipOptional text-encoder connection
textYour prompt containing LoRA tags
default_weightStrength used when a tag omits its weight
weight_multiplierScales every LoRA’s weight together
auto_remapEnables automatic block correction; default ON
save_remappedWrites a newly remapped LoRA to disk; default OFF
extend_to_new_layersExperimentally projects the LoRA effect onto inserted blocks; default OFF
extend_strengthScales that projected effect together with the tag’s weight
manifestAutomatic 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, or applied 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

  1. Type at least three characters from a filename.
  2. Browse suggestions with the mouse or ↑ / ↓.
  3. Inspect available previews and trigger words.
  4. Press Enter, Tab, or click a candidate to insert it.
  5. Press Esc to 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:

  1. civitai.trainedWords in <name>.metadata.json.
  2. trainedWords in <name>.civitai.info or <name>.info.
  3. modelspec.trigger_word embedded 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:

  1. <name>.preview.png, .webp, .jpg, or .jpeg.
  2. <name>.png, .webp, .jpg, or .jpeg.
  3. <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.

SettingIncluded in the cache identity?
Target block countYes
Resolved manifest filenameYes
extend_to_new_layersYes
extend_strengthOnly when extension is ON
blend_ratio in the Extended loaderOnly 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:

  1. Keep save_remapped OFF while experimenting.
  2. Settle on your mapping and extension settings.
  3. Turn it ON for one run if you want a reusable conversion.
  4. 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 _animaremap52 and _animaremap52_ext are 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.

Anima Model Merge interface

InputMeaning
model_1First model, in the top slot
model_2Second model, in the bottom slot
merge_ratioContribution of model_1, from 0.0 to 1.0
extend_ratioExperimental contribution from the smaller model to inserted blocks; default 0.0
manifestAutomatic or forced mapping

For corresponding shared blocks:

  • merge_ratio = 1.0: use model_1.
  • merge_ratio = 0.0: use model_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.

Extended LoRA Tag Loader

Extended Model Merge

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_ratioResult
1.0Preceding block only; numerically matches the regular node
0.5Equal contribution from both neighbors
0.0Following block only

Where only one neighbor is available, that neighbor is used at full strength.

  • In the Extended LoRA loader, enable extend_to_new_layers for this projection to matter.
  • In Extended Model Merge, extend_ratio controls how much projected material replaces the larger model’s value; blend_ratio controls 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:

GroupFolder contentsCountModel strength
1Style LoRAs10.4-0.8
2Character LoRAs11.0
3Concept LoRAs0Unused

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..3 and clip_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.

SettingMeaning
keyword_filterSpace-separated keywords or quoted phrases
filter_mode = ANDEvery keyword must match
filter_mode = ORAt least one keyword must match
filter_mode = OFFIgnore filtering without deleting the entered keywords
search_in_metadataAlso search metadata; default OFF
num_lorasNumber 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_source options:
    • 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, and extend_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:

OutputUse
MODELModel with selected LoRAs applied
CLIPText encoder with applicable adjustments
positive_textClean positive prompt, without LoRA tags
negative_textNegative prompt text
positiveEncoded positive conditioning
negativeEncoded negative conditioning
previewPreview images for selected LoRAs
lora_textPrompt 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

InputMeaning
modelTarget Anima model
lllite_nameLLLite weights from models/controlnet
imageConditioning image appropriate to the weights
strengthOverall control strength; default 1.0, range −10 to 10
start_percent / end_percentActive portion of sampling, from 0.0 to 1.0
auto_remapCorrect block positions; default ON
manifestAutomatic or forced mapping
extend_to_new_layersCopy control modules into inserted blocks; default OFF
extend_strengthScale the copied modules’ effect; default 0.5, range 0–2
preserve_wrapperPreserve compatible earlier model wrappers; default ON
maskRequired 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:

NodeStrengthStartEnd
A1.5–2.00.00.4
B0.5–0.80.41.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 modelCorrect injection blocks
28 blocks0, 7, 14, 21
40 blocks0, 10, 20, 31
52 blocks0, 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 familyBlocksWhen it matters
Original Anima / Anima-Base28Original layout; source generation for many older LoRAs and ControlNets
Anima-2.9B40Requires remapping when receiving 28-block assets
Anima-3.8B52Can 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 modelUse
Anima LLLite v2Lightweight guidance; choose weights trained for your desired task
Anima LLLite v2, 4-channelInpainting guidance requiring a mask
TaihoC/Anima-ControlNet-VACE-DepthDepth-based guidance
khanghy1000/Anima-ControlNet-VACE-CannyEdge-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_text no longer includes LoRA tags.
  • lora_text supplies 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 OFF mode so you can temporarily disable filtering without deleting keywords.
  • Added the filtered loader’s final keyword output, 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

  1. Confirm that the assets belong to the Anima family.
  2. Enable auto_remap where available.
  3. Set manifest to Auto (Recommended).
  4. Read remap_info or the console for detected block counts.
  5. Turn experimental extension settings OFF, or set merge extend_ratio to 0.0.
  6. Test one LoRA at a time.
  7. If merging reports that no manifest exists, do not rely on the unremapped fallback.
  8. 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”

  1. Try the bare filename without an extension:
    <lora:my_style:0.8>
    
  2. Check spelling.
  3. If duplicate names exist, include the subfolder:
    <lora:styles/my_style:0.8>
    
  4. 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.

  1. Check which generation the LoRA was trained for.
  2. Use a compatible target with the same or a larger supported layout.
  3. 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

  1. Type at least three filename characters.
  2. Make sure you are typing directly in the Tag Loader’s text box.
  3. Do not test from inside an existing <lora:...> tag.
  4. After adding a LoRA, wait for the 30-second candidate cache to refresh, then click back into the field.
  5. After an extension update, restart ComfyUI and hard-refresh the browser with Ctrl+F5.

Autocomplete has no preview or trigger words

  1. Check that sidecar files share the LoRA’s base filename.
  2. For trigger words, check the declared fields listed in the autocomplete section.
  3. For previews, use one of the documented adjacent image filenames.
  4. 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

  1. Check whether remap_info reports a cache hit.
  2. Delete the corresponding _animaremap* files.
  3. 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

  1. Turn save_remapped OFF while tuning settings.
  2. Remove unwanted _animaremap* cache files.
  3. Keep only conversions you intend to reuse.
  4. 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

  1. Verify the folder path.
  2. Check for .safetensors, .pt, or .ckpt files.
  3. Enable include_subfolders when needed.
  4. Set the selection count above zero.
  5. Temporarily set filtered mode to OFF.
  6. If that works, simplify the filter or switch from AND to OR.
  7. Check console warnings for file-access problems.

LoRA tags appear in the encoded prompt

  1. For Tag Loaders, use the cleaned text output downstream.
  2. For random loaders, use positive_text or the ready-made positive conditioning.
  3. Reserve lora_text for saved prompts, metadata, or inspection.

LLLite gives a depth_embed slices missing error

  1. Check that you selected Apply Anima ControlNet-LLLite (Auto Remap).
  2. Enable automatic remapping.
  3. Use Auto manifest selection.
  4. 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

  1. Remove prompt terms or LoRAs that contradict the conditioning image.
  2. Increase strength gradually.
  3. Try lowering CFG if prompt guidance is overpowering the control.
  4. If late detail deteriorates, reduce late-stage control strength.
  5. Consider two stacked nodes with strong early and lighter late guidance.
  6. Keep preserve_wrapper ON when stacking.
  7. Consider VACE if a stronger constraint is needed.

Inpainting reports a missing mask

  1. Confirm whether the selected LLLite weights are 4-channel inpainting weights.
  2. Connect a mask.
  3. 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

  1. Confirm that the documented PineCookie fork and branch are active.
  2. Use Load Advanced ControlNet Model.
  3. Place the remap node between loading and applying the ControlNet.
  4. Connect the same Anima model used by the sampler.
  5. 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

  1. Use width and height divisible by 16.
  2. Try dimensions such as 832, 1024, 1216, or 1536.
  3. 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

Model information

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.

ComfyUI-Anima-Remap Related Nodes

RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

ComfyUI-Anima-Remap detailed guide | ComfyUI