MiniMax H3 ComfyUI: Setup, Models and Local Workflows

H3Vid Teamon 2 months ago

MiniMax H3 runs in ComfyUI through official native workflows for text-to-video, image-to-video, and reference-to-video generation. The reliable starting point is to update ComfyUI, load the matching official template, download the workflow-specific weights, and test a short 768p job before adding LoRAs or advanced nodes.

Quick answer: Use the FL2VA weights for text-to-video and image-to-video. Use the separate Ref2VA weights for reference-to-video. Both workflows also need the H3 text encoder plus video and audio VAEs. Do not mix the two diffusion models in one base workflow.

Conceptual MiniMax H3 ComfyUI workflow connecting text, image, video, and audio references to a generated video
Conceptual workflow illustration. It explains the input-to-output flow and is not a ComfyUI screenshot or a MiniMax H3 generation result.

Find your setup route

This guide covers the native ComfyUI setup first, then the components and alternative interfaces you can add or choose instead. The community sections preserve documentation reviews from October 2–24, 2026; those dates are listed with each project. H3Vid has not installed or benchmarked those external runtimes. Reported timings belong to their authors and stated configurations. The illustrations explain concepts and are not generation results.

Your starting questionRead nextWhat changes
Which files do I need for T2V, I2V or Ref2VA?Native workflows and model foldersBase model, encoder and separate video/audio VAEs
Can a consumer GPU run the local stack?FreeVideoExecution planning, offloading and a dedicated model recipe
How do I reduce attention work?Veda, Spark, Ref2VA VSAAttention patches with different predictors, kernels and samplers
Can I speed up video encoding or decoding?LightVAEVideo VAE components
Which community model file should I download?Singularity V2, Remix v0.8Complete transformer checkpoints
Do I need an optimized runtime or a finishing stage?Sol-H3 Studio, SoL-RefinerSeparate runtime or H3-to-LTX refinement
Can I work through an interface instead of wiring every node?Maestro / ComfyUI Studio, Mago LocalAuthoring and production interface
I use Apple SiliconH3cApp on macOS, Omarchy on LinuxDifferent OS, memory and runtime requirements
I need a remote GPU controlled from my laptopColab runnerRemote inference, local job preparation

For few-step adapters, see the MiniMax H3 LoRA resource guide. FastH3 model variants have a separate FastH3 V2 and Trim guide. A checkpoint, an adapter, an attention patch and a VAE each occupy a different place in the stack; matching their documented recipe matters more than combining the largest number of accelerators.

Native ComfyUI setup

What you need before running MiniMax H3 in ComfyUI

Start with a current ComfyUI installation. MiniMax H3 support, templates, and newer native nodes have landed across recent updates, while Desktop and Cloud builds can trail the newest nightly changes. If a template or node mentioned here is missing, follow the official ComfyUI update guide before installing third-party custom nodes.

You also need:

  • For the NVIDIA native route, a CUDA-capable system with enough GPU memory for your chosen resolution and clip length. Other runtime routes are described below.
  • Free disk space for the diffusion model, text encoder, video VAE, audio VAE, and any optional LoRA files.
  • The official MiniMax H3 ComfyUI model pack.
  • The official template that matches your task: T2V, I2V, or R2V.
  • Time for an initial low-risk test before increasing resolution, duration, or reference count.

The official documentation does not promise one universal minimum VRAM figure. Memory use changes with workflow, model precision, resolution, frame count, reference media, attention implementation, and other nodes loaded in the same graph. Treat community claims such as “runs on 6GB” or “needs 24GB” as configuration-specific reports, not a guarantee for every MiniMax H3 ComfyUI setup.

Choose the correct MiniMax H3 ComfyUI workflow

The three official base workflows share some files but solve different creative tasks.

WorkflowBest forMain inputDiffusion weights
Text-to-video (T2V)Creating a shot from a written scene, camera, and audio descriptionPromptFL2VA
Image-to-video (I2V)Animating a first frame or connecting a first and last framePrompt plus optional first/last imagesFL2VA
Reference-to-video (R2V / Ref2VA)Preserving a character, style, motion, camera move, or voice from reference mediaPrompt plus images, videos, or audioRef2VA

The official MiniMax H3 native workflow guide includes downloadable JSON templates and Template Library names for all three modes. Begin with those templates. A third-party graph can be useful later, but it adds variables when you are still verifying the base installation.

Text-to-video

Choose T2V when the prompt alone should define the scene. MiniMax H3 can generate synchronized video and audio, so describe the visual action, camera movement, dialogue, ambience, sound effects, and music in one coordinated prompt rather than treating sound as an afterthought.

Image-to-video and first-last-frame video

Choose I2V when you have a starting composition. The native MiniMaxH3ImageToVideo node accepts an optional first frame and last frame. A first frame anchors the opening appearance; adding a last frame also gives the motion a visual destination.

Reference-to-video

Choose R2V when identity, style, motion, camera behavior, or voice should come from reference media. The official workflow supports up to nine reference images, three reference videos, and three standalone audio clips. Assign each reference a clear job in the prompt and refer to it in connection order. R2V uses its own Ref2VA diffusion weights, not the FL2VA file used by T2V and I2V.

If you want reference-guided generation without managing local weights, use the MiniMax H3 Ref2VA online workflow.

Install the MiniMax H3 model files in the right folders

Open ComfyUI's Template Library and search for MiniMax H3 T2V, MiniMax H3 I2V, or MiniMax H3 R2V. The template notes link to the files it expects. Download files from the official Comfy-Org repository rather than relying on similarly named uploads from an unknown account.

Place each file type in its matching directory:

ComfyUI/
└── models/
    ├── diffusion_models/
    │   ├── minimax_h3_fl2va_pruned_int8_convrot.safetensors
    │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors
    ├── text_encoders/
    │   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
    ├── vae/
    │   ├── minimax_h3_video_vae_int8_convrot.safetensors
    │   └── minimax_h3_audio_vae_fp32.safetensors
    ├── loras/
    │   └── minimax_h3_*_turbo_*.safetensors
    └── embeddings/
        └── minimaxh3_*.safetensors

You do not need both diffusion models for every task. Download FL2VA for T2V/I2V, Ref2VA for R2V, or both if you plan to use all three workflows. Turbo execution and style embeddings are optional. Some templates scan for the matching Turbo file even when its mode is off, so download any file required by the template notes; verify base sampling first.

After copying the files, restart ComfyUI or refresh its model list. If the graph still shows an unavailable model, compare the folder and filename with the template note. A correct file in the wrong model directory will not appear in the expected selector.

MiniMax publishes the base model under the MiniMax H3 Community License. Review the current license and acceptable-use terms before distributing weights, offering a hosted service, or using outputs commercially.

Use safe first-run settings

For a first successful run, keep the graph close to the official template:

  1. Select the matching FL2VA or Ref2VA diffusion model.
  2. Confirm that both the video VAE and audio VAE are loaded.
  3. Start at the native 768-pixel short-edge canvas; the official 16:9 example is 1344 × 768.
  4. Use a short clip before testing the upper duration range.
  5. Keep the default base sampling path before enabling a turbo LoRA.
  6. Use one simple prompt and the minimum number of references needed for the task.
  7. Queue one job and confirm that both video and audio decode correctly.

The native workflow rounds dimensions to multiples of 32. Its duration follows MiniMax H3's frame-block grid at 24 fps, so the displayed frame count may snap to a valid value rather than matching an arbitrary number exactly.

The official base templates use 20 sampling steps. The optional Lightning LoRA can reduce the workflow to an eight-step path for faster iteration, with some tradeoff in motion and audio quality. Use the base path to establish a quality reference before deciding whether the turbo result is acceptable for your project.

Plan VRAM before raising quality

Conceptual GPU workstation showing memory pressure and local AI video workflow controls
Conceptual hardware-planning illustration. Actual memory use depends on the complete graph, model precision, resolution, duration, references, and ComfyUI build.

Resolution and clip length are the first controls to reduce when a job runs out of memory. Video latent size grows across both space and time, so increasing the canvas and duration together is much more demanding than changing one setting alone.

Use this order when tuning a local MiniMax H3 ComfyUI workflow:

  1. Prove the graph at 768p with a short clip.
  2. Use the optimized or quantized files referenced by the official template.
  3. Reduce resolution before removing essential conditioning.
  4. Reduce duration or reference count if memory pressure remains.
  5. Close other GPU-heavy applications and unload unused models.
  6. Add LoRAs, upscalers, interpolation, or long-video chaining one component at a time.

Sampling fewer steps mainly reduces generation time; it is not a universal fix for peak VRAM. Likewise, a workflow that fits one GPU may fail on another system with the same advertised memory because software versions, attention backends, and other loaded nodes differ.

If local hardware is the main blocker, generate MiniMax H3 video online instead of spending time rebuilding the graph around an unverified low-memory preset.

Write prompts for video and audio together

MiniMax H3 prompts work best when they describe the whole scene first and then define the shot sequence, camera, action, and sound. A useful structure is:

Scene and subject. Shot timing and camera movement. Character action and expression.
Dialogue, ambient sound, sound effects, and music. Final composition or transition.

For I2V, describe how the supplied frame should move rather than repeating every visible detail. For R2V, give each reference one explicit responsibility: identity from one image, costume from another, motion from a video, and voice from an audio clip. Ambiguous assignments make it harder for the model to decide which reference should control each part of the result.

Consumer-GPU execution planning

FreeVideo: memory planning and installation

