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-chunk-star7

ComfyUI Extension: minimax-h3-chunk-star7

Repo Name

minimax-h3-chunk-star7

Author
star7code (Account age: 250 days)
Nodes
View all nodes(1)
Latest Updated
2026-11-10
Github Stars
0.1K

How to Install minimax-h3-chunk-star7

Install this extension via the ComfyUI Manager by searching for minimax-h3-chunk-star7
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter minimax-h3-chunk-star7 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-chunk-star7 Description

minimax-h3-chunk-star7 enables long MiniMax H3 video generation in ComfyUI on limited VRAM using activation chunking and accelerated attention, preserving video resolution, duration, and frame count.

minimax-h3-chunk-star7 Introduction

minimax-h3-chunk-star7 is a ComfyUI extension that helps MiniMax H3 generate high-quality, long-duration videos when GPU memory is limited. It combines memory-saving processing with several attention acceleration options, plus tools for preparing references, previewing videos, upscaling, and repairing faces.

Its central feature is activation chunking: processing certain parts of the model in smaller pieces instead of creating all their temporary data at once. This can help a video generation task stay within your graphics card’s dedicated memory.

The core chunking node does not reduce your video’s resolution, duration, or frame count. It also does not change the sampler, sigma schedule, latent layout, or VAE.

What you can use it for

  • Reduce temporary GPU memory peaks during QKV projection, RoPE processing, and MLP processing.
  • Recover from some out-of-memory errors automatically by reducing only the chunk size associated with the failed operation.
  • Choose an attention backend to balance compatibility, speed, and visual quality.
  • Keep an existing attention patch, such as Sage, while adding activation chunking.
  • Work with supported H3 quantized models, including specific W4A8 mixed-precision models.
  • Prepare reference images, videos, audio, and prompts with fewer separate preparation steps.
  • Preview the full video timeline during sampling, rather than waiting for final decoding.
  • Add optional latent upscaling and local face repair before the final video is decoded.

Important: Lower memory use does not automatically mean faster generation. Chunking is most helpful when a task would otherwise run out of memory, spill into shared memory, or repeatedly move data between devices. Approximate attention modes can also change the generated image or audio.

This is an independent community project, not an official MiniMax or NVIDIA extension.

How minimax-h3-chunk-star7 Works

1. Activation chunking: working in smaller batches

Imagine editing a large collection of images on a desk. Spreading every image out at once requires a huge surface. Working through smaller stacks uses less space while still processing the entire collection.

Activation chunking follows a similar idea. During video generation, the model creates temporary data called activations. Long videos and large frames can make these temporary allocations very large.

The extension separately chunks three stages:

StagePlain-language explanationMain setting
QKV projectionPrepares the information used by attention to compare different parts of the sequence.qkv_chunk_tokens
RoPEAdds positional information so the model can distinguish where information belongs in the sequence.chunk_tokens
MLPProcesses and expands intermediate features inside each Transformer block.mlp_chunk_tokens

A token is a unit of information processed by the model. For H3, the sequence includes video and conditioning information; it is not simply a count of words in your prompt.

Chunking processes smaller groups of tokens and writes the results back in their original order. It preserves the model’s formulas, weights, and conditioning structure.

What it saves: temporary activation memory.

What it does not save: model weight memory, token count, or the total theoretical amount of computation.

RoPE chunking can be element-for-element identical. Splitting large matrix calculations into smaller ones can introduce tiny floating-point differences in MLP results, so identical final pixels are not guaranteed.

2. Attention acceleration: choosing how information is compared

Attention allows different parts of the video and its references to influence one another. It becomes expensive as the sequence grows.

The extension offers several approaches:

  • Existing attention: keep whatever implementation is already attached to the model.
  • Comfy Kitchen INT8, or CK: use an approximate, lower-precision attention path.
  • SLA: select relevant blocks of information and calculate attention mainly over those blocks.
  • Sol: calculate selected blocks precisely, while representing unselected blocks with compact summaries.
  • VSA: use an H3 sparse-attention path, with additional learned compensation when supported by a FastH3/VSA model.
  • Hybrid: use CK for protected sampling steps near the beginning and end, and a selected sparse mode in the middle.

