MiniMax H3 Quantized Version Local Deployment in Practice: ComfyUI Startup with Troubleshooting Log

Honestly, when MiniMax [H3](MiniMax-H3 · Model Library) was first released a couple of days ago, what really caught my eye wasn't the parameter table, but its ability to generate video and stereo audio in one go. The first time I actually ran a 5-15 second video in ComfyUI and saw the visuals, ambient sound, and rhythm come out together, the feeling was very direct: this time it's not just "able to generate video," but it genuinely has a bit of a produced feel! And being able to achieve this effect with a local deployment is truly surprising. Compared to the previous LTX 2.3 and Wan, the results are much better. I personally feel it's currently only slightly behind Seedance, especially since this doesn't require Seedance's high usage costs~

Excitement aside, actually moving the model to a local server still involves a series of very practical problems: which weights exactly should be downloaded? Which torch version, which cuda version, and what is the relationship between them? After the model runs successfully, how do you keep ComfyUI stable and persistent? If these issues aren't sorted out in advance, it's easy to get bogged down shuffling between hundreds of GB of weights and different CUDA versions.

This article records the entire process of this landing. The server has two RTX 4090s, but this article only specifies physical GPU1 to run ComfyUI, and does not discuss services on the other card. From the virtual environment, quantized weights and model paths, to the three workflows of T2V, I2V, R2V, and systemd hosting, everything is organized according to the actual execution sequence, and the commands can be followed directly.

This article only installs the CUDA Runtime required to run MiniMax H3. The basic deployment does not need the system CUDA Toolkit, nor does it require nvcc; source code compilation of SageAttention needs it, and related content is placed in the second article of the series on using SageAttention.

Standalone lines starting with # in code blocks are descriptive comments, which are ignored when read by Bash, .env, and systemd, and can be copied along with the commands. Do not move comments to the end of continuation lines ending with \.

1. Tested Environment and Deployment Structure

The environment in this article is not a minimum configuration, but a real operating environment.

Item	Tested Configuration
Operating System	Ubuntu 24.04 amd64
System Memory	48GB
GPU	2 × NVIDIA GeForce RTX 4090 48GB (This article uses physical GPU1)
NVIDIA Driver	580.126.09
CUDA Version shown by nvidia-smi	13.0
Python	3.12.13
PyTorch	2.13.0+cu130
ComfyUI	0.30.0
comfy-kitchen	0.2.26
comfy-aimdo	0.4.11

The directory structure after deployment is as follows:

 /home/your-user/projects/comfyui-minimax-h3/
 ├── .venv/
 ├── .env
 ├── app/                         # ComfyUI 0.30.0
 │   └── extra_model_paths.yaml
 └── start-comfyui-h3.sh
 
 /data/models/hf/MiniMax-H3-Comfy/
 ├── diffusion_models/
 ├── text_encoders/
 └── vae/

This article only exposes physical GPU1 to ComfyUI via CUDA_VISIBLE_DEVICES=1. The process internally renumbers the only visible card as logical cuda:0, so it is normal for logs to show cuda:0; nvidia-smi on the host will still show the task located on physical GPU1.

2. Install Basic Tools and Create ComfyUI Environment

First, install basic dependencies:

 # Refresh Ubuntu package index
 sudo apt-get update
 
 # Install download, session, and video processing dependencies
 sudo apt-get install -y \
   git curl wget ca-certificates tmux \
   ffmpeg libgl1 libglib2.0-0

Besides Git and download tools, ffmpeg is used for video-related processing, and libgl1, libglib2.0-0 prevent some image/video dependencies from missing runtime libraries on headless servers.

After installing uv, create the project:

 # Install uv, and make the current Shell recognize uv immediately
 curl -LsSf https://astral.sh/uv/install.sh | sh
 source "$HOME/.local/bin/env"
 
 # Create an independent project directory
 mkdir -p /home/your-user/projects/comfyui-minimax-h3
 cd /home/your-user/projects/comfyui-minimax-h3
 
 # Pin ComfyUI version to avoid dependency changes from future main branch updates
 git clone \
   --branch v0.30.0 \
   --depth 1 \
   https://github.com/Comfy-Org/ComfyUI.git \
   app
 
 # Use uv to install Python 3.12 and create a project virtual environment
 uv python install 3.12
 uv venv --python 3.12 --seed .venv
 source .venv/bin/activate
 
 # Check Python and ComfyUI versions
 python --version
 git -C app describe --tags --always

