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:
| Stage | Plain-language explanation | Main setting |
|---|---|---|
| QKV projection | Prepares the information used by attention to compare different parts of the sequence. | qkv_chunk_tokens |
| RoPE | Adds positional information so the model can distinguish where information belongs in the sequence. | chunk_tokens |
| MLP | Processes 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 step | Attention |
|---|---|
| 1 | CK |
| 2 | Selected sparse mode |
| 3 | Selected sparse mode |
| 4 | CK |
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:
| Setting | What it controls | Suggested starting point |
|---|---|---|
chunk_tokens | RoPE chunk size. | 8192 |
mlp_chunk_tokens | MLP temporary activation size; often the most useful memory control. | 8192; try 4096 first if memory is tight. |
qkv_chunk_tokens | QKV projection chunk size. | 8192 |
auto_halve_on_oom | Halves only the failed, recoverable chunk stage and retries. | true |
| Attention output memory protection | Separately protects high-risk attention output projection, or out_proj. | Off by default. |
reuse_mlp_weights | Reuses prepared QKV/MLP weight snapshots when safe; uses a streamed path under memory pressure. | true |
attention_backend | Chooses the attention implementation. | comfy_kitchen_int8 |
verbose | Prints 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_backend | Purpose |
|---|---|
existing | Preserve upstream attention, including an existing Sage or other compatible patch. |
comfy_kitchen_int8 | General-purpose CK INT8 attention; the default starting choice. |
SM75 options
attention_backend | Main characteristics |
|---|---|
sla_sm75_qk_int8_pv_fp16 | SLA with INT8 QK and FP16 PV; the recommended first SLA quality check on SM75. |
sla_sm75_all_int8 | SLA with INT8 QK and PV; performance-oriented, with full audio-query protection. |
sol_sm75_all_int8 | Sol with selected-block attention plus centroid summaries and INT8 PV. |
vsa_sm75 | SM75 VSA path with 10% retention across the full sampling range. |
hybrid_sm75_ck_sla_all_int8 | CK at the beginning/end, SLA All-INT8 in the middle. |
hybrid_sm75_ck_sol_all_int8 | CK at the beginning/end, Sol All-INT8 in the middle. |
hybrid_sm75_ck_vsa | CK at the beginning/end, SM75 VSA in the middle. |
SM80+ options
attention_backend | Main characteristics |
|---|---|
sla_sm80+_qk_int8_pv_bf16 | Standard SM80+ SLA: INT8 QK, BF16 PV, and full audio-query protection. |
sla_sm80+_all_int8 | All-INT8 SLA for performance/quality comparison. |
sol_sm80+_bf16_official | Standard SM80+ Sol using NVIDIA’s official BF16 route, with audio protection. |
sol_sm80+_all_int8 | Star7 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_bf16 | CK/SLA/CK using the standard BF16-PV SLA path. |
hybrid_sm80+_ck_sol_bf16_official | CK/Sol/CK using official BF16 Sol. |
hybrid_sm80+_ck_sla_all_int8 | CK/SLA/CK using All-INT8 SLA. |
hybrid_sm80+_ck_sol_all_int8 | CK/Sol/CK using All-INT8 Sol. |
hybrid_sm80+_ck_vsa | CK/VSA/CK using the SM80+ VSA path. |
Choosing a starting point
- Already using a working attention patch? Select
existing. - Want a general baseline? Start with
comfy_kitchen_int8. - Testing SLA on SM75? Begin with
sla_sm75_qk_int8_pv_fp16. - Testing standalone Sol on SM80+? Begin with
sol_sm80+_bf16_official. - Want protected first/last steps? Compare a matching Hybrid mode.
- 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-unetsetting. - 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:
| Value | Behavior |
|---|---|
0 | Keep the original size. |
Greater than 0, up to 10 | Treat as megapixels; only reduce oversized images. |
Greater than 10 | Treat 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.
| Setting | Available values | Effect |
|---|---|---|
| Preview frames per second | 1–24, default 5 | Controls how many frames are shown. A 10-second video at 5 preview fps displays about 50 frames. |
| Preview longest edge | 256, 384, 512, 768, 1024; default 512 | Resizes the decoded preview. |
| WebP quality | 1–100; default 80 for new nodes | Controls preview compression. Older workflows without a saved value retain 76. |
| First-step-only preview | Off by default | Decodes 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:
| Model | Documented role |
|---|---|
minimax_h3_ref2va_pruned_w4a8_mixed.safetensors | A supported H3 W4A8 mixed-precision main model; use with its corresponding H3 workflow. |
minimax_h3_fl2va_pruned_w4a8_mixed.safetensors | Another 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
| Asset | Purpose | Documented location or behavior |
|---|---|---|
| Complete VDN stage | VDN acceleration and matching adapter. | ComfyUI/models/vdn/<model-directory> |
minimax_h3_t2va_veda_8nfe_600step_preview_fp8.safetensors | VEDA sparse-routing predictor. | ComfyUI/models/veda/ |
taeh3.safetensors | Live preview decoder. | ComfyUI/models/vae_approx/; downloads and verifies if missing. |
taeh3_decoder.safetensors | Compatible alternative preview decoder filename. | ComfyUI/models/vae_approx/ |
minimax_h3_latent_upscaler_3d_fp16.safetensors | H3 latent upscaling. | Downloads and verifies into ComfyUI/models/latent_upscale_models/ if missing. |
| Face detector | Detects faces for local repair. | Downloads and verifies into ComfyUI/models/ultralytics/bbox/ on first use. |
nvngx_dlssnr.dll and available variants | DLSS 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 route | Average sampling time per step | Complete task time |
|---|---|---|
| KJNodes SM75 SageAttention 2 | 190.50 s | 863.41 s |
| Comfy Kitchen INT8 | 119.50 s | 620.32 s |
| SLA SM75 QK-INT8/PV-FP16 | 96.68 s | 471.12 s |
| SLA SM75 All-INT8 | 60.83 s | 325.51 s |
| Sol SM75 All-INT8 | 88.71 s | 442.57 s |
| CK + Sol Hybrid | 106.12 s | 498.27 s |
| CK + SLA Hybrid | 94.67 s | 454.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
- Read the error to identify the failed stage.
- Leave automatic halving enabled if you want recoverable retries.
- Reduce the corresponding setting if necessary:
| Error location | Setting to reduce |
|---|---|
fc1, SwiGLU, or fc2 | mlp_chunk_tokens: 8192 → 4096 → 2048 → 1024 |
rms_rope_split_half_ or RoPE | chunk_tokens: 8192 → 4096 → 2048 |
| QKV projection | qkv_chunk_tokens: 8192 → 4096 → 2048 → 1024 |
- 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.
- Confirm that the error is inside attention rather than QKV, RoPE, or MLP.
- Try another compatible attention backend.
- 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.
- Review the model’s quantization format and memory requirements.
- Adjust loading or offloading strategy.
- Select a supported lower-memory model if needed.
Changing activation chunk sizes does not reduce model weight memory.
“Required architecture” or compute-capability error
- Check your GPU family.
- Select an SM75 or SM80+ backend appropriate to that GPU.
- Re-run the task.
The complete backend menu is intentionally visible on every machine to support shared workflows.
Hybrid cannot determine the sampling step
- Check that the workflow supplies the real sigma schedule.
- Compare your connections with the provided general workflow.
- 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.
- Use the enhanced H3 loader or verify that your H3 model has FP16 Exact protection.
- On SM80+, check that the intended BF16 loading route is being used.
- Review launcher precision settings, especially
--fp16-unet. - Read the logged block and stage information.
- 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
- Determine whether the original workflow already fit comfortably in dedicated VRAM.
- If it did, test larger chunk sizes.
- Compare complete task time as well as sampling time.
- 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.
- Compare with the same seed and all other settings unchanged.
- Inspect motion, detail, prompt adherence, and speech/audio quality.
- Try the standard precision route before All-INT8.
- 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
- Check that the selected backend supports your architecture.
- For VEDA, verify the predictor asset is available.
- Do not combine VEDA with SLA, Sol, VSA, or another sparse attention patch.
- 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
- Confirm that the preview node is connected before the Guider.
- Enable preview display.
- Check for
taeh3.safetensorsortaeh3_decoder.safetensorsinComfyUI/models/vae_approx. - 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
- Connect face repair directly to Star7 H3 Tiled Decode.
- Supply the sampling context.
- Confirm that repair is enabled and a face was detected.
- 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
- English general workflow — the most direct starting point for understanding the node connections.
- Workflow collection — additional workflow files supplied with the project.
- English documentation — the project’s English reference.
Understand acceleration and performance
- Spark/VPack acceleration guide — details for the separately enabled acceleration node.
- Benchmark records — reported timings and test conditions.
- MiniMax H3 Turbo SLA LoRA — the LoRA recommended for SLA use.
- Project repository — source documentation and distributed project files.
