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 > MiniMax H3 Power LoRA Stack

ComfyUI Extension: MiniMax H3 Power LoRA Stack

Repo Name

ComfyUI-H3-PowerLoraStack

Author
cicalooo (Account age: 1069 days)
Nodes
View all nodes(1)
Latest Updated
2026-10-11
Github Stars
0.02K

How to Install MiniMax H3 Power LoRA Stack

Install this extension via the ComfyUI Manager by searching for MiniMax H3 Power LoRA Stack
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter MiniMax H3 Power LoRA Stack 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

MiniMax H3 Power LoRA Stack Description

MiniMax H3 Power LoRA Stack loads and controls multiple LoRAs in ComfyUI, offering per-LoRA strengths, scheduling, modality control, AdaLN conversion, quantized-layer support, and diagnostics.

ComfyUI-H3-PowerLoraStack Introduction

ComfyUI-H3-PowerLoraStack is a set of ComfyUI nodes for loading and controlling multiple LoRAs with MiniMax H3 models.

It is designed for AI artists who want to combine several LoRAs, adjust their influence, and understand what is happening inside the workflow without creating a separate loader node for every LoRA. The extension also addresses several MiniMax H3-specific problems that can otherwise cause LoRAs to be skipped, produce incorrect results, or crash during loading.

MiniMax H3 Power LoRA Stack

The extension can help you:

  • Load any number of LoRAs from a single stack node.
  • Enable or disable individual LoRAs quickly.
  • Set a separate strength for each LoRA.
  • Automatically bring unusually strong LoRAs closer to a common scale.
  • Adjust LoRA influence independently for video, text, and audio.
  • Change LoRA strength during the denoising process.
  • Use LoRAs trained for different MiniMax H3 AdaLN formats when the required conversion information is available.
  • Preserve small LoRA effects on quantized H3 models.
  • Handle Acc and PDD output-head banks without the shape errors produced by the native loading path.
  • Inspect a LoRA's format, rank, and AdaLN basis before applying it.
  • View a detailed report showing which layers were merged, which use runtime branches, and whether any keys were unmatched.

The stack row interface is based on the Power Lora Loader from rgthree-comfy.

How ComfyUI-H3-PowerLoraStack Works

Combining Several LoRAs

A LoRA is a relatively small set of changes that modifies how a model behaves. For example, one LoRA might add a visual style, another might affect motion, and another might improve a subject or character.

Instead of applying each LoRA through a separate loader, this extension collects them in one stack. Each row represents one LoRA and includes controls such as:

  • Whether the LoRA is active.
  • Its strength.
  • Its position in the stack.
  • Optional scheduling or modality settings.

Conceptually, each LoRA contributes a small change to the model. The extension combines those changes into a shared low-rank representation. A stack of ten LoRAs does not require ten completely separate copies of the model. The LoRA factors are collected into a bank, which keeps the additional computation manageable and allows ComfyUI to account for the memory they use.

Merging and Runtime Branches

For ordinary, unquantized model layers, the extension can merge a LoRA into the model in the usual way.

Quantized layers are handled differently. Quantization stores model weights in a compressed form, such as 4-bit or 8-bit values. A very small LoRA update can be lost when the compressed weights are:

  1. Decompressed.
  2. Modified with the LoRA.
  3. Rounded and compressed again.

This is similar to repeatedly saving a small, detailed image as a highly compressed file: the small details can disappear.

For quantized layers, the extension can instead leave the original quantized weight untouched and apply the LoRA as a separate runtime branch:

original quantized result + LoRA adjustment

This preserves small LoRA effects while continuing to use the quantized model kernel.

AdaLN Compatibility

MiniMax H3 models can use different forms of AdaLN conditioning. AdaLN is an internal part of the model that helps it respond to time, text, video, and audio information.

A LoRA trained with one AdaLN representation may not fit directly into a checkpoint using another representation. Without conversion, ComfyUI may report a shape error and skip the affected LoRA layers.