A useful analogy is reading reference material:

  • Dense attention reads the full collection.
  • SLA reads selected sections.
  • Sol reads selected sections closely and uses summaries of the rest.

These approaches can reduce attention work, but they are not guaranteed to produce the same output as one another.

3. How SLA handles video and audio

SLA uses dynamic block selection, typically retaining approximately 15% of key blocks for target video queries. Internally, it uses query blocks of 128 and key blocks of 64.

Audio receives additional protection:

  • On SM75, target audio query blocks use full attention.
  • On SM80+, reference-audio and generated-audio query ranges are replaced with full-attention results.

For long-sequence SLA workflows, the author recommends the MiniMax H3 Turbo SLA LoRA.

4. How Sol differs from SLA

Sol uses 64-token query and key blocks with threshold routing.

  • Selected blocks contribute detailed attention results.
  • Unselected blocks contribute through representative K/V summaries, called centroids.
  • Both contributions are combined into the attention result.

The standard SM80+ BF16 route uses NVIDIA’s official Sol implementation. Star7 All-INT8 routes follow the same exact-plus-summary concept but use different quantization and kernels, so their results are not numerically identical to the official BF16 route.

SM80+ Sol also protects reference and generated audio through full-attention replacements and an audio KV sink.

5. How Hybrid sampling works

Hybrid switches attention modes between complete sampling steps. It does not mix two attention kernels inside a single attention operation.

For a typical four-step workflow:

Sampling stepAttention
1CK
2Selected sparse mode
3Selected sparse mode
4CK

Hybrid needs the real sigma schedule from ComfyUI to identify sampling steps reliably. If that context is unavailable, the task stops with an error rather than guessing.

minimax-h3-chunk-star7 Features

Core chunking controls

These are the documented starting values for the activation chunking node:

SettingWhat it controlsSuggested starting point
chunk_tokensRoPE chunk size.8192
mlp_chunk_tokensMLP temporary activation size; often the most useful memory control.8192; try 4096 first if memory is tight.
qkv_chunk_tokensQKV projection chunk size.8192
auto_halve_on_oomHalves only the failed, recoverable chunk stage and retries.true
Attention output memory protectionSeparately protects high-risk attention output projection, or out_proj.Off by default.
reuse_mlp_weightsReuses prepared QKV/MLP weight snapshots when safe; uses a streamed path under memory pressure.true
attention_backendChooses the attention implementation.comfy_kitchen_int8
verbosePrints compact configuration and diagnostic summaries.true

Practical example

If your task fails in the MLP stage, you can reduce:

mlp_chunk_tokens: 8192 → 4096 → 2048 → 1024

You do not need to reduce RoPE and QKV chunk sizes at the same time.

Smaller chunks generally reduce temporary memory demand, but may add overhead. The author’s isolated MLP test measured approximately 1,970 MiB at 8192 tokens and 672 MiB at 1024 tokens. These figures describe one test, not total workflow memory requirements.

Automatic recovery and displayed values

Automatic halving stops at a minimum chunk size of 256. It applies only to recoverable QKV, RoPE, and MLP chunk failures.

The node distinguishes between:

  • Running at your configured value.
  • Using a smaller value because the sequence itself is shorter.
  • Using a reduced value after an out-of-memory retry.

Recovered values are reused for subsequent blocks and the same model session, but are not saved back into your workflow. Changing parameters and executing the node again resets the remembered reductions.

For qkv_chunk_tokens, 0 means “try the full sequence first.” With automatic recovery enabled, it is reduced only after an actual QKV projection memory failure.

Attention output protection is separate: it handles out_proj, not QKV, RoPE, or MLP. When disabled, it does not install an out_proj wrapper.

Attention backend choices