FreeVideo brings MiniMax H3 video generation to consumer GPUs through a local ComfyUI workspace. The useful question is whether its memory management makes your intended shots practical on the computer you already own. A minimum-memory headline alone cannot answer that.

Documentation reviewed October 2, 2026. The project announcement cites operation with as little as 8GB VRAM and 16GB RAM; the conditions below explain the scope of that claim.

Concept illustration of a consumer GPU workstation creating cinematic video frames locally
Concept illustration of the FreeVideo workflow; not a software screenshot, model output or benchmark.

How FreeVideo relates to H3

The project README identifies FreeVideo as an inference engine built around OpenVDN's eight-step VDN-H3 model. MiniMax H3 is the underlying model family; FreeVideo packages a local execution path and creative workspace. ComfyUI provides the graph environment.

That distinction helps when choosing downloads. “I have H3 weights” and “I have the files expected by this workflow” are different checks. Start from the project's setup route, rather than assembling an installation from unrelated H3 tutorials.

What the 8GB claim actually tells you

FreeVideo's execution-planning documentation describes moving transformer blocks between VRAM, host memory, and disk. It measures available memory for each request; image dimensions and frame count affect the working set. Limited capacity can therefore change both placement and waiting time.

The capacity grid uses an H200 with imposed memory limits. That is not an 8GB consumer-card benchmark. The same document reports these separate Windows end-to-end examples for 1344 × 768, ten-second, two-pass generation:

GPUVRAM / RAMReported time
RTX 509032GB / 64GB122 seconds
RTX 5060 Ti16GB / 32GB486 seconds
RTX 4060 Ti16GB / 32GB558 seconds

These are project measurements, not our tests or promises for your machine. They illustrate why “fits in memory” and “fast enough for my work” need separate answers.

Before downloading, note your GPU, available RAM, disk space, and target clip. Close other heavy applications for the first trial. An eight-gigabyte label on the box does not establish how much memory is available when generation begins.

Choose an installation route

The README provides three entry points:

  • Windows launcher: select an existing ComfyUI folder or a new installation, optionally reuse model folders, then choose Install & launch.
  • Existing ComfyUI: add the repository under custom_nodes, restart, and open Workflow → Browse Templates → FreeVideo → FreeVideo-All-in-One. Complete FreeVideo Settings.
  • Linux: use the repository's setup script and command-line generator.

Follow the current README for commands and downloads. These are documentation-based directions, not a reproduced installation walkthrough. For the broader model-file structure, see our native setup.

A sensible choice is the route closest to your existing environment. If you already maintain ComfyUI, consider whether a separate installation would make experiments easier to isolate. If you are starting fresh, prepare enough time for setup and model downloads before a production deadline.

The planner also provides freevideo plan for inspecting capacity assumptions and a request JSON sidecar with hardware, placement, timing and memory details. Keep the sidecar when reporting a model-load failure, a longer-clip failure or unexpectedly slow disk streaming. It distinguishes setup, capacity and output-quality problems.

Attention backends: Veda, Spark and Ref2VA VSA

BackendComponent to installHardware and graph boundary
VedaRegistry node plus task-specific predictorDocumented NVIDIA, AMD and MLX paths have different validation coverage
Spark-H3Architecture-specific package and MODEL patchComfyUI packages target SM89/SM120; preserve the chosen sampler and actual evaluation count
Ref2VA VSACustom node, extracted gate and four-step Turbo adapterExperimental Ref2VA recipe; author's requirements specify a 24GB NVIDIA GPU

Use one attention patch for the first comparison. Fewer attention tiles, fewer sampler evaluations and less wall-clock time are separate measurements.

Veda sparse attention: predictors and reference controls

Veda is a learned sparse-attention method with a ComfyUI integration for MiniMax H3. It aims to reduce attention computation by predicting which regions are important and computing a selected subset. It is not a new video model, a Turbo LoRA, or a guarantee that every local workflow becomes faster by the same amount.

Documentation reviewed October 12, 2026. Sources: project README, predictor model card.

Concept illustration for Veda sparse attention: predictors and reference controls
Concept illustration of the Veda sparse attention workflow; not a software screenshot, model output or benchmark.

Veda changes computation, not the creative brief

A Turbo LoRA changes the model through learned weights for a different sampling recipe. Veda instead changes how attention is calculated. Its small predictor estimates which attention tiles to retain. The author's default configuration targets skipping roughly 90% of candidate attention tiles; this is not a claim that 90% of the entire generation workload disappears.

A video run still includes other work: model movement, sampling operations outside attention, decoding, and delivery. If one of those dominates your system, a faster attention stage may produce a smaller total improvement. Separate attention timing from the time between clicking Generate and receiving a usable clip.

Keep the prompt, references, and sampling configuration stable during your first comparison. Changing the scene and enabling Veda simultaneously makes it harder to identify why the result or timing changed.

Documented installation and placement

The current node documentation requires ComfyUI 0.38.0 or newer and offers installation through the Comfy Registry. It also provides templates for H3 text-to-video and reference-to-video. For an existing graph, the node sits on the MODEL connection after model and LoRA loading, immediately before the guider or sampler.

The separate predictor is stored in ComfyUI/models/veda/. The documented filename is:

minimax_h3_t2va_veda_8nfe_600step_preview_fp8.safetensors

A template's missing-model dialog can offer this file. The node itself does not silently download it; a missing selection should produce an explanatory message. Check that the selected file appears in the predictor list before diagnosing an apparent lack of speedup.

Read the current installation instructions for your environment. They distinguish NVIDIA kernel dependencies from the Apple Silicon route. Preserve a working baseline graph before modifying it, and keep the revision you installed with your test notes. These are documentation-based instructions, not a verified installation transcript.

What T2VA and 8NFE in the name mean

The predictor's repository name describes its training configuration. The model card says it can also be used with first/last-frame and reference generation, and with other diffusion-step counts. That permission to try a configuration is different from evidence that it performs equally well in every configuration.

The ComfyUI README identifies training around an eight-step Turbo recipe and a defined set of sizes and durations. Other combinations require comparison against full attention. As of October 10, 2026, a dedicated R2VA preview predictor is available, and the current ComfyUI README lists minimax_h3_r2va_veda_preview_fp8.safetensors for its reference template. This updates the earlier announcement's future-release language. The R2VA card describes an eight-step Turbo setup with independently selected visual-reference and generated-video tiles, while text and audio attention remain dense. Its comparison videos reuse the Dense audio track, so those paired videos do not independently demonstrate the sparse run's audio quality. Choose the predictor for the intended task and compare against full attention; availability alone does not validate every reference workflow.

For a character-reference workflow, judge identity and small features directly. A result that is pleasing as a standalone shot may still miss the specific facial details, clothing, or object geometry that motivated the reference input.

Generated and reference attention have separate controls

Veda exposes separate sparsity settings for generated content and reference content. The current defaults use the selected predictor's trained budget. A percentage describes skipped tiles; an integer describes a fixed number of retained 128-token key tiles. Those are different units. The node documentation describes a zero reference-sparsity setting as full attention for those references. It also provides ways to retain full attention on selected layers or sampling steps.

Treat these as controls to investigate a particular failure, not universal magic values. If a reference feature disappears, keep the source and seed fixed and compare a baseline, the current sparse configuration, and a configuration that preserves more reference attention. Inspect the exact feature you care about at several moments.

Do not assume every attention patch in a graph stacks productively. The project warns that ComfyUI's own Model Sparse Attention replacement can prevent Veda from being called. Read the current compatibility section for other patches and inspect the node's status text. An enabled box is not proof that a sparse kernel actually ran.

AMD and Apple Silicon now have upstream paths

As checked on October 12, the upstream node documents Triton INT8 for NVIDIA SM80 and newer, AMD RDNA3/RDNA4 on ROCm, and an MLX path for Apple Silicon. The hardware validation log distinguishes tested hardware from ready code paths. It records RX 9060 XT kernel checks on Windows and M3 Pro kernel self-tests; those checks do not establish full video-generation speed or quality on every Radeon or Mac.

ROCm Ninodes remains a separate Strix Halo / gfx1151 integration. Do not transfer its measurements to an upstream RDNA4 path or assume that a kernel self-test demonstrates an entire local video pipeline. Select the documentation for the node you installed and confirm its reported backend. We have not installed either AMD route or the MLX route.

The same upstream log now records reference and two-stage comparisons, including configurations where sparse attention was not faster at small token counts. Its expanded samples did not support the suspected periodic reference-tile artifact. That narrows one reported problem; it is not proof of universal reference identity or audio equivalence. The R2VA model-card comparison's reused Dense audio remains a separate limitation when evaluating sound.

Read speed claims in their measurement context

The model card gives author-reported acceleration claims and side-by-side examples. A community report describes one laptop configuration taking 8:05 without Veda and 4:32 with it, using a four-step LoRA and a 15-second, 1344×768 clip. The same discussion includes conflicting quality and comparison experiences. These are reports from other people, not project benchmarks.

A laptop GPU, a desktop GPU, and a unified-memory machine are different execution environments. Keep hardware, precision, offloading, other patches, and cold versus warm loading visible when comparing measurements. A timing for one prompt does not establish an overall ranking against SoL, SLA, Spectrum, or another acceleration method.

Spark-H3: GPU packages, samplers and evaluation counts

Spark-H3 is a local attention backend for MiniMax H3. It changes how the model computes attention rather than supplying a new video checkpoint. Its public code includes Diffusers integration and ComfyUI nodes, giving local users another way to investigate the cost of each sampling step.

Documentation reviewed October 12, 2026. Sources: project.

What Spark changes