When possible, this extension converts the LoRA between the dense and curve forms while preserving its rank and contribution. The conversion also restores the constant part of the change as a bias delta, so the LoRA does not silently lose an important part of its effect.

The extension can also rebase curve-trained LoRAs between compatible curve tables when the LoRA includes the necessary adaln_t_table information.

Strength During Denoising

Image and video generation happens over multiple denoising steps. The extension can change a LoRA's strength during those steps instead of keeping it fixed from beginning to end.

For example, you could:

  • Use a strong style LoRA early, then reduce it later.
  • Increase a motion LoRA toward the end of denoising.
  • Use a short step range to introduce a temporary effect.
  • Define a smooth transition instead of an abrupt change.

Schedules can follow either model-call step numbers or the scheduler's normalized sigma values.

ComfyUI-H3-PowerLoraStack Features

MiniMax H3 Power LoRA Stack

This is the main node for loading multiple LoRAs.

Each stack row can be enabled or disabled and given its own strength. You can add as many rows as needed for your workflow. Rows can contain different types of LoRA data, provided the format is supported by the selected loading mode.

This is useful when you want to compare combinations such as:

  • A character LoRA with a style LoRA.
  • A motion LoRA with a visual-quality LoRA.
  • Several style LoRAs that need different strengths.
  • A base LoRA that stays active while other experimental LoRAs are switched on and off.

Empty rows still pass the incoming AdaLN processing. This means the node can also be placed after another loader when you need the AdaLN handling or reporting features without adding another LoRA.

Individual Strength Controls

Each LoRA has its own strength value. The strength is applied to the LoRA's contribution to the model.

A strength of 1.0 is not a universal unit of visual influence. Different LoRAs can produce very different amounts of change at the same numeric strength. One LoRA at 1.0 may be subtle, while another may strongly alter the output.

For this reason, compare LoRAs by their results rather than assuming that identical strength numbers mean identical visual intensity.

Auto-Balance Strengths

The Auto-balance strengths action measures the relative size of each active LoRA's weight changes and trims unusually strong outliers.

It does not boost quiet LoRAs. This is important for distillation or turbo LoRAs, which may intentionally produce a small weight-space change. Such LoRAs remain at their manually selected strength when the measurement indicates that they should not be adjusted.

Auto-balance:

  • Preserves the relative intent between your selected rows.
  • Only reduces strengths when a LoRA is unusually large compared with the reference collection.
  • Does not automatically weaken other LoRAs just because you added a new row.
  • Does not claim to measure perceived visual strength.

The measurement uses the relative Frobenius energy of the LoRA updates. In practical terms, it estimates how large the weight change is without creating the complete update tensor in memory.

The results are cached using the LoRA path, modification time, and file size. Use Restore manual strengths to return every row to its manually selected value. Editing a strength manually does not prevent you from restoring or recalculating values later.

Quantized Layer Handling

The quantized_layers setting controls how the extension treats quantized model layers.

Available modes are:

  • auto: Uses a runtime branch for quantized layers and merges unquantized layers. This is the default and is generally the most useful setting.
  • branch: Avoids modifying model weights wherever possible. Adapters that do not support the runtime branch are reported as rejected.
  • merge: Uses the conventional merge behavior. This is mainly useful for comparison or compatibility testing.

The runtime branch keeps a quantized layer's original result and adds the LoRA adjustment separately. The additional computation is small for typical low-rank adapters, while avoiding the loss caused by dequantizing and requantizing a small update.

One special case is mlp.fc2 under TensorWiseINT8Layout. Because this layer is reached through comfy.ops.linear_input_act rather than its normal forward method, it is merged even when branch mode is selected.

AdaLN Porting

The adaln_port setting controls how mismatched AdaLN pairs are handled:

  • auto: Automatically rebase compatible dense and curve AdaLN pairs when the required basis information is available.
  • strip: Drop mismatched AdaLN pairs instead of converting them.
  • off: Disable this extension's AdaLN conversion.

auto is the normal choice. Use off only when you intentionally want to keep AdaLN handling from another node or workflow component. When this extension is already handling the AdaLN conversion, a separate AdaLN-fix node on the same MODEL is not needed.