Seeing detached HEAD when cloning is a normal prompt when checking out by tag. The deployment environment should stay on a verified version; there is no need to develop or commit directly in this directory.

Then confirm that the ComfyUI tag, uv-managed Python version, and virtual environment are all correct:

Place models, caches, and generation directories on /data to avoid filling up the project disk:

 # Create directories for models, caches, and generated files
 sudo mkdir -p \
   /data/models/hf/MiniMax-H3-Comfy \
   /data/cache/modelscope \
   /data/cache/huggingface \
   /data/comfyui-h3/input \
   /data/comfyui-h3/output \
   /data/comfyui-h3/temp
 
 # Transfer directory ownership to the currently logged-in user
 sudo chown -R "$(id -un):$(id -gn)" \
   /data/models/hf/MiniMax-H3-Comfy \
   /data/cache/modelscope \
   /data/cache/huggingface \
   /data/comfyui-h3

3. Install PyTorch cu130 and ComfyUI Dependencies

The PyTorch wheel comes with its own CUDA Runtime, so this step does not need /usr/local/cuda-13.0, nor does it need to execute nvcc --version.

 cd /home/your-user/projects/comfyui-minimax-h3
 source .venv/bin/activate
 
 # Install fixed versions from the official PyTorch cu130 index
 uv pip install \
   "torch==2.13.0" \
   "torchvision==0.28.0" \
   "torchaudio==2.11.0" \
   --index-url https://download.pytorch.org/whl/cu130
 
 # Install ComfyUI's own dependencies
 uv pip install -r app/requirements.txt

What is fixed here is the combination already verified in this article: PyTorch 2.13.0+cu130, TorchVision 0.28.0+cu130, and TorchAudio 2.11.0+cu130. If any one of these components is upgraded in the future, the CUDA, matrix, and audio dependency verification in this section should be re-executed. Do not just overwrite the production environment because the version number is newer.

Why choose cu130 here, instead of the newer cu132 or CUDA 13.3

"Driver version," "CUDA Runtime used by the PyTorch wheel," and "System CUDA Toolkit" are three related but not equivalent versions. The on-site driver in this article is 580.126.09, and PyTorch uses the official cu130 wheel; this combination has already completed verification for MiniMax H3 native workflows and subsequent SageAttention source code compilation.

According to the Toolkit/Driver compatibility table in the NVIDIA CUDA 13.3 Release Notes, the minimum drivers for direct matching of each version on Linux are as follows:

CUDA Toolkit	Minimum Linux Driver for Corresponding Version
13.0 GA / Update 1 / Update 2	580.65.06 / 580.82.07 / 580.95.05
13.1 GA / Update 1	590.44.01 / 590.48.01
13.2 GA / Update 1	595.45.04 / 595.58.03
13.3 GA / Update 1	610.43.02

Therefore, 580.126.09 meets the direct driver requirement for CUDA 13.0 Update 2, but does not meet the direct matching version for the Toolkits corresponding to CUDA 13.1~13.3. CUDA 13.x also has Minor Version Compatibility within the same major version, but older drivers may not provide all features of the new Toolkit. "The minimum compatible driver is 580" should not be understood as being able to unconditionally mix and match any 13.x components.

The fact that PyTorch officially provides cu132 wheels does not mean the current environment must be upgraded; even less should one assume that existing drivers, PyTorch wheels, and third-party CUDA extensions will automatically form a compatible combination just because CUDA Toolkit 13.3 is updated. The production environment should simultaneously check:

1. Whether the NVIDIA driver meets the requirements of the target Toolkit/Runtime;
2. Whether PyTorch provides an official wheel for the target CUDA version;
3. Whether source extensions like SageAttention support the target GPU architecture and Toolkit;
4. Whether existing workflows have completed regression verification.

This article keeps cu130 to reduce variables and reuse the already verified combination, not because the updated version itself is unusable.

When downloading and installing CUDA Runtime and PyTorch wheels, uv will display the download progress of various NVIDIA components:

After installation, you can check torch==2.13.0+cu130, torchvision==0.28.0+cu130, and related CUDA 13 runtime libraries in the list:

Next, install ComfyUI 0.30.0's own dependencies, including the frontend, workflow templates, comfy-kitchen, comfy-aimdo, and video processing components:

(Optional) Execute verification on the physical GPU1 used in this article:

 # Only expose physical GPU1 to the verification process
 CUDA_VISIBLE_DEVICES=1 python - <<'PY'
 import torch
 import torchvision
 import torchaudio
 
 print("PyTorch:", torch.__version__)
 print("TorchVision:", torchvision.__version__)
 print("TorchAudio:", torchaudio.__version__)
 print("PyTorch CUDA:", torch.version.cuda)
 print("CUDA available:", torch.cuda.is_available())
 
 if not torch.cuda.is_available():
     raise SystemExit("CUDA is not available")
 
 # Check GPU name and Compute Capability
 print("GPU:", torch.cuda.get_device_name(0))
 print("Compute capability:", torch.cuda.get_device_capability(0))
 
 # Execute an actual CUDA matrix calculation, not just check boolean status
 x = torch.randn((1024, 1024), device="cuda", dtype=torch.float16)
 print("Matrix calculation:", (x @ x).shape)
 PY

4. Only Download the Quantized Weights Needed for the Three Types of Workflows

The MiniMax H3 repository contains weights of multiple precisions and duplicate purposes simultaneously. At the time, the complete repository was close to 395GB, while the quantized combination required for the three official workflows is about 63.44GB. Files are explicitly specified here to avoid mistakenly downloading the full snapshot.

File	Purpose	Approx. Space
minimax_h3_fl2va_pruned_int8_convrot.safetensors	T2V, I2V, First/Last Frame Video	20.97GB
minimax_h3_ref2va_pruned_int8_convrot.safetensors	Image/Video/Audio Reference Generation	20.97GB
qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors	Multimodal Text Encoder	15.69GB
minimax_h3_video_vae_fp16.safetensors	Video VAE	5.21GB
minimax_h3_audio_vae_fp32.safetensors	Audio VAE	0.61GB

Install the ModelScope Hub client:

 cd /home/your-user/projects/comfyui-minimax-h3
 source .venv/bin/activate
 
 # Pin the ModelScope Hub client version verified in this article
 uv pip install "modelscope-hub==0.1.8" huggingface_hub

This article pins the use of 0.1.8. The console entry points published to PyPI for this version are ms and modelscope, and it is recommended to preferentially use the short command ms:

 # Confirm the ms entry and version provided by 0.1.8
 command -v ms
 ms -V
 ms --help

modelscope is the second entry provided by the same version, but it may have command name conflicts with the full modelscope framework package. This article only installs the lightweight modelscope-hub client and uniformly uses ms to avoid mixing up the package name, Python module name, and CLI name.

If ms is still not found, you can confirm the virtual environment in the following order and use the Python module entry as a fallback:

 # Confirm you are currently in the project virtual environment
 echo "$VIRTUAL_ENV"
 
 # Check the two available console entry points
 command -v ms || true
 command -v modelscope || true
 ls -l "$VIRTUAL_ENV/bin/ms" "$VIRTUAL_ENV/bin/modelscope" 2>/dev/null || true
 
 # Check installed files, and test the module method that does not rely on entry scripts
 uv pip show -f modelscope-hub
 python -m modelscope_hub.cli.main --help

As long as ms --help or the last Python module command can output help, the SDK is already available. Only when it is confirmed that .venv/bin/ms is indeed missing, should you execute uv pip install --reinstall "modelscope-hub==0.1.8" in the activated virtual environment; there is no need to rebuild the entire ComfyUI environment.

modelscope 0.18 version ms command

modelscope 0.19 and above version ms-hub command

Download the five required weights and README:

 cd /home/your-user/projects/comfyui-minimax-h3
 source .venv/bin/activate
 
 # Point to ModelScope domestic site, and configure cache and large file download retries
 export MODELSCOPE_ENDPOINT=https://modelscope.cn
 export MODELSCOPE_CACHE=/data/cache/modelscope
 export MODELSCOPE_DOWNLOAD_PARALLEL_WORKERS=4
 export MODELSCOPE_DOWNLOAD_MAX_RETRIES=10
 
 # Write weights directly to the external model directory used by ComfyUI
 MODEL_DIR=/data/models/hf/MiniMax-H3-Comfy
 
 # Only download the quantized weights needed for the three types of workflows, do not pull the complete repository
 ms download \
   Comfy-Org/MiniMax-H3 \
   diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors \
   diffusion_models/minimax_h3_ref2va_pruned_int8_convrot.safetensors \
   text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors \
   vae/minimax_h3_video_vae_fp16.safetensors \
   vae/minimax_h3_audio_vae_fp32.safetensors \
   README.md \
   --local-dir "$MODEL_DIR"