The project's two mechanisms are reblocking and reweighting. Reblocking groups tokens with similar attention preferences; reweighting adjusts summaries of the less directly computed blocks. The aim is to spend the attention budget more effectively while approximating interactions that do not receive full computation.

That is different from a Turbo LoRA, which supplies learned weights for a few-step recipe. It is also different from FastH3 as a distilled model release. A workflow can involve both a sampling accelerator and an attention backend, but each changes a different part of the execution.

Think about where your machine spends time before choosing an experiment. If weight transfers or decoding dominate a render, reducing attention work may change only part of the total. If attention is expensive because the video has many tokens, the potential benefit may be larger. Neither case can be diagnosed from the final video resolution alone.

Choose the package for your actual GPU

The ComfyUI guide describes standalone SM89 and SM120 nodes for native H3. Its release targets are Linux or Windows x86_64 with RTX 40-series or RTX 50-series/RTX PRO Blackwell GPUs and CUDA BF16 execution. Select the release for both the operating system and GPU architecture.

The broader Diffusers dispatch has additional architecture paths. That does not mean every path has the same release packaging or hardware validation. DGX Spark is a computer with a GB10 chip; its name does not establish compatibility with this project named Spark-H3. Read the exact architecture table instead of matching the word “Spark.”

Keep your working ComfyUI environment intact while investigating installation. Note its Python, PyTorch and CUDA versions, then compare them with the release's requirements. Model weights and ComfyUI itself are not bundled with the attention package.

Begin with a supplied workflow

The ComfyUI examples cover native H3 and several LoRA configurations. The LightX2V and Larryvrh adapters require their own weights; the Larryvrh route also has a documented conversion step. DMAD uses its specific re-noise sampler. These are explicit recipes, not permission to substitute any four-step sampler.

Place the matching Spark node on the MODEL path before BasicGuider and use one attention patch. Begin with the package's example values instead of adding it to a graph already carrying several attention overrides. First confirm the correct node, model files, and sampler connections; only then change creative inputs.

Its LBH example is especially easy to confuse with another workflow. Spark's official-style LBH graph performs four low-resolution model evaluations followed by three high-resolution evaluations, with Spark applied to the second stage. The separate LBH 3+1 package uses three low-resolution steps and one high-resolution step. They should not share a timing label.

Warmup and step counts need explicit definitions

The configuration guide distinguishes dense warmup evaluations from later sparse evaluations. Keeping the early part dense is part of a recipe, not an extra initialization time that can always be removed from the measurement.

MiniMaxH3Scheduler also includes a terminal zero in its requested inference-step grid. The documented Diffusers example requests 20 grid points for 19 actual denoising evaluations. Spark's installer should receive the actual evaluation count. Copying a requested number into every field without checking its meaning can change the warmup schedule.

When comparing runs, record requested steps, executed model evaluations, dense warmup, forced dense layers and Top-K settings separately. A single “20 steps” note loses information needed to reproduce the configuration.

The project describes exact handling for text, audio and conditioning context while sparsifying the generated target-video grid. That execution design does not replace listening to the result or checking the reference subject. Numerical handling and perceptual success answer different questions.

What the speed numbers measure

The kernel performance matrix reports CUDA-synchronized DiT/denoising time, excluding loading, VAE decoding and other end-to-end work. It records actual evaluations and aggregates four dense and four Spark measurements for each displayed duration.

For its ten-second native H3 profile, the matrix gives 988.0→581.5 seconds on A800 and 583.9→338.7 seconds on RTX PRO 6000 Blackwell. Both use a specified BF16, 1344×768, 19-evaluation profile with dense warmup. These author measurements are more useful with their configuration attached than as a headline promising every clip finishes that much faster.

Do not merge an attention-kernel ratio, a DiT ratio, and a complete generation ratio into one ranking. Compiled runtime state, cache warmth, model precision and sampler changes can all affect a comparison. A social post's larger ratio may refer to another workload; use its original record before repeating it.

Ref2VA VSA: gate files and the four-step graph

ComfyUI-Ref2VA-VSA is an experimental custom node that applies video-sparse attention to MiniMax H3's reference-to-video path. Its useful promise is a specific local character-video recipe: keep multimodal reference conditioning separate while pruning selected attention work in generated video. It is not a new hosted H3 model or a guarantee that every character will remain unchanged.

Documentation reviewed October 20, 2026. Sources: author's repository.

Concept illustration of MiniMax H3 Ref2VA VSA
Concept illustration of the Ref2VA VSA workflow; not a software screenshot, model output or benchmark.

What the 72-second number means

The README's warm result is approximately 72 seconds for 124 frames at 24fps and 1344×768 on an RTX 4090 with 24GB VRAM. Its first run is about 95 seconds. A 124-frame output is approximately 5.17 seconds, which explains the rounded five-second label.

The listed peak memory is about 13.5GB, but the requirements still specify a 24GB NVIDIA GPU. Peak memory from one measured configuration does not validate all 16GB cards, different text encoders, larger reference sets or other installations. A social repost's broader sixteen-gigabyte claim should not replace the repository's actual tested machine and requirements.

The comparison also changes more than attention: the VSA case uses four Euler/simple steps, while the VDN comparison uses eight steps with another sampler and scheduler. Read it as a comparison of complete author-selected recipes, rather than a controlled measurement of one kernel change. Ratios based on first-run timing also differ from ratios based on warm runs.

Why reference conditioning needs special handling

Reference-to-video packs text and reference information alongside the sequence being generated. Applying video tiling indiscriminately can mix conditioning segments into a geometry intended for video. The project separates the conditioning prefix from generated-video tiles and keeps that prefix outside the pruning operation.

This is an architectural explanation of the node's intent. It does not establish perfect identity preservation. Faces, clothes, pose and interactions still need visual review in the resulting clip. A reference remaining available to attention is different from the generator obeying it exactly in every frame.

The patch transplants learned gate projections from a FastH3 VSA checkpoint onto the Ref2VA model. That gate file is a distinct component from the Turbo LoRA: one controls sparse selection, while the other supplies the accelerated sampling recipe. Renaming an ordinary LoRA to the gate filename will not create those projections.

Assemble the required files

Use the current repository's linked files and destinations. The documented recipe includes a pruned INT8 Ref2VA diffusion model, a four-step Ref2V Turbo LoRA, fasth3_vsa_gate.safetensors, an NVFP4 AWQ Qwen3-VL text encoder, FP16 video VAE and FP32 audio VAE. The diffusion model belongs in models/diffusion_models; gate and Turbo files go under models/loras; encoder and VAEs have their own directories.

The complete filenames and download links remain in the author's requirements section. Check every selector in the workflow against the actual file on disk. Similar H3 names can refer to a different task, quantization or conditioning contract.

The gate extraction utility accepts the named FastH3 VSA source checkpoint and writes the small gate file. Use the script's documented source rather than assuming every checkpoint contains suitable gate tensors. Keep a record of which source produced it so the experimental setup can be reconstructed later.

Install and preserve node order

Install the custom node inside ComfyUI's custom_nodes, restart ComfyUI, then load workflows/ref2va_vsa_4step_rtx4090.json. The README also requires a current native-H3 ComfyUI installation, PyTorch/CUDA and comfy-kitchen with CUDA sol_attn support. A visible node in the menu does not prove that the required compiled attention kernel is available.

The intended model path is: load the Ref2VA INT8 model, apply the four-step Turbo LoRA at strength 1.0, apply Ref2VAVSAGatePatch at sparsity 0.75, then apply H3 sigma shifts. The documented shifts are 12 for video and 3 for audio. Sampling uses four steps, the simple scheduler and Euler sampler.

For an initial check, use the supplied example image and saved workflow before substituting your own references. Preserve its wiring and change one input at a time. If the node cannot import or the kernel fails, capture the software versions and error; changing sparsity will not repair a missing binary dependency.

Video VAE components

LightVAE: video encoder and decoder choices

LightVAE accelerates the video autoencoder stage of MiniMax H3. It supplies smaller encoder and decoder components that retain the corresponding latent interface. It does not replace the main video diffusion model, and it does not compress H3's separate audio VAE.

Documentation reviewed October 15, 2026. Sources: ComfyUI PR #17049.

Concept illustration for LightVAE: video encoder and decoder choices
Concept illustration of the LightVAE workflow; not a software screenshot, model output or benchmark.

What changes in the H3 pipeline

An encoder turns reference pictures or footage into latent representations. A decoder turns generated video latents back into frames. Sampling the main video model sits between those stages. Faster decoding therefore helps most when decoding takes a meaningful share of your job.

The LightVAE paper describes temporal compression and quality recovery across supported video autoencoders. The released H3 Lite components use independent block pruning. Wan's Pro and Lite naming should not be copied onto H3 as if every backbone had the same available variants.

Keep checkpoints matched to their backbone. A file trained for Wan is not an H3 component merely because both repositories discuss video VAEs. The published H3 workflows also keep the original audio VAE, so sound decoding and video decoding remain separate choices.

Choose FL2V or reference-video wiring first

WorkflowEncoder pathDecoder path
FL2V, including first/last picturesOriginal H3 VAEH3 Lite decoder
Ref2V with picturesOriginal or H3 Lite encoderOriginal or H3 Lite decoder
Ref2V with video and soundtrackOriginal or H3 Lite encoderOriginal or H3 Lite decoder; original audio VAE

These are the author's supported graph distinctions. In the first/last-frame example, the original VAE feeds keyframe encoding directly. Replacing it everywhere because a smaller encoder exists would depart from that documented setup.