SM75 generally refers here to RTX 20-series GPUs. SM80+ refers to the supported RTX 30–50-series and newer architecture paths described by the project.

The menu shows options for multiple architectures so workflows can be shared across machines. It does not hide incompatible choices automatically.

General options

attention_backendPurpose
existingPreserve upstream attention, including an existing Sage or other compatible patch.
comfy_kitchen_int8General-purpose CK INT8 attention; the default starting choice.

SM75 options

attention_backendMain characteristics
sla_sm75_qk_int8_pv_fp16SLA with INT8 QK and FP16 PV; the recommended first SLA quality check on SM75.
sla_sm75_all_int8SLA with INT8 QK and PV; performance-oriented, with full audio-query protection.
sol_sm75_all_int8Sol with selected-block attention plus centroid summaries and INT8 PV.
vsa_sm75SM75 VSA path with 10% retention across the full sampling range.
hybrid_sm75_ck_sla_all_int8CK at the beginning/end, SLA All-INT8 in the middle.
hybrid_sm75_ck_sol_all_int8CK at the beginning/end, Sol All-INT8 in the middle.
hybrid_sm75_ck_vsaCK at the beginning/end, SM75 VSA in the middle.

SM80+ options

attention_backendMain characteristics
sla_sm80+_qk_int8_pv_bf16Standard SM80+ SLA: INT8 QK, BF16 PV, and full audio-query protection.
sla_sm80+_all_int8All-INT8 SLA for performance/quality comparison.
sol_sm80+_bf16_officialStandard SM80+ Sol using NVIDIA’s official BF16 route, with audio protection.
sol_sm80+_all_int8Star7 All-INT8 Sol with selected-block and centroid contributions, plus audio protection.
vsa_sm80+SM80+ VSA path with 10% retention across the full sampling range.
hybrid_sm80+_ck_sla_qk_int8_pv_bf16CK/SLA/CK using the standard BF16-PV SLA path.
hybrid_sm80+_ck_sol_bf16_officialCK/Sol/CK using official BF16 Sol.
hybrid_sm80+_ck_sla_all_int8CK/SLA/CK using All-INT8 SLA.
hybrid_sm80+_ck_sol_all_int8CK/Sol/CK using All-INT8 Sol.
hybrid_sm80+_ck_vsaCK/VSA/CK using the SM80+ VSA path.

Choosing a starting point

  1. Already using a working attention patch? Select existing.
  2. Want a general baseline? Start with comfy_kitchen_int8.
  3. Testing SLA on SM75? Begin with sla_sm75_qk_int8_pv_fp16.
  4. Testing standalone Sol on SM80+? Begin with sol_sm80+_bf16_official.
  5. Want protected first/last steps? Compare a matching Hybrid mode.
  6. Considering All-INT8? Compare quality and speed against the standard route before adopting it.

Existing BF16 Hybrid values in older workflows remain BF16; they are not silently changed to All-INT8.

For a fair comparison, keep the model, seed, prompt, frame count, resolution, sampling steps, and offloading strategy unchanged.

Enhanced H3 model loading

The MiniMax H3 Enhanced Loader – Star7 handles model precision and supported quantized layouts.

  • RTX 20-series: uses protected FP16 computation with FP32 residual operations and overflow protection.
  • SM80+: explicitly uses native BF16, overriding a launcher’s global --fp16-unet setting.
  • Preserves supported INT8, ConvRot, and W4A8 model dispatch.
  • Includes FP16 Exact protection; a separate FP16 repair extension is not required.

The chunking node also accepts H3 models with existing FP16 Exact protection. Unprotected ordinary FP16 models are blocked before sampling.

Optional VEDA sparse attention

The VEDA node uses a predictor to guide sparse attention. It can work with ordinary H3 sampling and the Star7 CK chunking chain.

Recommended order:

LoRA / Sigma Shift
    → VEDA
    → Star7 Activation Chunk, using CK
    → Optional Live Preview
    → Guider
  • SM75 uses Star7 native sparse kernels.
  • SM80+ uses the upstream Triton path.
  • Chunking still handles QKV, RoPE, and MLP.
  • CK handles non-sparse attention calls.
  • When disabled, VEDA passes the model through without loading its predictor or installing patches.

Do not stack VEDA with SLA, Sol, VSA, or another sparse attention backend.

VDN acceleration

The MiniMax H3 VDN Acceleration – Star7 node loads a complete VDN stage and its matching adapter.

  • Supports 8-step DMD and 50-step original modes.
  • Connects between the H3 loader and Star7 chunking.
  • The chunking node automatically preserves VDN attention.
  • The author recommends the INT8 ConvRot stage.
  • Use an H3 base model without Turbo or other LoRAs already merged into it; VDN supplies its own adapter.

Spark/VPack acceleration

Version 2.19.0 adds a separate Spark/VPack acceleration node with its own enable switch. It reuses the original chunking-node settings and passes inputs through when disabled.

The author’s tested configuration was faster than CK alone, but did not exceed CK plus VEDA. Spark uses approximate computation, may alter images, and is not guaranteed to accelerate every configuration.

See the Spark/VPack acceleration guide for the documented details and platform limits.

Reference image, reference video, and prompt helpers

The three standalone loaders support dragging compatible files directly onto their nodes. They do not inject attention or precision patches into your model.

Reference image loader

You can:

  • Load an image by dragging it onto the node.
  • Limit image size.
  • Optionally enlarge a small image.
  • Crop to common landscape or portrait ratios while preserving as much content as possible.

The size limit uses these rules:

ValueBehavior
0Keep the original size.
Greater than 0, up to 10Treat as megapixels; only reduce oversized images.
Greater than 10Treat as a longest-edge pixel limit.

If aspect-ratio adjustment is enabled, cropping happens before resizing.

Reference video loader

You can load a video, trim it to a time range, and limit its longest edge. The output frames and audio come from the same selected time window.

Prompt loader

The prompt loader can extract long text from images, videos, or workflow JSON files and retain candidate prompts for selection.

The prompt asset library added in 2.19.0 supports:

  • Saving and editing prompts.
  • Creating duplicates.
  • Deleting and applying saved prompts.
  • Dragging in multiple TXT files.
  • Automatic short timestamp names, with numbering for duplicate names.

All-in-one conditioning

The MiniMax H3 All-in-One Conditioning Loader – Star7 organizes:

  • Prompts.
  • First and last frames.
  • Reference images.
  • Reference videos.
  • Audio.

It also outputs sampling context for the upscaling and face-repair nodes.

Connected assets receive prompt labels such as:

<Picture N>
<Video N>
<Audio N>

Driving audio always uses <Audio D>.

Up to three independent reference-audio inputs are supported. Inputs 1 and 2 appear initially; connecting input 2 reveals input 3.

Live video preview

The live preview node shows a looping animation covering the generated video’s timeline after sampling steps.

Connect it on the model path before the Guider. The Scheduler can connect directly to the chunking node.

SettingAvailable valuesEffect
Preview frames per second1–24, default 5Controls how many frames are shown. A 10-second video at 5 preview fps displays about 50 frames.
Preview longest edge256, 384, 512, 768, 1024; default 512Resizes the decoded preview.
WebP quality1–100; default 80 for new nodesControls preview compression. Older workflows without a saved value retain 76.
First-step-only previewOff by defaultDecodes a preview only after the first step.

These settings do not change final video resolution.

Lower preview frame rates reduce final-stage preview decoding, transfer, and encoding work, but the decoder still maintains continuous temporal state. Preview size is reduced after RGB decoding.

If the preview model is missing, it downloads and verifies in the background without blocking sampling. Preview failures do not stop formal generation. Disabling preview avoids callbacks, model loading, downloads, and decoding.

One-click latent upscaling