Multiple file paths are explicitly passed here, and 0.1.8 will process these files sequentially; --max-workers is only used for full repository snapshot downloads without a specified file list, so it is not added to this command. MODELSCOPE_DOWNLOAD_PARALLEL_WORKERS=4 controls the segmented download concurrency for a single large file.

If the ms entry script is missing but the Python module entry is available, you can simply replace the first line ms download with:

 python -m modelscope_hub.cli.main download

The repository, file list, and parameters following it remain unchanged. If the download is interrupted, re-executing the same complete command will continue checking and downloading missing content.

After completion, check the directory and size:

 # List weights by file size, then check total usage
 find /data/models/hf/MiniMax-H3-Comfy \
   -type f -printf '%s  %p\n' \
   | sort -n
 
 du -sh /data/models/hf/MiniMax-H3-Comfy

5. Connect the External Model Directory to ComfyUI

Models do not need to be copied into app/models. Create /home/your-user/projects/comfyui-minimax-h3/app/extra_model_paths.yaml:

The ComfyUI repository comes with extra_model_paths.yaml.example. You can first confirm the supported keys from the example, then add the MiniMax H3 configuration. Do not directly enable all unrelated paths from the entire example.

 minimax_h3:
   base_path: /data/models/hf/MiniMax-H3-Comfy
   diffusion_models: diffusion_models
   text_encoders: text_encoders
   vae: vae

Create .env in the project root directory:

 # This article uses physical GPU1
 COMFYUI_PHYSICAL_GPU=1
 
 # Listen on all IPv4 network interfaces
 COMFYUI_LISTEN=0.0.0.0
 COMFYUI_PORT=8188

 # .env may continue to add local configurations, so restrict to current user read/write
 chmod 600 /home/your-user/projects/comfyui-minimax-h3/.env

The meaning of 0.0.0.0 is that the service listens on all IPv4 network interfaces of the server, not the address the browser should access. LAN access still uses:

 http://SERVER_LAN_IP:8188

Listening on 0.0.0.0 expands the accessible range. Do not expose port 8188 directly to the public internet; at least cooperate with a host firewall, internal network ACL, VPN, or authenticated reverse proxy.

6. Create a Startup Script with GPU Occupancy Check

Create /home/your-user/projects/comfyui-minimax-h3/start-comfyui-h3.sh:

 #!/usr/bin/env bash
 # Exit immediately if any command fails, variable is undefined, or pipe fails
 set -euo pipefail
 
 PROJECT_DIR=/home/your-user/projects/comfyui-minimax-h3
 APP_DIR="$PROJECT_DIR/app"
 
 cd "$PROJECT_DIR"
 
 # Automatically export variables read from .env
 set -a
 source "$PROJECT_DIR/.env"
 set +a
 
 GPU_ID="${COMFYUI_PHYSICAL_GPU:-1}"
 LISTEN_ADDRESS="${COMFYUI_LISTEN:-127.0.0.1}"
 LISTEN_PORT="${COMFYUI_PORT:-8188}"
 
 # Validate GPU number and necessary files before starting the service
 [[ "$GPU_ID" =~ ^[0-9]+$ ]] || {
   echo "Invalid GPU id: $GPU_ID" >&2
   exit 64
 }
 
 [[ -x "$PROJECT_DIR/.venv/bin/python" ]] || {
   echo "Python environment does not exist: $PROJECT_DIR/.venv" >&2
   exit 1
 }
 
 [[ -f "$APP_DIR/main.py" ]] || {
   echo "ComfyUI does not exist: $APP_DIR" >&2
   exit 1
 }
 
 # If the target GPU already has compute processes, exit with status code 78
 busy_pids="$(
   nvidia-smi \
     -i "$GPU_ID" \
     --query-compute-apps=pid \
     --format=csv,noheader,nounits 2>/dev/null \
     | sed '/^[[:space:]]*$/d' \
     || true
 )"
 
 if [[ -n "$busy_pids" ]]; then
   echo "Physical GPU $GPU_ID is occupied by PID(s): $busy_pids" >&2
   exit 78
 fi
 
 # Limit the running GPU, and centrally set model cache directories
 export CUDA_VISIBLE_DEVICES="$GPU_ID"
 export HF_HOME=/data/cache/huggingface
 export HUGGINGFACE_HUB_CACHE=/data/cache/huggingface/hub
 export MODELSCOPE_CACHE=/data/cache/modelscope
 export HF_XET_HIGH_PERFORMANCE=1
 export PYTHONUNBUFFERED=1
 
 cd "$APP_DIR"
 
 # Replace the current Shell with ComfyUI, so systemd can correctly track the main process
 exec "$PROJECT_DIR/.venv/bin/python" main.py \
   --listen "$LISTEN_ADDRESS" \
   --port "$LISTEN_PORT" \
   --extra-model-paths-config "$APP_DIR/extra_model_paths.yaml" \
   --input-directory /data/comfyui-h3/input \
   --output-directory /data/comfyui-h3/output \
   --temp-directory /data/comfyui-h3/temp