A curve-trained LoRA applied to a dense checkpoint can only be converted when the LoRA includes its own adaln_t_table. Without that information, the mismatched AdaLN pairs are dropped with a warning.

The extension looks for AdaLN basis information in the following order:

  • Basis data stored in the checkpoint.
  • A live time_embedder on a dense base.
  • h3_silu_temb_grid.safetensors.
  • Other H3 checkpoints found during a scored search.

The grid file may be found in locations such as:

models/h3_adaln/
models/loras/
models/diffusion_models/

It may also be found one level below the custom_nodes directory. Table-to-table conversion does not require a separate grid.

AdaLN Modality Control

Use the MiniMax H3 adaLN Modality node to control how strongly a stacked LoRA affects each modality:

  • Video
  • Text
  • Audio

The default value for each modality is 1.0. At that setting, the node does not change the LoRA. A value of 0.0 removes that modality's AdaLN contribution, while values between 0.0 and 1.0 reduce it.

For example:

  • Video 1.0, text 1.0, audio 0.0 keeps the LoRA's video and text influence while removing its audio modulation.
  • Video 0.5, text 1.0, audio 1.0 reduces the LoRA's video-related modulation without changing the other two.
  • Setting all three values to 1.0 is a no-op.

MiniMax H3 shares many blocks between audio and video. The modality-specific AdaLN ranges are read from the loaded AdalnProj, so the node does not rely on manually guessed row positions. The final one-modality AdaLN projection is left unchanged.

Modality scaling happens before AdaLN porting, so any generated bias delta follows the selected modality strength.

MiniMax H3 LoRA Schedule

Use the MiniMax H3 LoRA Schedule node to vary selected stack rows during denoising.

Rows can be selected using:

  • all
  • A comma-separated list such as 1,3
  • A range such as 2-4

The schedule can use:

  • Linear interpolation.
  • Cosine interpolation.
  • Smoothstep interpolation.
  • Power curves.
  • A step change.
  • An explicit curve.

start_percent and end_percent limit where the transition takes place.

Schedules can follow:

  • steps: ComfyUI model-call indices.
  • sigma: The scheduler's normalized noise values.

The stack reads sample_sigmas from ComfyUI, so a normal KSampler workflow does not need a separate SIGMAS connection.

You can chain schedule nodes. When selectors overlap, the later schedule takes precedence in the overlapping area.

Scheduled rows use the live branch path, including on unquantized bases. If a particular adapter cannot use a runtime branch, the report identifies that it was merged at its static strength instead.

Acc and PDD Output-Head Banks

Some Alibaba PAI Acc LoRAs include a bank of output heads rather than one ordinary output head. The bank contains 32 intervals, represented as a tensor with a shape equivalent to 32 heads of 96 rows each.

The native ComfyUI path may try to copy the entire bank into a single 96-row head, which causes a shape error. This extension recognizes the bank, removes it from the ordinary copy path, and blends the appropriate head across the sampler step.

The first row is treated as the full head. Later rows represent offsets from it. The LoRA row strength controls the interpolation between the native head and the blended bank. Schedules can further vary that strength during denoising.

For a bank trained on an eight-step schedule, the original documentation recommends using the simple blending mode with shifts of 12/3 so sampler steps align with the trained intervals.

If a later stack row also contains an output-head bank, it replaces the earlier bank.

Supported Key Conventions

The extension resolves LoRA keys against the loaded model's own state dictionary. It does not split names by guessing where underscores represent module boundaries. This is important for names such as qkv_proj, which must remain one module name.

The extension recognizes conventions including:

FormatExample
ai-toolkit / diffusersdiffusion_model.blocks.0.attn.qkv_proj.lora_A.weight
Bare keysblocks.0.attn.qkv_proj.lora_A.weight
kohya / musubilora_unet_blocks_0_attn_qkv_proj.lora_down.weight with .alpha
lycorislycoris_blocks_0_...
peft / diffusers trainerbase_model.model.blocks.0... or transformer.blocks.0...