For reference inputs, changing encoder and decoder together changes two stages at once. Start with original encoding and Lite decoding, then evaluate the optional encoder separately. This makes it easier to locate a change in reference fidelity or reconstruction detail.

Install the documented adapter route

The ComfyUI installation guide provides an explicit installer. Use ComfyUI's own Python environment, and start from a version with native H3 support.

cd /path/to/ComfyUI
git clone https://github.com/ModelTC/LightVAE.git LightVAE
python LightVAE/comfyui/install.py --comfy-root .
python -m pip install huggingface_hub
hf download lightx2v/LightVAE \
  lightvae-lite-h3-decoder.safetensors \
  lightvae-lite-h3-encoder.safetensors \
  --local-dir models/vae/LightVAE

The installer creates the custom-node adapter. Do not clone the complete LightVAE repository directly into custom_nodes. Retain the original H3 video VAE as the adapter's base component; its documented download is vae/minimax_h3_video_vae_fp16.safetensors from Comfy-Org/MiniMax-H3.

Restart ComfyUI. Connect the standard Load VAE output to Load H3 LightVAE.base_vae, then select the desired Lite components in the LightVAE node. In this adapter, none retains the corresponding original component. For FL2V, leave the encoder selection at none and keep original keyframe encoding wired as the example shows.

The newly merged native support changes what ComfyUI can recognize; it does not prove an older stable installation already has those changes. The installer workflow above is the documented adapter route, with its own node and wiring. Avoid mixing instructions for a native partial component loader with instructions that expect a complete base VAE.

Import a matching example

The author supplies separate first/last-frame, image-reference and video-reference graphs. Select your actual model files and upload your own inputs after importing one.

Their default examples use 1344×768, 124 frames at 24 fps, and twenty base-model steps. They are not four-step or eight-step Turbo recipes. First validate the provided model family and graph, then assess whether a separate accelerated sampler recipe remains compatible. A successful file load alone does not establish that an arbitrary combined optimization is correct.

Add the optional ConvRot-INT8 decoder

The model card lists lightvae-lite-h3-decoder-int8-convrot.safetensors. Update the adapter checkout, rerun its installer, download the file into the LightVAE VAE directory, and select it as the decoder. Keep the base VAE connected and preserve your existing encoder and audio paths.

This particular INT8 file is documented for ComfyUI. Use standard non-INT8 checkpoints with the standalone infer.py and benchmark.py programs. Native NVIDIA acceleration requires a CUDA 13.0-or-newer PyTorch build and a compatible driver; older builds may fall back to other operations. The checkpoint's smaller storage footprint does not establish a matching percentage reduction in job time or peak memory.

If an INT8 run is unexpectedly slow, record the actual PyTorch build and backend before changing the sampler. If reference appearance changes, compare original encoding with Lite decoding first. If audio changes, inspect the audio path: LightVAE's documented replacement is the video component.

Measure the stage you intend to improve

The repository's comparison protocol uses an H200, BF16, three 124-frame clips and warmup before timing. Reconstruction quality is measured before MP4 compression. Those conditions describe the authors' experiment, not a result on your GPU.

Keep sampling settings, reference inputs and output encoding fixed for your own evaluation. Record encoding, sampling, video decoding and total wall-clock time separately. Inspect fine texture, moving edges and reference identity as well as playback. An optional compact component is useful when it improves the stage that limits your workflow while retaining acceptable output.

For broader local setup, use the native setup. For an attention optimization, see Veda sparse attention. These affect different parts of the pipeline and need separate compatibility checks.

Full community checkpoints

Singularity and Remix replace the diffusion transformer. They are not standalone LoRAs; keep compatible text encoding, conditioning and video/audio VAEs in the graph.

Singularity V2: full checkpoints and older pruned files

Singularity V2 is a community fine-tuned fusion of MiniMax H3 for video with sound. Its new release targets broader action coverage, closer prompt following and stronger style rendering. The important download detail is simpler: the published V2 file is a full INT8 checkpoint. The smaller pruned files beside it still carry V1.3 names.

Documentation reviewed October 22, 2026. Sources: author's model card, current file tree, SGLang's H3 cookbook.

What changed in V2?

The author describes expanded action training, better control over subjects and environments, and improved photorealistic and CG styles. The card also reports a repair to audio-reference conditioning. These are release claims, rather than a controlled comparison against base H3 or other fine-tunes.

One detail needs particular care: the English card says audio references can adjust a character's “color tone.” That wording does not establish how voice identity, timbre or visual color responds. Treat the announcement as an audio-conditioning fix; use a short controlled example to establish what it means for your scene before relying on it for a production voice.

Singularity remains a fusion model, combining H3 checkpoint families and further training. It is different from FastH3 Omni's reference-conditioned distillation and from an ordinary style LoRA. Downloading it changes the transformer used by the workflow; it does not install the surrounding text encoder, video VAE or audio VAE.

Choose the correct file

The publisher's file listing currently distinguishes these builds:

CheckpointApproximate downloadMeaning
Minimax-h3_Singularity_ref2va_v2_int8.safetensors34.0 GBThe newly listed V2 INT8 model
Minimax-h3_Singularity_ref2va_v1.3_int8.safetensors34.0 GBOlder full V1.3 INT8 model
Minimax-h3_Singularity_ref2va_Pruned_v1.3_int8.safetensors21.0 GBOlder pruned V1.3 build
Minimax-h3_Singularity_ref2va_v1.3_Pruned_w4a8.safetensors11.8 GBOlder V1.3 W4A8 build

These decimal file sizes describe storage, not required VRAM. Model loading, activations, reference encoding and decoding add their own memory demands. A 34 GB file does not imply a 34 GB card is the minimum, or that a smaller card will finish at a particular speed.

When someone recommends a smaller Singularity download, check the complete filename and revision. A working V1.3 quantization is useful, but changing its label in a preset does not give it V2's training. Community GGUF repositories are separate distributions; verify their model lineage rather than assuming their newest upload is V2.

Prepare ComfyUI without changing everything at once

Begin with a working native MiniMax H3 installation. Keep a saved copy of the graph and the exact model selected before changing it. Place the chosen transformer in the diffusion-model directory expected by your loader, then explicitly reselect it after refreshing the model list.

Retain the compatible H3 text encoder and both VAEs. Start with the same input mode, reference order, duration and resolution that already work. The Singularity card advertises text, image, reference and video workflows, but the graph still has to supply the matching conditioning. The ref2va filename alone is not a wiring tutorial for every mode.

For faster inference, the author recommends minimax_h3_ref2v_turbo_4step_v0.1. Match the sampler recipe to that adapter. Simply reducing an ordinary high-step graph to four steps does not install distillation. Likewise, do not add PTD, VSA and multiple action adapters to the first validation run: that makes any failure difficult to attribute.

Running outside ComfyUI

SGLang documents Singularity as a hybrid FL/Ref fusion transformer override while retaining the official H3 model for encoders and VAEs. Its currently shown recipe names V1.3 files and uses an explicit hybrid variant. That is evidence for a specific runtime arrangement, not confirmation that V2 has passed the same checks.

Before replacing that filename with V2, inspect the runtime's current supported-weight list and release notes. Keep base assets and transformer overrides separate. The model card's repository license label also does not by itself establish the rights for every upstream component in a hosted deployment.

For a local first attempt, choose the exact V2 file, a known H3 graph and a short scene with clear events. For a hosted workflow today, use the actual model name shown by your generator; H3 Max and Singularity are different execution choices.

The author suggests keeping prompts within approximately 5,000 characters. Use that as a ceiling, and retain the same action sequence, camera direction and sound brief when comparing V2 with an older checkpoint.

Remix v0.8: version records and Easy H3 loaders

MiniMax H3 Remix v0.8 is FX_FeiHou's community checkpoint release for local H3 workflows. Its October 23 announcement describes a hierarchical merge with statically fused LoRA contributions. The useful starting question is which version and file to load, because the collection's general description discusses precision options that do not all belong to v0.8.

Documentation reviewed October 24, 2026.

Concept illustration of two film strips merging through a prism into one action sequence
Concept illustration of the Remix v0.8 workflow; not a software screenshot, model output or benchmark.

Select v0.8 by its version record

The current Civitai record identifies v0.8 as version 3423265, created October 22 at 23:47 UTC. The version description calls it an INT8 release aimed at dynamic footage and recommends the Remix Easy H3 secondary-sampling workflow.

Two v0.8 safetensors files appear: minimaxH3Remix_v08_3317933.safetensors, about 46 GiB by the listed size, and minimaxH3Remix_v08_3318096.safetensors, about 22 GiB. The same version also supplies three workflow JSON files. Size alone does not establish which transformer partition or component a file contains. Inspect the intended workflow's loaders before downloading or renaming a checkpoint.

The collection separately retains bf16 v0.6 and int8_convrot v0.6 (fixed). Those are older versions. Do not describe their files as BF16 v0.8 simply because the general collection page discusses BF16 and INT8 together. Preserve the version ID, file ID and any available checksum in your project notes.

Use the workflow as a component map

Open the author's collection on v0.8 and inspect its supplied JSON before running. A graph tells you more than a model nickname: which loader consumes each file, whether the operation uses frame or reference conditioning, and where sampling, decoding and export happen.

The collection places diffusion checkpoints in ComfyUI/models/diffusion_models. That does not supply every dependency. A complete H3 setup still needs a compatible text/vision encoder, video VAE, audio VAE and the nodes referenced by the chosen graph. Resolve missing-node and missing-model errors before changing the creative prompt.