Replace your-user in the script with the server's real username, then check and manually start for the first time:

 # Add execute permission, and do a Bash syntax check first
 chmod +x /home/your-user/projects/comfyui-minimax-h3/start-comfyui-h3.sh
 bash -n /home/your-user/projects/comfyui-minimax-h3/start-comfyui-h3.sh
 
 # First foreground start, convenient for directly observing errors
 /home/your-user/projects/comfyui-minimax-h3/start-comfyui-h3.sh

After seeing To see the GUI go to: http://0.0.0.0:8188, access the server's actual LAN address from the browser.

The first startup will also initialize ComfyUI's SQLite database and resource index. The log finally showing Starting server and the GUI address indicates that the backend has completed startup:

7. Load Official MiniMax H3 Workflows

ComfyUI 0.30.0 and above can open three native workflows from the template library:

Workflow	Diffusion Model	Main Supported Inputs
Text-to-Video	FL2VA INT8	Text
Image-to-Video	FL2VA INT8	Text, First Frame, Optional Last Frame
Reference-to-Video	Ref2VA INT8	Text, Reference Images, Reference Videos, Reference Audio

The three workflows share the same Qwen3-VL text encoder, Video VAE, and Audio VAE. Ref2VA cannot replace FL2VA: R2V uses Ref2VA, while T2V/I2V should choose FL2VA.

If only running Reference-to-Video, you can skip downloading minimax_h3_fl2va_pruned_int8_convrot.safetensors; but as long as text-to-video or image-to-video is still needed, the FL2VA weights must be kept. According to the ComfyUI official H3 workflow description, Ref2VA can receive up to 9 reference images, 3 videos with sound, and 3 audio clips in addition to text prompts, and generate videos with native stereo audio. It is a "reference-conditioned video generation" model, not a general multimodal dialogue model that can arbitrarily receive all modalities and output any modality.

It is recommended to use the following for the first verification:

 Aspect Ratio: 16:9
 Megapixels: 0.4
 Output Resolution: 864 × 480
 Multiple: 32
 Duration: 5 seconds
 Frame Rate: 24 FPS

The H3 official resolution selector will constrain width and height to multiples of 32. Run through with preview resolution first, then gradually increase Megapixels; locating problems will be much easier.

The image below shows the node configuration when running the official example for the first time. You can simultaneously check if the 5-second duration, FL2VA INT8, Qwen3-VL encoder, and two VAEs are selected correctly:

8. On-Site Results Under Native Attention

In the T2V workflow at 5 seconds, 16:9, 864×480, the on-site single task time was 113.89 seconds. This number is used for subsequent SageAttention comparison and does not mean all machines can reproduce the same speed.

The corresponding nvidia-smi on-site record shows that the target GPU was at full load during T2V generation, with VRAM usage around 22.7GB:

The same set of FL2VA weights also completed image-to-video, with an on-site single task time of about 102.18 seconds:

During generation, the target GPU is near full load, and VRAM usage will vary with workflow, resolution, duration, and dynamic offloading status:

9. Hand Over to systemd for Hosting

After manual verification is complete, create /etc/systemd/system/comfyui.service:

 [Unit]
 Description=ComfyUI MiniMax H3 Quantized Service
 # Wait for network readiness, and confirm ComfyUI entry exists
 Wants=network-online.target
 After=network-online.target
 ConditionPathExists=/home/your-user/projects/comfyui-minimax-h3/app/main.py
 
 [Service]
 Type=simple
 User=your-user
 Group=your-user
 WorkingDirectory=/home/your-user/projects/comfyui-minimax-h3
 ExecStart=/home/your-user/projects/comfyui-minimax-h3/start-comfyui-h3.sh
 
 # Auto-restart on normal failure; do not enter restart loop when GPU is occupied
 Restart=on-failure
 RestartSec=15
 RestartPreventExitStatus=78
 TimeoutStartSec=0
 LimitNOFILE=1048576
 
 [Install]
 WantedBy=multi-user.target