The upscaling node enlarges an H3 sampling result to a target megapixel count and can run a short second sampling pass.

  • Presets cover balanced HD, high quality, distant small faces, and fast motion.
  • Custom mode allows manual step and strength adjustments.
  • LoRA and attention inherit from the first pass unless separately specified.
  • Original prompts and reference conditions are reused.
  • First/last frames are re-encoded for the target resolution.
  • Spatial tiling can reduce peak memory, but adds processing time.

A target no higher than the source resolution passes through unchanged. Disabling HD resampling avoids loading the HD model.

The node outputs an H3 sampling result, not decoded RGB frames. Connect it to Star7 tiled decoding.

One-click face repair

Face repair accepts an H3 sampling result and sampling context. It detects, tracks, and repairs faces locally.

  • Supports 1–4 people.
  • Target selection can prioritize the main subject, frame center, or a reference image.
  • Presets include automatic balance, realistic fidelity, distant small faces, anime characters, and custom settings.
  • LoRA and attention inherit from the first pass by default.
  • If disabled, or if no face is detected, the result passes through without additional sampling or VAE encoding.

Repair crops are composited into final RGB output by Star7 tiled decoding, avoiding another full-video VAE encode. Connect face repair directly to that decoder.

“Preserve repair sharpness” is enabled by default. It proportionally enlarges source videos below approximately 1.0 MP and does not shrink larger videos.

Reference-image matching can optionally use InsightFace; other selection modes do not require it.

Tiled H3 decoding

The dedicated decoder processes full H3 video/audio latents. Video decoding uses the current H3 VAE’s temporal streaming and spatial tiling paths.

It also handles final compositing for Star7 face repair.

DLSS Neural Quality Enhancement V2

This node processes a single image or a batch of video frames using a selected nvngx_dlssnr*.dll Neural Rendering model.

Available presets include:

  • Realistic.
  • Realistic portrait.
  • 3D anime.
  • 2D anime.
  • Custom.

The target megapixel setting preserves aspect ratio and does not downscale an image when the target is below its current size. Custom parameters are saved with the workflow.

This is not the complete game-rendering DLSS Super Resolution pipeline. Enlargement uses high-quality scaling together with Neural Rendering at the target size.

minimax-h3-chunk-star7 Models

This extension works with H3 models and supporting assets; it is not a collection of interchangeable general-purpose image models. Each model type has a specific role.

Supported H3 W4A8 models

The enhanced loader supports H3 mixed-precision models in ComfyUI’s asym_w4a8_int8 format, including:

ModelDocumented role
minimax_h3_ref2va_pruned_w4a8_mixed.safetensorsA supported H3 W4A8 mixed-precision main model; use with its corresponding H3 workflow.
minimax_h3_fl2va_pruned_w4a8_mixed.safetensorsAnother supported H3 W4A8 mixed-precision main model; use with its corresponding H3 workflow.

The text encoder, VAE, and sampling conditions remain those required by the corresponding H3 workflow.

W4A8 support requires an environment with the relevant ComfyUI and Comfy Kitchen layout support. It does not mean arbitrary INT4 or QuantFunc models are compatible.

SM75 native optimizations apply to supported codebook, ConvRot 256, and grouped-scale layouts. Unsupported layers keep the upstream quantized path.

W4A8 can be combined with VEDA plus CK chunking because they operate at different stages. Do not additionally stack SLA, Sol, or VSA. W4A8 is not guaranteed to outperform INT8; compare memory, time, and quality under identical conditions.

SLA LoRA

MiniMax H3 Turbo SLA LoRA is recommended by the author for SLA workflows, particularly for long-sequence behavior.

Changing a LoRA changes model behavior, so include it consistently when comparing attention modes.

Ordinary H3 and FastH3/VSA models

Both can use the documented VSA paths:

  • Ordinary H3: runs the fine sparse branch only and displays a one-time warning.
  • FastH3/VSA with compression gates: also uses learned coarse compensation, which is generally more favorable for preserving quality.

The FastH3 VSA adapter_model.safetensors is a model-merging asset, not a normal LoRA file.