At review time we could read the public file inventory, but the workflow download did not complete in our retrieval environment. We therefore do not assign undocumented roles to the two safetensors files or claim a verified v0.8 graph execution. Use the actual author-provided JSON as the final component authority.

Understand the Easy H3 node boundary

The FeiHou Easy H3 documentation describes a loader and a generation node with embedded media slots. Its reference mode accepts pictures, video and separate audio; its frame mode uses the initial picture slots for frame conditioning. The selected mode changes what the inputs mean.

Install the node pack into the correct ComfyUI environment, update ComfyUI to include native H3 support and restart it. The pack has its own node class names, so a similarly named upstream Easy node is not necessarily interchangeable. Use the matching saved workflow rather than constructing a chain from labels that merely look similar.

For the current pack, optional LoRA stacks enter the loader. The documentation also warns that its experimental low-memory block path should not be combined with a separate attention-backend patch. Establish a functioning baseline before enabling experimental memory changes; otherwise a crash has several competing explanations.

Resolve the acceleration settings deliberately

The collection's general recommendations list res_multistep, simple, eight to twelve steps and a Turbo LoRA strength of 0.75. Elsewhere it says LoRA contributions are already baked in and warns against adding matching weights again. These statements are not a complete, unambiguous recipe for every v0.8 graph.

Follow the selected v0.8 workflow's actual configuration, record it and avoid stacking additional acceleration adapters by habit. A merged checkpoint is different from a standalone LoRA that can be attached to any base. Our PTD guide explains another example of why step counts and loaders belong to a specific execution recipe.

The advertised 14 GB and 24 GB VRAM recommendations are not universal measured peaks. Resolution, references, offloading and decoder choices affect the full request. A smaller disk file also does not guarantee that it fits entirely in that much VRAM.

Optimized runtime and post-processing

Sol-H3 Studio includes generation orchestration. SoL-Refiner is the separate finishing component for an existing clip. Their installation requirements and timing boundaries differ.

Sol-H3 Studio: one-stage and two-stage runtimes

Sol-H3 Studio is a workspace inside ComfyUI for running an optimized MiniMax H3 engine on your own hardware. Its October 16 announcement highlights five-second videos with native audio in 35.5 seconds on an RTX 5090. That number belongs to a particular two-stage, already-loaded configuration. Choosing the correct pipeline matters as much as installing the interface.

Documentation reviewed October 18, 2026. Sources: NVlabs package.

Conceptual local video workstation with an eagle above an alpine lake and two processing layers
Concept illustration of the Sol-H3 Studio workflow; not a software screenshot, model output or benchmark.

Choose one stage or two stages

The one-stage route runs an eight-step HyperFlow adapter merged into an FP8 transformer, with an AdaLN lookup table, Sol-Attn, compilation, and an optional distilled video decoder. It supports text, first-frame conditioning, and reference-image requests at the documented 480p or 768p settings.

Two-stage generation first produces an H3 draft, then applies LTX refinement. The current Studio documentation limits this route to text at 768p. It is therefore a different production recipe, rather than a faster switch that preserves every one-stage input mode.

ChoiceUseful starting questionImportant boundary
One stageDo I need a starting frame or reference images?Reference generation needs a separate converted transformer
Two stagesCan a text-driven draft plus refinement solve my shot?Requires the separate H3/LTX package and its setup
Original baselineWhat does the comparison actually measure?Its encoder and runtime are specified, rather than an arbitrary untouched installation

The SoL-Refiner section explains the refinement component separately. HyperFlow explains the adapter's own loading contract. Neither component alone is the entire Studio deployment.

Prepare the runtime before the interface

The published RTX 5090 requirements include Linux, a 32GB card, at least 90GB host RAM, and ComfyUI 0.30 or newer. The runtime uses Python 3.12, PyTorch 2.12 with CUDA 13, Triton 3.7, FastVideo, and attention libraries built for the target architecture. These are package-specific requirements, not a promise that any 32GB system is ready.

The plugin runs the GPU engine in a separate Python process. Linking its folder into custom_nodes supplies the interface and bridge; it does not install all the model execution dependencies into a working runtime automatically.

The installation guide starts from this repository location:

git clone -b sol-engine https://github.com/NVlabs/Sana.git

Link models/minimax_h3/Sol-H3-ComfyUI into your ComfyUI custom-node directory. Prepare a paths file containing the runtime interpreters, FastVideo and attention checkouts, H3 model directory, Qwen checkpoint, and required supporting paths. Keep virtual-environment interpreter paths intact rather than resolving their symlinks.

Next, build the checkpoints for your chosen route. One-stage acceleration needs the merged FP8 transformer and schedule-specific AdaLN table; reference images require the corresponding transformer_ref conversion. The table builder checks against the official module, and an unsupported schedule fails instead of silently using an unrelated table. Two-stage users must prepare the separate RTX 5090 package and supply its paths file.

Run scripts/configure.py from the plugin directory with the options for the components you actually prepared. It validates checkpoint shards, writes configuration files, and prints the SOL_ENGINE_CONFIG setting. Export that setting before starting ComfyUI. The upstream guide provides the complete command; copying a large all-components example before preparing those files creates unnecessary missing-path failures.

Read the speed numbers with their clocks

The validation record separates request time from loading and warmup. Its headline two-stage result uses resident Qwen conditioning: four formal requests were approximately 35–36 seconds, with a median of 35.5 seconds. The package configuration that reloads Qwen for each request instead took about 90–91 seconds on that host.

The first two-stage session also incurred 881 seconds of loading and warmup. Persistent compilation caches help later sessions, but do not make that first preparation disappear. The one-stage eight-step profile reports a 67.2-second median in a different recorded session; CPU MP4 encoding load contributes to variation.

These observations suggest a useful evaluation plan: time startup, the first request, repeated requests, and mode switches separately. The reference-image path swaps checkpoints when changing between reference and text/first-frame modes. Its first response therefore answers a different latency question from several consecutive reference jobs.

SoL-Refiner: finish an existing H3 draft

SoL-Refiner is a separate refinement stage for a video that has already been generated. The H3-specific release takes an existing MiniMax H3 clip and a prompt, then performs one denoising step using an LTX-2.5-based refiner. It does not replace the upstream H3 generation job.

Documentation reviewed October 6, 2026.

Separate the paper from the H3 extension

The NVlabs overview distinguishes two versions. The original paper builds on LTX-2.3 Refiner. A subsequent extension uses LTX-2.5 for MiniMax H3 enhancement and acceleration, with its own entry point and checkpoint.

This distinction matters when downloading files or reading a benchmark. A result from the paper's LTX-2.3 experiments does not establish the same result for the later H3 implementation. Likewise, H3 is the draft generator, while LTX supplies the refinement backbone. They are separate roles in the pipeline.

The method combines training on low/high-quality pairs, reward-based post-training, and distillation into a one-step student. For a user choosing a workflow, the practical consequence is simpler: retain your draft and evaluate the refinement separately. A sharper output cannot demonstrate that the original generator followed the prompt more accurately.

What the released H3 path does

The H3-specific README describes one Transformer forward pass and one Euler update, without classifier-free guidance. Video conditioning, text encoding, upsampling, and decoding remain parts of the surrounding computation.

PropertyDocumented H3 implementation
InputsAn existing video and a text prompt
ModelSoL-Refiner-LTX-2.5-for-MiniMax-H3
Default delivered size1920 × 1080
Internal canvas1920 × 1088, center-cropped for delivery
Frame rateInput frame rate
Frame countTruncated to a count of the form 8k + 1
SoundNo audio in the exported result

The frame rule has a concrete editing consequence: 124 input frames become 121. At 24fps, losing three frames changes duration by one eighth of a second. If the clip must land precisely on a musical beat or spoken ending, account for that before inserting the refined result into your timeline.

The public project studies refinement up to 4K, but the released H3 CLI's documented default is 1080p. A gallery headline and a default command describe different things. Inspect the current code and supported configuration before planning a 4K production; use only the H3 implementation’s documented output settings.

Prepare an environment that matches the implementation

The H3 documentation reports testing on an H100 80GB, Python 3.12, PyTorch 2.9.1 with CUDA 12.6, and NATTEN 0.21.5. That identifies the authors' tested environment; it is not a published minimum-VRAM requirement or evidence of consumer-card speed.

Install the requirements from the H3 extension directory and select a NATTEN wheel matching the PyTorch/CUDA combination. Diffusers is pinned for the decoder APIs. Check those version relationships before treating an import error as a problem with the video itself.

The documented command accepts --model, --input, --prompt, --output, --seed, and --decoder-seed. Use the H3-specific checkpoint named above. Start from the current repository example and replace the video path, output path, and scene description. These are documentation-based setup directions, not a reproduced installation tutorial.

Preserve audio and measure the full job

Because the released output contains no audio, retain the source track and restore it in your editor after checking the refined duration. If frame truncation shortens the picture, decide whether to trim the soundtrack or adjust the edit. Do not assume that copying the original audio automatically preserves the intended ending.

Measure upstream generation, refiner loading, encoding, the refinement pass, decoding, and file export separately. A one-step sampler describes one part of execution. It does not mean the entire video takes one unit of time or that every machine becomes ten times faster.

The authors report three complete H100 runs producing 121-frame, 24fps, 1080p files with one refiner call each. Their controlled similarity checks support those sample validations; they do not establish pixel equality or universal quality parity. Those are project-reported checks, not H3Vid test results.