Keys that do not match a model layer are reported separately for each stack row.

Report Output

Connect the stack's report output to a text-display node to inspect how each LoRA was processed. The report is also written to the log.

A report can include:

  • The base model type and quantization information.
  • Whether the base uses dense or curve AdaLN.
  • How many layers were merged.
  • How many layers use runtime branches.
  • Whether AdaLN pairs were ported.
  • The basis fit quality for a port.
  • Modality settings.
  • Relative weight-change estimates.
  • The size of the runtime branch bank.
  • Unmatched keys or rejected adapter types.

A typical report may look like this:

base: ConvRotW4A4 x300, INT8 x50
adaLN: curve (input dim 8)
turbo dense-adaLN @ 1: 26 merged, 275 branched, adaLN ported x51 (basis fit 1.7e-03)
  rel dW 0.047%
style_lora curve-adaLN @ 0.8: 0 merged, 258 branched, adaLN modality video/text/audio = 1/1/0.25 x50
  rel dW 0.054%
motion_lora @ 1: 0 merged, 104 branched, adaLN modality 1/1/0.25 INACTIVE (LoRA has no adaLN pairs)
  rel dW 0.316%
branch bank: 300 layers, 412 MB

The rel dW value describes the estimated relative weight change. It is not a direct prediction of how strong or visible the LoRA will look in the final image or video.

Troubleshooting ComfyUI-H3-PowerLoraStack

A LoRA Is Skipped with an AdaLN Shape Error

You may see an error similar to:

ERROR lora ... adaln_proj.linear.weight shape '[96768, 8]' is invalid for input of size ...

This usually means that the LoRA and checkpoint use different AdaLN forms.

Try these steps:

  1. Confirm that the loaded model is a MiniMax H3 checkpoint supported by the extension.
  2. Leave adaln_port set to auto.
  3. Check the report output to see whether the AdaLN pairs were ported or dropped.
  4. If the LoRA is curve-trained and the checkpoint is dense, confirm that the LoRA includes its own adaln_t_table.
  5. If the required table or basis is unavailable, use a LoRA trained for the same H3 checkpoint form.
  6. Use adaln_port=strip only when you intentionally prefer dropping mismatched pairs.
  7. Use adaln_port=off only when another AdaLN-fix node is intentionally handling the conversion.

A separate AdaLN-fix node should not normally be attached to the same MODEL when this extension is already performing the port.

A Small LoRA Has Almost No Visible Effect on a Quantized Model

This can happen when the LoRA is merged into a quantized weight and the update is lost during requantization.

Try these steps:

  1. Set quantized_layers to auto.
  2. Run the workflow again.
  3. Check the report to confirm that the relevant layers use runtime branches.
  4. If you need to test whether merging is the cause, compare auto with merge.
  5. Use branch for a stricter test, keeping in mind that adapters without a supported runtime branch may be rejected.

The merge mode is mainly useful for comparison. auto is normally the better choice for preserving small LoRA changes on quantized H3 bases.

The Workflow Crashes While Loading an Acc or PDD LoRA

If the LoRA contains an output-head bank, the native path may try to place a 32-interval bank into a single output head.

Try these steps:

  1. Load the LoRA through MiniMax H3 Power LoRA Stack.
  2. Check the report for the output-head bank handling.
  3. For an eight-step setup, use the simple head mode with shifts 12/3 as recommended by the extension documentation.
  4. Make sure another stack row is not unintentionally replacing the bank with a later one.
  5. If the problem continues, test the LoRA by itself before adding other rows.

Auto-Balance Makes a LoRA Weaker

Auto-balance only trims unusually large relative weight changes. It never boosts a quiet adapter.

To check what happened:

  1. Inspect the report for the LoRA's rel dW value.
  2. Compare the manually selected strength with the calibrated strength.
  3. Use Restore manual strengths to return to your original values.
  4. Increase the strength manually if the LoRA is intentionally subtle.
  5. Remember that weight-space magnitude is not the same as perceived visual intensity.

