All posts
ComfyUIVideo GenerationArtificial Intelligence

How to Speed Up MiniMax H3 in ComfyUI by Up to 45% with Spectrum

Install the Spectrum node to cut MiniMax H3 sampler time in ComfyUI by up to 45%. Correct node placement, LoRA order, sampler settings, and what not to combine.

By PixelAiLabs · 8/16/2026

How to Speed Up MiniMax H3 in ComfyUI by Up to 45% with Spectrum

MiniMax H3 is one of the most talked-about local video models in ComfyUI right now. It produces video with native stereo audio in one pass and runs on a single consumer GPU. The catch is generation time. A 20-step run easily takes several minutes, which makes iterating on a prompt or a LoRA slow.

A custom node called ComfyUI-Spectrum-MiniMax-H3 changes that. Spectrum forecasts part of the denoising process instead of running the full H3 transformer on every step. In testing shared by the maintainer, the v0.1.8 degree-1 settings cut sampler time by roughly 45% while keeping quality close to native MiniMax H3.

License note: MiniMax H3 is released under the MiniMax H3 Community License Agreement, not a standard open-source license. The weights are public, but commercial use is restricted and the license excludes several regions by default. A separate application form is required for the United States, the EU, the UK, and South Korea. The Spectrum node itself is licensed GPL-3.0-or-later. Review both licenses before using either in commercial or production work.

This post covers the setup that currently makes the most sense, especially on a high-end local machine such as an RTX 5090 with 64 GB of RAM. At the end I include the sources and links so you can test it yourself. The workflow JSON, performance screenshots, and example videos referenced in the original draft were not supplied with this article, so those placeholders are listed under "Missing files" in the upload checklist rather than fabricated here.

Table of contents

What Spectrum does for MiniMax H3

Spectrum is a training-free acceleration node for ComfyUI. Instead of running the full H3 transformer stack on every sampling step, it alternates between actual steps and forecast steps.

On an actual step, native MiniMax H3 runs and captures the packed hidden state after the final transformer block. On a forecast step, Spectrum predicts that hidden state from the previous actual anchors using a Chebyshev ridge model, skips the H3 transformer blocks, and runs the remaining output path (FinalLayer, video and audio reconstruction, sigma handling, and the sampler update).

With the degree-1 defaults, a 20-step Euler run typically becomes:

A F A F A F A F A F A F A F A F A F A A

That is 11 actual transformer evaluations and 9 forecasted evaluations. The speedup comes from skipping the transformer, which is the expensive part, on almost half the steps.

Useful links:

The reported performance result

The headline numbers come from the maintainer's benchmark post on Reddit and the matching v0.1.8 release notes. The test configuration was:

  • GPU: RTX PRO 6000
  • Model: MiniMax H3 pruned BF16
  • Mode: image-to-video
  • Resolution: 992 x 768
  • Duration: 7 seconds
  • FPS: 24
  • Steps: 20
  • Sampler: Euler
  • Scheduler: Beta
  • Spectrum history storage: VRAM

The reported results were:

Native MiniMax H3

  • Sampler time: 324.98 seconds
  • Full prompt time: 340.59 seconds

MiniMax H3 + Spectrum v0.1.8

  • Sampler time: 177.80 seconds
  • Full prompt time: 200.32 seconds

Reported improvement

  • 45.29% lower sampler time
  • 1.83x sampler throughput
  • 41.19% lower full-prompt time

These are the maintainer's reported figures for one specific configuration. Treat them as a best-case reference, not a guarantee. The same Reddit thread reports smaller gains of about 34% for Euler and 30% for RES under other settings, and independent tests around the community range from roughly 15% to 40% depending on GPU, resolution, duration, model version, and memory settings. Using history_storage = vram also added roughly 3.2 GB of extra memory usage in that benchmark.

Spectrum is not a small tweak. It makes MiniMax H3 noticeably more practical for local workflows, but your exact speedup will vary.

If you are running an RTX 5090 with 64 GB of RAM, start with a safe, stable configuration first and push for more speed once everything works.

Use the current degree-1 defaults from the Spectrum node:

enabled = true
blend_weight = 0.50
degree = 1
ridge_lambda = 0.10
window_size = 2.0
flex_window = 0.75
warmup_steps = 1
tail_actual_steps = 1
max_history = 8
history_storage = system_ram
bootstrap_first_forecast = true
debug = false