For pruned/T8 H3, the extension supports native 8-dimensional LoRAs and converted 2688-dimensional full-model LoRAs loaded through the standard ComfyUI loader. Original, unconverted Turbo LoRAs still require their dedicated loader.

Supporting models and assets

AssetPurposeDocumented location or behavior
Complete VDN stageVDN acceleration and matching adapter.ComfyUI/models/vdn/<model-directory>
minimax_h3_t2va_veda_8nfe_600step_preview_fp8.safetensorsVEDA sparse-routing predictor.ComfyUI/models/veda/
taeh3.safetensorsLive preview decoder.ComfyUI/models/vae_approx/; downloads and verifies if missing.
taeh3_decoder.safetensorsCompatible alternative preview decoder filename.ComfyUI/models/vae_approx/
minimax_h3_latent_upscaler_3d_fp16.safetensorsH3 latent upscaling.Downloads and verifies into ComfyUI/models/latent_upscale_models/ if missing.
Face detectorDetects faces for local repair.Downloads and verifies into ComfyUI/models/ultralytics/bbox/ on first use.
nvngx_dlssnr.dll and available variantsDLSS Neural Rendering enhancement.ComfyUI/models/upscale_models/, including subfolders.

For DLSS, the default model can download automatically. Other manually selected variants must already exist in the model directory.

Using minimax-h3-chunk-star7 in a Workflow

Basic generation chain

H3 Loader
    → LoRA
    → Optional Attention Patch
    → Star7 Activation Chunk
    → Optional Star7 Live Preview
    → Guider
    → Sampler

Star7 Activation Chunk
    → Scheduler
    → Sampler

For RTX 20-series workflows, use the Star7 enhanced loader to obtain the documented protected FP16 path.

Keeping Sage or another upstream attention patch

Loader
    → LoRA
    → Sage Attention Patch
    → Star7 Activation Chunk

Set:

attention_backend = existing

Choosing CK, SLA, Sol, or Hybrid instead installs that selected attention route on the output model.

An upstream VSA patch can likewise be preserved with existing.

Optional upscaling and face repair

Sampler result
    → One-Click HD Upscale
    → One-Click Face Repair
    → Star7 H3 Tiled Decode
    → Video assembly

All-in-One Conditioning sampling context
    → HD Upscale and Face Repair

Video/audio VAE
    → Star7 H3 Tiled Decode

You can omit optional enhancement nodes you do not need.

Example workflows

The general workflow includes all-in-one conditioning, chunking, live preview, independent H3 decoding, and an optional second pass that is disabled by default. After importing it, select your available models and replace placeholder reference files.

What’s New with minimax-h3-chunk-star7

The supplied release notes describe the following versions.

Version 2.19.0

Separate Spark/VPack acceleration

  • Adds an independently enabled acceleration node.
  • Reuses existing chunking settings.
  • Passes inputs through when disabled.
  • Windows SM75 includes a dedicated Spark kernel.
  • Other architectures need a matching Spark backend.
  • Linux Spark has not completed GPU validation.

Why it matters: you can test another acceleration option without replacing your familiar chunking settings. Performance and visual quality still need checking on your own workflow.

Prompt asset library

  • Adds saved prompt management: save, edit, duplicate, delete, and apply.
  • Supports batch TXT drag-and-drop.
  • Automatically names new saves with short timestamps and numbers duplicate names.

Why it matters: reusable prompts are easier to organize and apply across projects.

First/last-frame aspect-ratio correction

  • Uses aspect-preserving center cropping instead of stretching.

Why it matters: reference frames no longer need to be distorted to fit the requested ratio.

Version 2.18.8

Additional enhanced-loader memory protection

  • Chunks per-token AdaLN modulation and residual gating into groups of 2,048 rows.
  • Releases completed attention tensors before entering the MLP.
  • Allows FP32 MLP inputs to be converted piece by piece into FP16 computation inputs while reusing storage.