Turbo and distillation LoRAs may be intentionally quiet and can remain at ×1.00.

A Modality Control Does Nothing

The modality node can only affect LoRA data containing AdaLN pairs.

To troubleshoot:

  1. Check the report for the message that modality control is active or inactive.
  2. Confirm that the selected LoRA actually contains AdaLN keys.
  3. Verify that the modality values are not all 1.0 if you expected a change.
  4. Remember that the final layer's one-modality AdaLN projection is left unchanged.

Some LoRA Keys Are Unmatched

Unmatched keys may come from:

  • A LoRA trained for a different H3 model version.
  • A different naming convention.
  • A model architecture that does not contain the referenced layer.
  • A specialized adapter type that is not supported by the selected loading mode.

Check the per-row report to identify the unmatched keys. The extension resolves keys against the actual loaded model, so changing the model checkpoint may change which keys are valid.

Runtime Branches Do Not Apply

Runtime branches apply to MODEL objects produced by ComfyUI's native H3 loader.

They do not apply to the streaming loader in minimaxh3chinkloader, which uses its own model handle and LoRA path. If you are using that loader, the branch behavior described by this extension may not be available.

Also note:

  • Plain rank-decomposition LoRAs are supported by the runtime branch path.
  • DoRA, LoHa, LoKr, and locon are merged in auto.
  • These adapter types are rejected in branch mode.

Frequently Asked Questions

Does strength 1.0 mean that every LoRA is equally strong?

No. Strength is a multiplier for a particular LoRA, not a universal visual unit. Different LoRAs can have very different effects at the same value.

Can I use an empty stack row?

Yes. Empty rows still run the incoming AdaLN pass, so the node can be useful after another loader when you need AdaLN handling or a report.

Do I need a separate AdaLN-fix node?

Normally no. The stack includes AdaLN porting. Use another fix node only when you intentionally disable this extension's porting with adaln_port=off.

Does adding more LoRAs automatically weaken the existing ones?

No. Auto-balance does not apply a 1 / number of LoRAs reduction. Existing rows keep their selected strengths unless calibration trims an outlier.

Does auto-balance measure how attractive the final image will be?

No. It measures relative weight-space energy. It does not measure perceptual quality, style compatibility, or feature contention.

Can two curve LoRAs load without an error but still be incompatible?

Yes. Two curve bakes can have the same AdaLN width while using different underlying tables. If a LoRA includes its own adaln_t_table, the extension can rebase table-to-table. Without that information, use a LoRA trained against the checkpoint you are running.

Where can I see what the extension did?

Connect the report output to a show-text node. The same report is also logged by ComfyUI.

Learn More about ComfyUI-H3-PowerLoraStack

The following resources provide useful background and related workflow information:

For troubleshooting, include the stack report and the relevant model and LoRA details when asking for help. The report is especially useful because it shows whether a layer was merged, branched, ported, rejected, or left unmatched.

ComfyUI-H3-PowerLoraStack Limitations

The extension has several important limitations:

  • A curve-trained LoRA applied to a dense checkpoint can only be ported when the LoRA includes its own adaln_t_table. Otherwise, the mismatched AdaLN pairs are dropped with a warning.
  • Runtime branches work with MODEL objects from ComfyUI's native MiniMax H3 loader.
  • The minimaxh3chinkloader streaming loader uses a separate model and LoRA path.
  • DoRA, LoHa, LoKr, and locon use merge behavior in auto mode.
  • These adapter types are rejected in branch mode.
  • Frobenius energy is not the same as perceived LoRA strength.
  • Auto-balance does not measure whether two LoRAs compete for the same visual features.
  • A fit from the wrong AdaLN build can be rejected when its error is too large.

ComfyUI-H3-PowerLoraStack License

ComfyUI-H3-PowerLoraStack is licensed under the Apache License, Version 2.0.

MiniMax H3 Power LoRA Stack 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.

MiniMax H3 Power LoRA Stack detailed guide | ComfyUI