The CLI also uses CPU offload and tiled decoding, with 768-pixel tiles and a 512-pixel stride. The authors note that tiled and untiled decoding can differ. Record these settings with the checkpoint, seed and decoder seed. For the separate online enhancement route, see the MiniMax H3 Upscaler.

Local authoring and editing interfaces

InterfaceInstallation routeModes and practical limits
MaestroPinokio application on Windows/Linux with NVIDIA CUDAManual Studio and Director; experimental FastH3 modes have separate input limits
ComfyUI-MiniMaxH3-StudioExtension in an existing native-H3 ComfyUI installationFive authoring modes; media editing/assembly requires Windows x64
Mago LocalWindows desktop app connected to existing or managed ComfyUIGenerate and Transform are different workflows; cloud models remain separately available

Maestro and ComfyUI-MiniMaxH3-Studio

If you want a MiniMax H3 interface with less graph wiring, two community projects offer different starting points. Maestro is a broader local creative application launched through Pinokio. ComfyUI-MiniMaxH3-Studio adds a prompt, production, and editing sidebar to an existing ComfyUI installation.

Documentation reviewed October 23, 2026.

Concept illustration of a local video workspace with storyboard, timeline, and connected workflow panels
Concept illustration of the Maestro and ComfyUI-MiniMaxH3-Studio workflow; not a software screenshot, model output or benchmark.

Choose the workspace around your existing setup

QuestionMaestroComfyUI-MiniMaxH3-Studio
Starting pointA Pinokio-managed creative applicationAn extension inside ComfyUI
Main organizing ideaManual Studio, automated Director, and editingInspect a prompt, generate segments, then assemble
Existing H3 installation required?Managed downloads are availableNative H3 nodes, templates, and weights are prerequisites
Platform distinctionWindows or Linux with NVIDIA CUDA; no current macOS or AMD supportPrompt pipeline on Windows/Linux/WSL; media tools require Windows x64
First evaluationConfirm the selected H3 model and memory settingsConfirm host compatibility and App Mode readiness

Use the Maestro README and the exact Studio repository for current requirements. Several repositories use similar H3 Studio names. This section concerns rookiestar28's video-oriented extension, not a similarly named still-image studio.

Maestro: a separate local creative environment

Maestro combines image, video, and audio work with an editor and an LLM-assisted Director. Its documented installation route is Pinokio: find Maestro in Discover or import the repository URL, install, then start. Model downloads happen when requested. Default managed downloads do not require a Maestro or Hugging Face account; custom gated assets can have additional access requirements.

The published application minimum of 6GB VRAM and 16GB RAM is not a guarantee for every H3 workload. Treat it as an application entry point. Confirm the selected H3 checkpoint, resolution, duration, and available memory before deciding that a particular shot fits. Downloads and cached weights also need substantial disk space.

For a first attempt, use manual Studio so you can inspect inputs before trying a longer Director production. H3 reference support and acceleration options depend on the selected path. Leave optional optimizations out of your initial comparison, then change one setting at a time. Record whether your timing includes downloads or first-use compilation.

Maestro 3.2 adds explicit experimental FastH3 choices

Update, October 23: the author's v3.2 announcement and FastH3 guide now document separate FastH3 V2 and OmniRef paths. V2 is text-to-video with generated audio. To use OmniRef, choose References in Studio, open Manage models, and enable FastH3 OmniRef 8-Step (Experimental). The documented starting point is 480p, about 5.2 seconds, guidance 1, and eight steps.

OmniRef requires an image or video anchor, with ordered picture, video, and audio references. Its reference audio guides generated sound; an exact frozen soundtrack is not supported by that recipe. Start/end frames, continuation, Director, extra LoRAs, and ordinary H3 audio refinement are outside this OmniRef path. The application's broader capabilities should not be assumed to apply to every enabled model.

BF16, INT8, and FP8 are normal OmniRef format choices; the Blackwell QAD NVFP4 option is a separate trained variant. Download size alone is not a minimum VRAM requirement. The author's 4090 image-reference smoke test produced a decoded clip with audio, but neither it nor a single-layer kernel check proves a universal memory tier or near-real-time rendering on every card.

The release also improves soundtrack roles, draft history, and recovery when optional finishing fails. Those are application changes, not evidence that a video model now supports every audio-preservation operation. Keep accepted originals and inspect the saved take before applying another finishing pass. For the underlying files and device recipes, see FastH3 Omni setup.

ComfyUI Studio: keep the graph and simplify authoring

The Studio feature documentation describes a sidebar backed by 28 canvas nodes. It builds a plan, compiled prompt, and validation report from the request. App Mode places the appropriate official H3 workflow on the canvas or connects to an existing graph. It does not install the H3 models for you.

Its five modes correspond to text-only generation, an opening image, first and last images, an ending image, or a multimodal reference set. Reference roles matter: an ending frame defines a destination, while a character reference guides appearance. For this sidebar's reference-set mode, the README specifies at most one image, one video, and one audio reference; audio alone is unavailable. Do not assume every interface exposes the model family's maximum input counts.

The extension is independent of MiniMax's official Context-IR implementation. Prompt validation can identify missing roles or conflicting instructions. It cannot certify that the generated movement, identity, or dialogue will be correct.

A documentation-based first-clip route

For Studio, the maintained installation instructions are to stop ComfyUI, clone the complete repository under custom_nodes, then restart. Keep the root initializer and the implementation folder together. The browser extension is prebuilt. The host must already supply native H3 nodes, workflow templates, and sidebar support.

Then follow this small evaluation sequence:

  1. Open the MiniMax H3 Studio sidebar and choose a mode in Context.
  2. Describe one short shot, choose a supported duration, and add the required media.
  3. Inspect the plan and validation messages. Put exact dialogue in hard constraints.
  4. Start H3 App Mode, review the canvas model selections, and queue the workflow.
  5. Inspect the actual output in Production before opening the editor.

For example, start with a person turning toward a window, with a fixed camera and no dialogue. Once that succeeds, add a short spoken line or a reference video. This is a suggested evaluation scene, not a tested prompt or quality guarantee. The native setup explains the underlying local setup.

Editing and longer-video limits affect the choice

Studio's limitations are especially relevant to Linux users: clip editing, import, assembly, and rendering require Windows x64 and the designated media tools. Its longer-video planner covers 4–60 seconds by generating and joining segments; that is not a single unlimited-duration inference.

Editor work lasts while ComfyUI runs, rather than becoming a durable saved project. Download finished videos and save workflows. The documentation also distinguishes assembly at 30fps from editor rendering at 24fps. Check the exported file's timing, sound, and cuts instead of judging an approximate preview alone.

Maestro provides a different production environment, but interface convenience still cannot guarantee continuity across generated shots. Use the same source assets and a short acceptance checklist when evaluating either application: correct input roles, expected dimensions, usable motion, intelligible audio, and a recoverable saved configuration.

Mago Local: Generate, Transform and export

Mago Local packages a film-production interface around generation and editing tools, with the option to render through your own ComfyUI installation. Its official download page lists Windows, an NVIDIA GPU with at least 16GB VRAM, and 60GB free disk space. Local renders do not consume Mago credits; cloud models remain available separately.

Documentation reviewed October 18, 2026.

What changes when Mago runs locally?

The official download page describes two useful arrangements: connect an existing ComfyUI server, or let Mago set one up. Your GPU performs local rendering, and your footage can remain on your machine. That does not imply every operation in an account becomes local: cloud model choices still have their own execution and billing behavior.

The practical distinction is ownership of the execution environment. With an existing installation, record its ComfyUI version, available models, custom nodes, GPU driver, and working workflow before connecting another interface. With a new installation, reserve room beyond the advertised download requirement for checkpoints, caches, source footage, and render versions.

Treat the 16GB minimum as an application entry requirement. It does not establish that every H3 resolution, reference count, or long sequence fits without offloading. The team member's approximately 3.5-minute ten-second RTX 5090 example is a configuration-specific statement, not a speed guarantee for the minimum card.

Separate Generate from Transform

Mago's official product overview describes Generate for making footage from ideas, scripts, stills, or references, and Transform for restyling existing footage. Those operations solve different starting problems. A new narrative scene needs characters and shot planning; a restyle starts with motion and timing already present in source footage.

The website describes long-form generation as alpha. It should be evaluated as an evolving production feature, including how approved characters, locations, and props carry across shots. Do not assume a finished-film marketing description guarantees that every desktop model and every export format supports the same path.

For a first project, choose one of two concrete goals: animate one approved character reference, or restyle one short source shot while retaining its timing. Avoid combining a new script, many characters, a long timeline, and a new backend in the same initial experiment. A smaller goal makes failed handoffs easier to locate.

The official getting-started guide follows a source-video route: create a project, upload a shot, validate an appearance in Modify Frame, render, compare and export. Its cloud-oriented buttons and model choices do not establish identical controls in desktop H3. Use the guide after checking the selected desktop mode. Split source footage at camera cuts or changes in location and lighting so each shot can have its own reference and prompt.

Check the handoff to your editor

Mago's export documentation describes per-track delivery and external finishing. It lists MP4 downloads and image-sequence options; its 16-bit EXR instructions apply specifically to Mago Transform and Mago Style Transfer. That is not evidence that local H3 generation exports equivalent high-dynamic-range source data.

Confirm the actual file you receive: frame size, frame rate, audio tracks, duration, and color interpretation in your editor. Also check whether you are exporting an individual render, a comparison, or an assembled sequence. A preview timeline and a final deliverable are separate acceptance points.

For example, a three-shot character scene is only ready for finishing when the exported shots retain their order, match the intended timing, and contain the expected audio. A visually convincing preview cannot answer whether an editor will interpret the files correctly.