Why it matters: QKV and MLP chunking alone did not cover every temporary allocation. This update protects additional operations that could still create large peaks, including in workflows already using spatial tiling.

It does not change tile count, overlap, resolution, frame count, or denoising strength. It is a general loader fix, not a patch exclusive to the separate director workflow.

The author reports Windows operator and actual-model MLP checks, but does not promise fixed speed improvements or complete elimination of memory errors.

Restart ComfyUI after updating.

minimax-h3-chunk-star7 Performance and Compatibility

Reported benchmark

The author tested these paths on an RTX 2080 Ti with 22 GB VRAM, using:

  • 1.0 MP video.
  • 10 seconds at 24 fps.
  • H3 INT8 Tensorwise + ConvRot.
  • 768p Turbo four-step LoRA.
  • Euler/simple sampling.
Attention routeAverage sampling time per stepComplete task time
KJNodes SM75 SageAttention 2190.50 s863.41 s
Comfy Kitchen INT8119.50 s620.32 s
SLA SM75 QK-INT8/PV-FP1696.68 s471.12 s
SLA SM75 All-INT860.83 s325.51 s
Sol SM75 All-INT888.71 s442.57 s
CK + Sol Hybrid106.12 s498.27 s
CK + SLA Hybrid94.67 s454.76 s

These are observations from one configuration, not performance guarantees. Hybrid averages use actual sampling-step times; complete task time also includes initialization, VAE work, and video assembly.

See BENCHMARKS.md for the full records.

Platform considerations

  • SM75 Windows x64: bundled native libraries use CUDA 13 and require a compatible NVIDIA 580+ driver.
  • SM75 Linux x86_64: existing SLA/Sol libraries use CUDA 12.6 and a glibc 2.31 baseline. New preprocessing, VEDA, and W4A8 test libraries use CUDA 13 and glibc 2.35.
  • Linux test support: new libraries passed loading and interface checks, but full Linux GPU numerical and video-workflow regression testing is not complete.
  • SM80+ SLA and All-INT8: use Triton; the first run compiles and caches kernels.
  • SM80+ official BF16 Sol: prefers the compiled Comfy Kitchen backend when available, otherwise uses the bundled official NVIDIA implementation. A separate Sana installation is not required.

Architecture-specific modes stop with a compatibility error if they do not match your GPU. They do not silently switch to another backend.

Troubleshooting minimax-h3-chunk-star7

Out of memory during MLP, RoPE, or QKV processing

  1. Read the error to identify the failed stage.
  2. Leave automatic halving enabled if you want recoverable retries.
  3. Reduce the corresponding setting if necessary:
Error locationSetting to reduce
fc1, SwiGLU, or fc2mlp_chunk_tokens: 8192 → 4096 → 2048 → 1024
rms_rope_split_half_ or RoPEchunk_tokens: 8192 → 4096 → 2048
QKV projectionqkv_chunk_tokens: 8192 → 4096 → 2048 → 1024
  1. Run again and check the displayed actual chunk sizes.

Avoid lowering every setting at once: targeted changes make it easier to identify what helps.

Out of memory in the attention kernel

Activation chunking cannot shrink the attention kernel’s core working set.

  1. Confirm that the error is inside attention rather than QKV, RoPE, or MLP.
  2. Try another compatible attention backend.
  3. If necessary, reduce sequence length or reference-token load.

For an error specifically in out_proj, consider the separate attention output memory protection option.

Out of memory while loading the model

The chunking node has not run yet.

  1. Review the model’s quantization format and memory requirements.
  2. Adjust loading or offloading strategy.
  3. Select a supported lower-memory model if needed.

Changing activation chunk sizes does not reduce model weight memory.

“Required architecture” or compute-capability error

  1. Check your GPU family.
  2. Select an SM75 or SM80+ backend appropriate to that GPU.
  3. Re-run the task.

The complete backend menu is intentionally visible on every machine to support shared workflows.