Why system_ram first

The benchmark with the biggest speedup used history_storage = vram. That is faster, but it also consumes more VRAM. On the RTX 5090 the safest first step is history_storage = system_ram.

With 64 GB of system RAM this gives you a stable starting point while leaving VRAM headroom for MiniMax H3 itself. Once you confirm the workflow is stable, test history_storage = vram. If the run still fits comfortably in VRAM, that is likely the fastest configuration for you.

How to install Spectrum

Install through ComfyUI Manager or manually with Git.

Option 1: ComfyUI Manager

Search for:

ComfyUI-Spectrum-MiniMax-H3

Install it, then restart ComfyUI.

Option 2: install manually

cd ComfyUI/custom_nodes
git clone https://github.com/xmarre/ComfyUI-Spectrum-MiniMax-H3.git

Then restart ComfyUI.

If you already installed it, update it with:

cd ComfyUI/custom_nodes/ComfyUI-Spectrum-MiniMax-H3
git pull --ff-only

The node adds no third-party Python dependency. It uses PyTorch and the ComfyUI modules that are already present in a normal installation.

Where to place the Spectrum node

Node placement is the most common source of confusion. Spectrum accepts and returns a MODEL object, and it needs to sit after the Sigma Shift and before the guider and sampler.

The recommended model chain is:

MiniMax H3 model loader
-> LoRA / model patches
-> MiniMax H3 Sigma Shift
-> Spectrum Apply MiniMax H3
-> guider / sampler

Correct order

UNET / MiniMax H3 Loader
    |
Load LoRA (Model Only)        [if you use LoRAs]
    |
MiniMax H3 Sigma Shift
    |
SageAttention / model patch   [optional]
    |
Spectrum Apply MiniMax H3
    |
Basic Guider
    |
Sampler

If a LoRA seems to do nothing, it is almost always connected in the wrong place.

LoRA placement

Load a MiniMax H3 LoRA before Spectrum, not after it. Use Load LoRA (Model Only) (also called LoraLoaderModelOnly) and connect it like this:

MiniMax H3 Loader
    |
Load LoRA (Model Only)
    |
MiniMax H3 Sigma Shift
    |
Spectrum Apply MiniMax H3

Best sampler settings

To match the tested configuration as closely as possible, start with:

  • Sampler: Euler
  • Scheduler: Beta
  • Steps: 20

These match the settings used in the maintainer's benchmark. Spectrum is allowlisted for a specific set of sampler contracts, including Euler, native ER-SDE, MiniMax H3 Turbo, RES multistep, and RES multistep CFG++. Unsupported samplers fail closed to native execution, so nothing breaks if you pick one, but you also get no speedup.

Spectrum and SageAttention

Yes, you can use them together. Spectrum does not replace ComfyUI's attention implementation. On actual steps, native MiniMax H3 runs with whatever attention backend ComfyUI has selected, so a SageAttention patch already in your workflow keeps working. On forecast steps the H3 transformer blocks are skipped, so no attention call happens for those steps.

A practical setup looks like this:

MiniMax H3
+ LoRA (optional)
+ Sigma Shift
+ SageAttention
+ Spectrum
+ guider / sampler

What not to combine with Spectrum

Do not combine Spectrum on the same model branch with:

  • EasyCache
  • LazyCache

These caches can return an approximate result without entering the native H3 wrapper, which prevents Spectrum from observing the actual features it depends on. If both are attached to the same model path, Spectrum detects the active cache and stays inactive for that run.

The simple rule:

  • Spectrum + SageAttention = yes
  • Spectrum + EasyCache = no
  • Spectrum + LazyCache = no

Does it affect quality

Spectrum is an approximate accelerator, not a lossless one. Even with the same seed, prompt, workflow, and settings, the output may not be bit-identical to native MiniMax H3. Forecast steps change the denoising trajectory, so motion, timing, pose, anatomy, facial behavior, audio, and synchronization can all differ.

In practice the degree-1 settings are more stable than expected, and the maintainer noted that MiniMax H3 responded better to these aggressive forecast settings than originally assumed. Still, treat it as an iteration tool first:

  • Use Spectrum for faster iteration.
  • Compare it against native H3 on the same seed.
  • For quality-critical final shots, decide whether the speed gain is worth the approximation.