Evaluate cost with the whole production in view

Local rendering avoids Mago render credits for those jobs, but still uses electricity, storage, and hardware time. A rented remote ComfyUI server has rental charges even if the interface calls that generation local. Keep those costs separate from any optional cloud model credits.

Record successful and rejected takes, not just the fastest accepted clip. For a real production, the useful measure is time to an accepted shot, including revisions and export. We have not benchmarked Mago or verified its consistency claims independently.

Choose Mago Local when your question concerns project organization and a desktop production interface around your GPU. The existing Maestro and ComfyUI Studio comparison covers other interfaces; the native setup covers the underlying graph workflow. H3Vid's hosted generator does not run Mago's desktop project system.

Apple Silicon: macOS and Linux routes

These alternatives are not native ComfyUI installation recipes. H3cApp targets macOS with Metal/MPSGraph; the Omarchy port targets Linux with Honeykrisp Vulkan and a pinned runtime.

H3cApp: native macOS on Apple Silicon

H3cApp offers a native macOS interface for running MiniMax H3 locally on Apple Silicon. Author Junzo Kamahara introduced the app on October 9, 2026 in Japan, describing use on a 24GB M5 Mac. The public repository and v0.4.4 release provide a concrete distribution route rather than only a social-media demo.

Documentation reviewed October 9, 2026.

Concept illustration for H3cApp: native macOS on Apple Silicon
Concept illustration of the H3cApp workflow; not a software screenshot, model output or benchmark.

What H3cApp changes

The project wraps a fork of antirez’s h3.c inference engine in a native interface. Its documentation describes local Metal/MPSGraph computation and native media handling, avoiding a separate Python inference environment. That can make the first interaction easier, but the model still needs substantial storage and computation.

Use the app if the question is “Can I create short H3 clips on my Apple Silicon Mac?” A cloud generator answers a different question: where to submit a job without maintaining a local model installation. Neither access route by itself establishes better image quality.

For other local interfaces, compare the different platform requirements of Maestro and ComfyUI Studio.

Check the operating system and storage first

The current README requires Apple Silicon and macOS 15 or later. It distinguishes M5-class acceleration paths from fallbacks on older chips. Do not read an M5 timing as a promise for every M-series laptop.

Check free disk space before opening the model downloader. The README estimates about 134 GiB for FL2VA and about 268 GiB when Ref2VA is also installed. The launch article gives different approximate totals, so use the current downloader and selected files to confirm your actual requirement. Additional caches require more room.

Memory capacity and checkpoint size are different constraints. A machine can stream weights from storage without holding the entire checkpoint in RAM, but this does not make storage irrelevant. Keep the files on a drive with enough room for models, caches, generated clips, and working copies.

Before changing your system, write down the chip, unified memory, macOS version, available disk space, and intended output size. This short record will make a slow or failed test easier to diagnose than simply reporting “a Mac.”

Install from the project’s release page

The documented installation route is the prebuilt DMG: download it from the project’s Releases page, open it, and move the app to Applications. The README describes the distributed app as signed and notarized; we have not independently checked a downloaded binary.

On first launch, register existing model files or use the built-in model manager. Begin with the model family needed for your first task. Downloading every available variant before deciding whether you need reference conditioning adds avoidable setup work.

Read the selected weights’ license separately from the app’s code license. Permission to use or redistribute an application does not automatically extend to every model it can load. If a download is interrupted, verify its completed state in the manager before treating a generation error as a GPU problem.

For an initial H3cApp run, use a five-second text-to-video clip at a modest resolution. Save the compute mode and speed mode along with the seed, dimensions, duration and step count. Check the exported video and requested audio before adding a first/last frame or mixed references. Those app-specific mode selections are needed to interpret the timing below.

Read speed measurements in their full context

Kamahara’s launch article reports a 512×512, 15-second result taking about 9 minutes 25 seconds in its fastest configuration on an M5 with 24GB memory. Each condition was measured once while other applications were running. This is an author-reported example, not a controlled cross-model ranking or a measurement from H3Vid.

A useful personal comparison repeats the same input and seed at the same dimensions. Record whether model loading and cache preparation are included, then compare output quality as well as wall-clock time. Separate the first run from subsequent runs; a cached trial can answer a different question from a fresh launch.

Do not combine a smaller frame, fewer steps, and a different speed mode into one “faster” claim. The resulting clip may solve a different production problem. A low-resolution draft can be useful even when it cannot replace a finished shot.

Add references and automation gradually

The documented app supports first/last-frame conditioning and mixed references, but reference inputs have their own memory cost. Start with one short, relevant reference and increase complexity after measuring it. Verify that the subject, motion, and soundtrack behave as intended; a reference is guidance rather than an identity lock.

The README also documents a localhost JSON API, including job status and result retrieval. That offers a possible route for a local batch workflow, but a loopback interface is not a hosted cloud endpoint for H3Vid. Stabilize a single interactive job before automating many requests.

Your next step is practical: confirm the release requirements, reserve storage, download only the needed model family, and retain one reproducible small test. If you need a separate accelerated H3 model comparison, read the FastH3 V2 and Trim explanation. Its measurements and execution stack should remain distinct from H3cApp’s Mac results.

Omarchy: Linux on 96GB Apple Silicon

MiniMax H3 now has a documented end-to-end video generation route on Linux running on Apple Silicon. Joshua Warren's Omarchy port combines an int8 H3 model bundle, a patched TensorFold engine and omarchy-mlx using Honeykrisp's Vulkan backend. It is a specific Linux hardware and software configuration, rather than a general claim that ordinary MLX packages run H3 on every Linux computer.

Documentation reviewed October 10, 2026. Sources: model bundle, installation and rendering guide.

Linux on Apple Silicon is the important distinction

Apple Silicon names the hardware; macOS and Linux are different operating-system routes on that hardware. The documented Omarchy pipeline uses Vulkan through Honeykrisp, while the macOS TensorFold Studio route describes Metal and MLX or a native FastH3 engine. Their compatible wheels, kernels and measured timings are different.

The Omarchy bundle contains a derivative of the base MiniMax H3 model. It does not identify its sample as FastH3 V2 or H3 Max. A performance result from one of those models cannot be substituted for the Linux sample's measurements. If your actual goal is a native macOS interface, see H3cApp rather than installing a Linux-specific wheel into that environment.

Check memory and storage before downloading

The author's guide requires 96GB of unified memory. It reports that loading the compact text tower fails on a 64GB M1 Max. That is a concrete boundary for the documented route, even though a later stage reports a smaller allocation figure.

The bundle includes approximately 44GB of int8 diffusion-transformer shards and a 50.3GB text-tower export, plus video and audio VAEs. The text encoder is loaded during preparation; the transformer and decoder matter at later stages. Looking only at one stage's reported peak can hide the component that prevents the full pipeline from starting.

The guide estimates about 160GB free storage before downloading. Its model files total roughly 101GB, while reconstruction of a large download can require substantial temporary cache space. Optional denoising checkpoints add more storage. Do not interpret the final directory size as the maximum free space needed during setup.

The runtime depends on pinned components

The guide specifies Omarchy Linux on Apple Silicon, the linux-aurora kernel and Honeykrisp Vulkan support. It also specifies an omarchy-mlx build exposing mx.fast.int8_matmul, a pinned TensorFold fork and a separate minimax-h3-mlx checkout for text loading, audio decoding and media writing.

Six local engine patches are part of that recipe. They cover kernel dispatch, int8 loading, reduced-memory tables, sampler checkpoint recovery and chunked video-VAE attention. The guide distinguishes those patches from an older pair in the same directory. Applying every patch you find indiscriminately is not equivalent to following the documented pin.

The wheel installation order matters too. The guide warns that a later installation of the standard mlx package can overwrite the custom implementation because they share an import name. Its verification step checks whether the imported module actually exposes the required int8 operation. Successful package installation alone is therefore insufficient proof that the right runtime is active.

These details make the original guide the right place for executable commands. Preserve its current revision and the specified engine commits in your setup notes; the requirements here come from the author’s installation record.

What the published sample demonstrates

The model card describes one 768×448 sample with 56 frames, 24fps and stereo audio, approximately 2.3 seconds long. The scene is a slow camera movement across a dark desk. It is evidence of a reported end-to-end pipeline, not a comprehensive comparison of motion quality or all reference modes.

The model card lists two development-wheel runs. One took about 90.3 minutes in total; the other lists about 63.2 minutes total and 58.7 minutes for inference alone. The separate fresh-clone guide reports 58 minutes 44 seconds from text encoding through the muxed clip. These are different recorded runs and timing boundaries, not interchangeable numbers.

In particular, “58 minutes” does not mean a five-second clip takes 58 seconds. The demonstrated output is a short clip whose wall time is measured in minutes. Do not compare it with a macOS Studio headline or a consumer-GPU FastH3 result without matching output duration, geometry, model, steps and timing scope.

Use the sample hash within its stated scope

The author provides a SHA-256 for the sample and reports reproduction on the same chip family, wheel and seed. That offers a concrete check for that exact setup. It does not establish that different chips or runtime versions should produce the same bytes.

If you follow the author's recipe on matching hardware, record the wheel identifier, model revision, seed and engine pins before comparing the resulting file. On another chip family, a hash mismatch alone cannot describe the visible quality difference. Compare the actual frames and listen to the audio, while keeping track of which configuration changed.