Hybrid cannot determine the sampling step

  1. Check that the workflow supplies the real sigma schedule.
  2. Compare your connections with the provided general workflow.
  3. Use a non-Hybrid backend if reliable schedule context is unavailable.

Hybrid stops rather than switching kernels at uncertain steps.

NaN/Inf errors or invalid latents

NaN and Inf are invalid numerical values. The extension stops them before they reach VAE decoding or media export; it does not replace them with zeros.

  1. Use the enhanced H3 loader or verify that your H3 model has FP16 Exact protection.
  2. On SM80+, check that the intended BF16 loading route is being used.
  3. Review launcher precision settings, especially --fp16-unet.
  4. Read the logged block and stage information.
  5. Re-run to obtain targeted diagnostics where the extension enables them.

The checks help locate an error; they are not themselves a precision repair.

Generation is slower after enabling chunking

  1. Determine whether the original workflow already fit comfortably in dedicated VRAM.
  2. If it did, test larger chunk sizes.
  3. Compare complete task time as well as sampling time.
  4. Keep model, seed, duration, resolution, and offloading unchanged.

Chunking reduces memory peaks, not theoretical computation. Sparse attention can also be slower than CK for some hardware and sequence sizes.

My output changes when switching attention modes

This is expected for approximate attention.

  1. Compare with the same seed and all other settings unchanged.
  2. Inspect motion, detail, prompt adherence, and speech/audio quality.
  3. Try the standard precision route before All-INT8.
  4. Consider Hybrid if you want CK at the beginning and end.

Even activation chunking alone can introduce small floating-point differences.

VEDA, VSA, or another sparse backend fails

  1. Check that the selected backend supports your architecture.
  2. For VEDA, verify the predictor asset is available.
  3. Do not combine VEDA with SLA, Sol, VSA, or another sparse attention patch.
  4. Read the reported compatibility or producer error before selecting another route.

Strict sparse routes do not silently fall back to dense attention.

Ordinary H3 can run VSA’s fine-only branch. Its warning about missing learned coarse compensation is not a rejection of the model.

Live preview is missing

  1. Confirm that the preview node is connected before the Guider.
  2. Enable preview display.
  3. Check for taeh3.safetensors or taeh3_decoder.safetensors in ComfyUI/models/vae_approx.
  4. Check whether a background download or verification is still in progress.

Preview download or decoding failure does not invalidate the formal generation.

Face repair does not appear in the final output

  1. Connect face repair directly to Star7 H3 Tiled Decode.
  2. Supply the sampling context.
  3. Confirm that repair is enabled and a face was detected.
  4. Review the selected target and preset.

No detected face means the node intentionally passes the original result through.

Frequently asked questions

Will chunking lower my resolution or shorten my video?
No. The core chunking node does not alter resolution, frame count, or duration. Optional enhancement nodes perform their own explicitly selected changes.

Can it fix every out-of-memory error?
No. Model loading, complete Q/K/V allocation, and attention-kernel memory requirements are separate from recoverable chunked activations.

Should I always choose All-INT8?
No. It is an explicit performance/quality trade-off. Compare it with the standard path on your actual prompts and hardware.

Can I keep Sage?
Yes. Put Sage before Star7 chunking and select attention_backend=existing.

Can W4A8 and VEDA work together?
Yes, with the documented VEDA + CK chunking chain and supported model/environment. Do not add another sparse backend.

Does a smaller preview change the final video?
No. Preview size, frame rate, and compression affect the preview only.

Does DLSS V2 provide the full DLSS Super Resolution pipeline?
No. It combines scaling with Neural Rendering, not the complete game-rendering pipeline.

Do I need a separate FP16 repair extension?
Not when using the documented Star7 enhanced loader, which includes FP16 Exact protection.

Learn More about minimax-h3-chunk-star7

Start with an artist-friendly workflow

Understand acceleration and performance

Licenses and third-party notices

minimax-h3-chunk-star7 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-chunk-star7 detailed guide | ComfyUI