Go to gcube.ai →
← All posts
Running the MiniMax H3 video generation model on a gcube RTX 5090
gcube · hands-on

Running the MiniMax H3 video generation model on a gcube RTX 5090

by Yoon Lee2026-09-23▸ RTX 5090Level Intermediate~ 60 min
on this page

Part A. Using gcube: tutorial

Introduction

Text-to-video (T2V) models, which generate a video from a single line of text, are advancing quickly, so we checked firsthand how to actually run this kind of workload on gcube. In this post, we install MiniMax’s latest video generation model, H3, on a gcube RTX 5090 (32 GB) workload and walk through the whole process of generating 5-second and 10-second videos, command by command, so you can follow along.

H3 is a model that requires official license approval from MiniMax. Korea is a region with a pre-application process, so we formally reviewed and agreed to every item — the license terms, safeguard commitments, downstream pass-through confirmation, confidentiality confirmation and the disclaimer — before testing.

1. Create a gcube workload

  1. Log in to gcube.ai → Workload Deployment → Create Workload
  2. Step 1 Basic Settings: Enter a workload description
  3. Step 2 Container Settings

    • Registry Type: Docker Hub

    • Container Image: pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

    • Container Port: 8888

    • Container Command:

      bash -c "apt-get update && apt-get install -y git wget && pip install jupyterlab && jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --NotebookApp.token='' --NotebookApp.password=''"

    • Set Max concurrent requests to 20

  4. Step 3 GPU Settings: Select Tier2 RTX 5090 × 1 / 32GB
  5. Step 4 Other Options: Set shared memory to 8 GB
  6. Step 5 Final Deployment: Select Deploy now → Deploy
  7. Once deployment finishes, open the HTTP service URL on the workload details page and go to /lab to open JupyterLab.

2. Common environment setup

Open a JupyterLab terminal and switch to a bash shell first.

bash

Install the base packages

python3 -m pip install --quiet -U huggingface_hub diffusers transformers accelerate sentencepiece imageio imageio-ffmpeg
apt-get install -y tmux git

Log in to Hugging Face

hf auth login

Choose “Paste an access token” and paste the token you generated.

Run large downloads with tmux and a retry loop The model files are 20 GB or larger, so we wrap the downloads in a background session that retries automatically on failure, as shown below, to download them reliably.

tmux new-session -d -s dl_h3_dit 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "diffusion_models/minimax_h3_fl2va_pruned_fp8_scaled.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_dit.log 2>&1' && echo STARTED

3. Install and run MiniMax H3

3-1. Install ComfyUI

cd /workspace
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m pip install --quiet -r requirements.txt

3-2. Upgrade to torch nightly (cu130)

You need the latest torch build to support NVFP4 quantized operations.

pip install --upgrade --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu130

3-3. Download the models (~42 GB in total)

We use the community quantized versions (Comfy-Org) in a configuration that fits on a single RTX 5090 (32 GB).

mkdir -p /workspace/ComfyUI/models/diffusion_models /workspace/ComfyUI/models/text_encoders /workspace/ComfyUI/models/vae /workspace/ComfyUI/models/loras

# Transformer (FP8, ~20GB)
tmux new-session -d -s dl_h3_dit 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "diffusion_models/minimax_h3_fl2va_pruned_fp8_scaled.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_dit.log 2>&1' && echo STARTED

# Text encoder (NVFP4 AWQ, ~15.7GB)
tmux new-session -d -s dl_h3_te 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_te.log 2>&1' && echo STARTED

# Video VAE (FP16, ~4.9GB)
tmux new-session -d -s dl_h3_vvae 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "vae/minimax_h3_video_vae_fp16.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_vvae.log 2>&1' && echo STARTED

# Audio VAE (FP32, ~578MB)
tmux new-session -d -s dl_h3_avae 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "vae/minimax_h3_audio_vae_fp32.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_avae.log 2>&1' && echo STARTED

# Turbo LoRA (BF16, ~1.9GB)
tmux new-session -d -s dl_h3_lora 'cd /workspace/ComfyUI && until hf download Comfy-Org/MiniMax-H3 --include "loras/minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors" --local-dir models; do echo RETRY_$(date); sleep 5; done > /workspace/dl_h3_lora.log 2>&1' && echo STARTED

3-4. Start the ComfyUI server

A gcube workload exposes only one port externally (8888, for Jupyter), so you can’t open ComfyUI’s own web UI (8188) in a browser. Instead, we start the server in the background and send generation requests by calling the API directly.

tmux new-session -d -s comfyui 'cd /workspace/ComfyUI && python3 main.py --listen 0.0.0.0 --port 8188 > /workspace/comfyui.log 2>&1' && echo STARTED

tail -20 /workspace/comfyui.log

If you see To see the GUI go to: http://0.0.0.0:8188, the server is up.

3-5. Convert the workflow to API format

The official workflow template uses a subgraph structure, which the /prompt API doesn’t accept as is. We queried the ComfyUI server’s /object_info to find the widget order of each node, then wrote and used a script that flattens the subgraph into JSON. (You can reuse the same approach to run other subgraph-based workflows headlessly on gcube.)

cd /workspace/ComfyUI
wget -q https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/video_minimax_h3_t2v.json -O h3_t2v.json
python3 convert.py

If it prints Wrote /workspace/ComfyUI/h3_t2v_api.json with 23 nodes, the conversion succeeded.

3-6. Request 5-second and 10-second clips

Sending the converted JSON to the /prompt endpoint as a POST request starts generation. Once you’ve confirmed the 5-second clip is completely done, change the length value to 10 and submit the 10-second clip.

import json, urllib.request
p = json.load(open('h3_t2v_api.json'))
req = urllib.request.Request('http://127.0.0.1:8188/prompt',
    data=json.dumps({'prompt': p}).encode(),
    headers={'Content-Type': 'application/json'})
r = urllib.request.urlopen(req)
print(r.read().decode())

3-7. Check completion and the output

Generation is complete when Prompt executed in XX.XX seconds appears in the log.

tail -20 /workspace/comfyui.log
find /workspace/ComfyUI/output -name '*.mp4'

In the JupyterLab file browser on the left, go to ComfyUI → output → video and double-click a generated video to play it right away, or right-click → Download to save it locally.

4. Measured results

Pure generation time at 864×480 resolution and 20 steps.

Stage5-second clip (124 frames)10-second clip (243 frames)
Pure generation time~65.6 s~184.8 s

We ran the same procedure two more times as reproduction tests, and the results reproduced reliably, within 5% of the original figures.

Wrapping up

Even a large, recently released video generation model like MiniMax H3 can run end to end on a single gcube RTX 5090 when you use community quantized versions and API-based execution. We’ve documented the procedure as a reproducible manual you can follow step by step, and in the next post we’ll cover tests with another video generation model, LTX.

Test environment: gcube Tier2 RTX 5090 × 1 (32 GB), PyTorch 2.5.1 / nightly cu130, ComfyUI