For a first local evaluation, use the documented small sample rather than immediately increasing duration or resolution. Confirm that text encoding completes, denoising progresses, both VAEs decode, and the final video plays with sound. These are proposed acceptance checks; we have not performed them on Omarchy hardware.

Cloud GPU route

The following workflow uses a remote Colab GPU. Preparing media and submitting from a local terminal does not make inference local.

Colab: remote GPU, ordered references and session cleanup

MiniMax H3 can run on a Google Colab GPU while your local computer prepares reference pictures, sends jobs, and downloads the resulting MP4. A local command line does not mean local inference: the GPU, model weights, and generation remain in the remote runtime.

Documentation reviewed October 16, 2026. Sources: community Colab runner, bundled notebook, runner source.

Concept illustration of a local laptop connected to a remote GPU and an autumn reference-video scene
Concept illustration of the Colab workflow; not a software screenshot, model output or benchmark.

Choose a route and inspect its dependencies

The bundled notebook has two modes. Its browser-oriented default uses FL2VA with a first image. The local launcher switches to Ref2VA for one to nine semantic reference pictures. Those are different conditioning paths; sending several files to a first-frame graph does not make them ordered character references.

The notebook selects compatible INT8, FP8, or BF16 weights based on CUDA and GPU capability and pairs the reference model with its own acceleration adapter. It also needs a text encoder and both video and audio VAEs. Its guidance asks for substantial free disk space: roughly sixty GiB, or eighty GiB for the BF16 reference fallback. Check the actual runtime before downloading.

The MiniMax model card and its license remain relevant even when a community notebook automates installation. Colab access does not change model-use conditions. Verify eligibility for your intended use and deployment region against the current upstream terms before allocating compute.

Prepare the local command line

The runner requires Python 3.11 or newer, while the documented current Colab CLI installation uses Python 3.12. These requirements refer to different programs. An existing local Python environment for the runner need not be replaced simply to install the CLI as an isolated tool.

Clone the community repository and review its README and notebook. The documented installation uses uv to install Python 3.12 and google-colab-cli, then checks colab version. Run the CLI's OAuth usage command interactively for initial authentication and inspect the account's compute balance. The runner defaults to OAuth2 and has an explicit alternative for existing ADC setups.

The repository's skill installer is optional when using its shell launcher directly. It copies the files needed by that named skill; it does not perform GPU inference during installation. If you use the installed skill, keep its runner and notebook together so they remain compatible.

Define reference order before writing the prompt

Choose one or two clear images first. Their argument order becomes Picture 1, Picture 2, and so on; the runner validates that the prompt does not reference a picture number you did not upload. Those labels identify visual content, not timestamps in the final clip.

Write a UTF-8 prompt file that names each subject and gives one manageable action. For example, identify the traveler in Picture 1 and the companion in Picture 2, then describe them walking through an autumn market in one continuous shot. State the camera movement and desired sound. This is an original planning example, not a tested result.

When writing the actual prompt, follow the official Ref2VA guide. It provides the reference syntax and prompt structure. Keep the image order unchanged when revising words so you can interpret the next result.

Submit one short job

From the reviewed community checkout, the launcher accepts repeated image flags, a prompt path, and an output path:

H3_DURATION_SECONDS=5 ./run_colab_inference.sh \
  --image /absolute/path/traveler.png \
  --image /absolute/path/companion.jpg \
  --prompt /absolute/path/prompt.txt \
  --output /absolute/path/market.mp4

These are example paths to replace, not files supplied by H3Vid. The launcher requests an A100 high-memory runtime by default. Availability depends on the account, balance, plan, and current capacity; a free T4 is not an equivalent promise. The notebook recommends five to fifteen seconds even though its accepted boundary starts at four.

Requested seconds can also differ from encoded duration because H3 aligns frame geometry. Inspect the actual media rather than assuming a five-second request is exactly five seconds. Record the selected checkpoint variant and GPU with the result so later timing comparisons have context.

Batch without losing completed work

For several clips, create the documented job manifest and use scripts/runner.py batch. Each job can supply ordered images, a prompt file or inline prompt, duration, and output name. A single session avoids repeatedly allocating a GPU and loading the same models.

The runner records progress and preserves completed outputs if a later job fails. Sessions it creates are stopped in cleanup, including error paths; reusing a named existing session has different ownership, so use the explicit stop-on-complete option when appropriate. Inspect progress and remote state before rerunning a timed-out batch, since an uncertain local outcome does not prove the remote kernel stopped.

Check that the downloaded MP4 exists and contains the expected video and audio. The optional ffprobe check can verify streams; watching and listening verifies the actual scene. Download your selected files and logs before ending the runtime, then confirm no active assignment remains through the CLI.

A community report from October 12 describes one A100 setup and generation session. Its timings are one user's evidence, not a service-level expectation or proof that this separate runner has identical performance. For a hosted creative task without managing a Colab runtime, see H3 Ref2VA. For desktop preparation, return to the native setup.

Compare a local optimization once the base graph works

Keep the checkpoint revision, mode, references and their order, prompt, seed, dimensions, frame count, sampler, schedule and adapter weights with the exported MP4. Add the selected attention predictor or gate, precision, decoder and software versions. Those records make a component-specific failure reproducible.

Time model loading and compilation separately from repeated warm requests. Where possible, record text/reference encoding, sampling, video decoding, audio decoding and export as well as total wall-clock time. A denoising-only benchmark cannot establish the time from opening an app to receiving a finished clip.

Compare a quiet shot, a moving subject and a reference-driven interaction. Watch the entire output and matched frames for identity, small features, hand-object contact, scene continuity and moving edges. Listen for distortion, intelligibility and action/sound synchronization. Keep rejected outputs with successful ones; then change one component before repeating the comparison.

For a failure report, include the exact missing filename or node, dependency versions, chosen backend and full error. If only a longer or larger job fails, include both configurations. A missing compiled kernel, an unsupported model/predictor pairing and a memory-capacity problem require different fixes.

Fix common MiniMax H3 ComfyUI problems

The template or native node is missing

Update ComfyUI first. Some native H3 features appear in newer builds before they reach every Desktop or Cloud stable release. Do not install an unrelated custom node solely because an old build cannot find the official node.

The workflow cannot find a model

Check the file category, folder, and exact filename. The diffusion model belongs in diffusion_models, the Qwen text encoder in text_encoders, both VAEs in vae, and turbo files in loras. Restart or rescan after adding files.

Generation exits with an out-of-memory error

Return to the official template, lower resolution, shorten the clip, reduce references, and unload other models. Once the base graph succeeds, add optional components individually. Do not assume a low-step LoRA alone will solve a graph whose latent tensors exceed available memory.

R2V ignores a reference

Confirm that you loaded the Ref2VA diffusion model. Refer to media in its connection order and say what each item controls. The official workflow's match reference-size option favors speed, while max preserves more reference detail at additional cost.

Video renders but audio is missing or weak

Confirm that the audio VAE is present and connected. Then describe audible events in the prompt: who speaks, what the environment sounds like, which effects align with the action, and whether music should be present.

A graph reports a shape mismatch after changing modes

Do not reuse FL2VA-specific components inside a Ref2VA graph without verifying compatibility. Reload the official template for the intended mode and move your prompt or references into that clean graph.

Advanced native workflows worth adding later

Once the base setup is stable, current native nodes support more controlled workflows. MiniMaxH3AddGuide can anchor an image, video clip, or audio guide at a chosen frame instead of limiting guidance to the first and last frames. Per-token noise masks can also regenerate or extend selected video and audio regions while retaining the rest.

These features are useful for controlled transitions, continuation, partial regeneration, and longer sequences, but they should come after a successful base T2V, I2V, or R2V test. Update ComfyUI and start from the official advanced templates because node inputs can change as support evolves.

Local ComfyUI or an online MiniMax H3 generator?

Choose local ComfyUI when you need graph-level control, repeatable node experiments, local model files, optional LoRAs, or a workflow you can inspect and modify. Choose an online generator when you want to create without downloading large weights, maintaining nodes, or fitting the graph into local VRAM.

H3Vid does not run your local ComfyUI graph or host custom nodes. It provides a separate online MiniMax H3 workflow for text, frame-guided, and reference-based generation. That makes it a practical fallback for testing an idea before investing time in a local setup.

MiniMax H3 ComfyUI FAQ

Is MiniMax H3 officially supported in ComfyUI?

Yes. ComfyUI provides native MiniMax H3 nodes and official templates for T2V, I2V, and R2V workflows. Update ComfyUI if they do not appear in your installation.

Do I need custom nodes for the base workflows?

No. The base workflows described here use native ComfyUI support. Third-party custom nodes may add optimizations or specialized controls, but they are not the best first step for verifying an installation.

How much VRAM does MiniMax H3 need in ComfyUI?

There is no single official minimum that covers every workflow and GPU. Resolution, duration, precision, references, loaded nodes, and software versions all affect memory use. Begin with the optimized official template at 768p and a short clip, then scale one variable at a time.

Which model should I download for MiniMax H3 ComfyUI?

Use the FL2VA diffusion model for text-to-video and image-to-video. Use the separate Ref2VA diffusion model for reference-to-video. Both need the H3 text encoder plus video and audio VAEs.

Can MiniMax H3 generate audio in ComfyUI?

Yes. The native workflows generate synchronized video and audio when the audio VAE is installed and the workflow is connected correctly. Include dialogue, ambience, effects, or music in the prompt when they matter.

Can I run MiniMax H3 without downloading local models?

ComfyUI Partner Nodes and online generators use hosted inference rather than the native local-weight path. If you do not need a node graph, the simplest option is to try MiniMax H3 online.