The most honest comparison runs the same prompt, seed, checkpoint, resolution, duration, sampler, and LoRA setup with Spectrum enabled and disabled.

The simple 5090 setup

The shortest version for an RTX 5090 with 64 GB of RAM:

Node order

MiniMax H3 Loader
-> Load LoRA (Model Only)
-> MiniMax H3 Sigma Shift
-> SageAttention
-> Spectrum Apply MiniMax H3
-> Basic Guider
-> Sampler

Spectrum settings

blend_weight = 0.50
degree = 1
ridge_lambda = 0.10
window_size = 2.0
flex_window = 0.75
warmup_steps = 1
tail_actual_steps = 1
max_history = 8
history_storage = system_ram
bootstrap_first_forecast = true

Sampling settings

Sampler = Euler
Scheduler = Beta
Steps = 20

After that

Once everything works, test history_storage = vram to see whether you can squeeze out more performance without running into VRAM limits.

Spectrum has moved past v0.1.8

The node has kept changing since v0.1.8. The current README default adds settings that the original draft did not mention:

audio_blend_weight = 0.00
offline_archive_storage = system_ram
offline_smoothing_replay = true
model_aware_mode = off

The important one is offline_smoothing_replay = true, a default two-pass path introduced after v0.2.0. It separates a compute-heavy capture pass from a transformer-free replay pass, which the maintainer added to fix audio degradation in the earlier single-pass design. The result is still approximate, but it keeps audio_blend_weight = 0 and applies the accepted video smoothing during replay.

Workflows saved with v0.2.0 may retain offline_smoothing_replay = false. If you want the current default path, enable it once. If audio sounds worse with Spectrum, start from offline_smoothing_replay = true, audio_blend_weight = 0.00, and model_aware_mode = off, then compare the same seed with Spectrum disabled.

The core advice in this article still applies: install the node, place it after Sigma Shift, keep the LoRA before Spectrum, start with system_ram, and test Euler + Beta + 20 steps. The node just ships more controls now than the v0.1.8 benchmark used.

Resources

The main links referenced in this post:

The original draft also referenced a Spectrum workflow JSON download, performance screenshots, and example videos. None of those files were supplied with this assignment, so they are not included here and should not be invented. See the upload checklist for what is still needed.

FAQ

Will Spectrum always speed up MiniMax H3?

No. The speedup depends on the sampler, resolution, duration, and how much of the run is spent outside the forecasted transformer calls. Reference-heavy workflows can spend a lot of time in preprocessing, which shrinks the end-to-end gain.

Why does my LoRA seem to do nothing after adding Spectrum?

It is almost always connected after Spectrum. Load the LoRA before Spectrum, directly after the H3 loader.

Can I use Spectrum with ancestral samplers or multi-GPU parallel sampling?

No. Unsupported samplers and multi-GPU parallel sampling fall back to native H3 execution, so you get no speedup but no breakage either.

Why is there no live preview during sampling?

With the default replay path, ordinary preview callbacks run only during the fast replay pass. Live preview during capture is currently supported only through KJNodes' Model Preview Override with Kijai's MiniMax H3 TAE.

Spectrum reports zero forecast steps. What happened?

Enable debug = true and check the log. Spectrum logs the exact reason it fell back, whether it was a sampler, cache, wrapper, topology, or safety fallback.

Conclusion

MiniMax H3 is powerful, but its generation time makes experimentation slow. Spectrum is one of the more useful current optimizations for local MiniMax H3 workflows. It is simple to add, easy to A/B test, and can deliver a real speedup for creators who iterate a lot.

If you run something like an RTX 5090 with 64 GB of RAM, the practical path is:

  1. Install Spectrum.
  2. Place it after Sigma Shift.
  3. Put your LoRA before Spectrum.
  4. Start with history_storage = system_ram.
  5. Test Euler + Beta + 20 steps.
  6. Compare against native H3 using the same seed.

That gives you a clean baseline without overcomplicating the workflow. Remember that the 45% figure is a reported benchmark, not a promise, and that MiniMax H3 and Spectrum each carry licenses you should read before commercial use.

Workflow files & resources

Download the files used in this article and try the workflow yourself.

ComfyUI_Workflow.zip

Continue learning

Explore more PixelAiLabs workflows and courses.

Browse courses