After replacing the username, load and start:

 # Reload systemd configuration after unit file changes
 sudo systemctl daemon-reload
 
 # Set to start on boot and start the service immediately
 sudo systemctl enable --now comfyui.service
 
 # View current status and the last 200 lines of logs
 sudo systemctl status comfyui.service --no-pager
 journalctl -u comfyui.service -n 200 --no-pager

View generation logs in real-time:

 # Continuously follow ComfyUI service logs, press Ctrl+C to exit
 journalctl -u comfyui.service -f

RestartPreventExitStatus=78 cooperates with the startup script's GPU occupancy check: if the target GPU is already occupied by other compute tasks, the service will exit clearly, rather than continuously restarting and competing for VRAM.

10. Common Issues

1. How to confirm which GPU ComfyUI is actually using?

This article sets COMFYUI_PHYSICAL_GPU to 1. After CUDA_VISIBLE_DEVICES=1 takes effect, physical GPU1 becomes the only card visible within the process, so the log shows logical cuda:0. You can execute nvidia-smi on the host and confirm the task is actually located on physical GPU1 based on ComfyUI's Python PID, VRAM usage, and GPU utilization.

2. Why does ms-hub: command not found appear?

Because the commands registered by modelscope-hub==0.1.8 in PyPI are ms and modelscope, not ms-hub. So this error first indicates that the command name does not belong to the currently installed version, and does not mean the dependency is not installed, nor does it mean 0.1.8 is too old. Because the ms-hub command was only replaced in versions of modelscope-hub>0.1.8. So if you downloaded a version greater than 0.1.8, then replace the original ms with ms-hub, and modelscope with modelscope-hub.

First confirm the virtual environment and use the correct entry:

 source /home/your-user/projects/comfyui-minimax-h3/.venv/bin/activate
 
 # Main entry: ms provided by modelscope-hub 0.1.8
 command -v ms || true
 ms --help
 
 # Alternate entry
 command -v modelscope || true
 uv pip show -f modelscope-hub
 python -m modelscope_hub.cli.main --help

The command priority in this article is: ms → Python module entry; modelscope is only used as a backup, because installing the full ModelScope framework may cause same-name entry overwriting. The article no longer uses ms-hub or modelscope-hub.

3. VRAM grow failed appears

This type of error does not necessarily equal physical VRAM exhaustion on the graphics card. MiniMax H3 uses DynamicVRAM, CPU offloading, and pinned memory; insufficient system main memory, main memory pressure, or occupation by other processes can also cause allocation failure.

Check in order:

 # Check VRAM, system main memory, and processes occupying the most main memory separately
 nvidia-smi
 free -h
 ps -eo pid,comm,rss --sort=-rss | head

The suggested processing order is: stop unrelated tasks, reduce Megapixels or duration, restart ComfyUI to clean CUDA state, and finally consider increasing system memory. After upgrading from lower main memory to 48GB in this article's environment, the dynamic offloading space is more ample, but specific requirements still depend on the workflow.

11. Conclusion

At this point, the quantized weights of MiniMax H3, the three official workflows, and systemd persistence have formed a complete baseline. Keep this native attention baseline first, then install acceleration components, so you can judge whether the acceleration is truly effective and quickly roll back when problems occur.

Next article: MiniMax H3 with SageAttention Measured Acceleration

References

• ComfyUI: MiniMax H3 Workflow Examples
• ComfyUI 0.30.0 requirements.txt
• PyTorch cu130 Repository
• PyTorch cu132 Repository
• NVIDIA CUDA Toolkit Release Notes: Toolkit and Driver Version Table
• NVIDIA CUDA Minor Version Compatibility
• PyPI: modelscope-hub 0.1.8 (This version's documentation uses ms)
• modelscope-hub v0.1.8 pyproject.toml: ms and modelscope entry points
• ModelScope: Comfy-Org/MiniMax-H3
• ModelScope: MiniMax/MiniMax-H3 Official Model Card
• ModelScope: Comfy-Org/MiniMax-H3 Community Feedback Page
• vLLM Recipes: MiniMax H3 TI2V