Open-H3-Regenerate-2K on one GB10 (128 GB)

One 5 s draft redrawn at 2560×1440: about 22.0 min per clip

Draft and result, side by side

Measured but not shown above: the repeat runs, same prompts, seed +1. job 3 clip (V1, 12.6 MB) · job 4 clip (V3, 20.7 MB).

What the refinement changed

Same moment of the 768p draft and of the refined clip, cut out of the frames. My judgement, not a measurement.

All four jobs

All numbers come from times.json. Whole job is the wall time from the request until the MP4 is saved. The stage times are ComfyUI node times; rest is whole job minus refine minus decode. The medians in the boxes above are taken for each column on its own, so the parts do not add up to the total exactly: refine, decode and rest add up to 1,318.9 s, the median total is 1,317.6 s.

What to keep in mind

• Not the official fast path. NVIDIA's code README says: “One GPU needs about 150 GB for the SoL-Engine forwards with CUDA graphs (B200 / GB200).” I did not run that route. This run uses ComfyUI with int8 weights, dense attention and the released VAE.
• NVIDIA's own speed line is context, not a like-for-like test. The model card says “One 5 s clip, 768P latent → 2560×1440 video: latent upscale + 3-step refine + VAE decode, warm, median of 3 runs” and lists 87.26 s on one B200 for the dense, BF16 route with the released H3 VAE. On this box the same three stages take 1,270.3 s (warm median), 14.6 times as long. Different chip, different weights, different runner.
• Where this setup differs from the model card: int8 DiT instead of BF16 and a 4-bit text encoder instead of BF16. The LoRA is a ComfyUI repack: the rank-576 original is compressed to rank 128 (its author names about 4.5 % error), it leaves out the 50 “sharp” curve branches, and DrakenZA's file fixes the SwiGLU order. The VAE encode may handle the posterior differently. Sampling follows the card: euler, 3 steps, CFG 1, the card's sigmas. The seed 1766580932 is the default seed of NVIDIA's reference script (repeat runs …933).
• Quality is judged by eye only. At the same moment of draft and result, the refinement redraws the face of the violinist, the number plate and a neon sign instead of only sharpening them. That is my impression from three frame pairs, not a measurement. I did not measure image quality.
• The numbers are four jobs on one box. The first run after the server start is one run, with the disk cache not emptied. The warm median is three runs (two different clips: motorcycle, violinist, motorcycle), from 1,315.6 to 1,319.3 s. Peak memory is the whole box, because CPU and GPU share one pool; the box used 4,495 MiB before the first job and 1,521 MiB of swap was already in use.
• The sound is the draft's sound. The graph passes the audio track of the draft clip on to the result; the refiner does not make sound.
• Extra, decode only: from the saved latents, Comfy Org's “Sol” VAE decoded in 51.7 s (violinist) and 50.1 s (motorcycle) against 156.3 s and 147.4 s with the released VAE. By eye the Sol VAE result looks a little softer. The main numbers above use the released VAE. This is not NVIDIA's fast decoder.
• Not run: the SoL-Engine route, NVIDIA's fast VAE decoder, Sol-Attn, a 2-step variant and 4K.
• Licence note: the model card points to the MiniMax H3 Community License and says: “This bundle is not covered by a single blanket license.” Check the terms before you use the clips.

Setup

• Model: Open-H3-Regenerate-2K (NVIDIA), refiner LoRA on MiniMax H3 (fl2va)
• Task: Redraws a 5 s 768p draft clip as 2560x1440: latent upscale, 3 Euler refine steps, VAE decode
• Weights: huggingface.co/Comfy-Org/MiniMax-H3 (DiT, text encoder, VAE) + huggingface.co/DrakenZA/Open-H3-Regenerate-2K-ComfyUI (LoRA) + latent upscaler of NVIDIA's card
• Quantization: int8 DiT (Comfy-Org ConvRot), 4-bit text encoder, rank-128 LoRA in BF16
• Runner: ComfyUI
• Software: ComfyUI master fd7639f4 (0.43.0), torch 2.14.1+cu130, driver 580.178.04, aarch64
• Settings: dense attention, euler, 3 steps (sigmas 0.909375 / 0.857143 / 0.666667 / 0), CFG 1, LoRA rank 128 at strength 1.0, released H3 VAE, seed 1766580932
• Hardware: NVIDIA GB10, 128 GB unified memory (one GB10 with 128 GB (ASUS GX10))

Exact command and run record

# 1) start ComfyUI: master fd7639f4 (reports 0.43.0), torch 2.14.1+cu130, driver 580.178.04, default memory management, one GPU
python main.py --listen 127.0.0.1 --port 8291 --disable-auto-launch --output-directory <out> --temp-directory <temp> --user-directory <user>
# 2) the 4 jobs, one after the other, through the ComfyUI API (POST /prompt): cold run first, then 3 warm runs
#    the graph is workflow_api.json in this folder; per job the runner fills in the draft clip, the prompt text (prompts.json), the seed (jobs.json)
python run_regen.py --port 8291 --out <result folder> --jobs jobs.json
# 3) extra: decode only, from the saved latents (released VAE against Comfy-Org's Sol VAE)
# models in ComfyUI-models/: diffusion_models/minimax_h3_fl2va_int8_convrot.safetensors, text_encoders/qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors,
#   loras/minimax_h3_open_regenerate_2k_r128_comfyui_bf16_swiglu_fixed.safetensors, latent_upscale_models/minimax_h3_latent_upscaler_3d_conv_v1_bf16.safetensors,
#   vae/minimax_h3_video_vae_fp16.safetensors (main runs), vae/minimax_h3_sol_vae_fp16.safetensors (extra)
# sampling: euler, ManualSigmas 0.909375, 0.857143, 0.666667, 0.0 (3 steps), CFG 1 (BasicGuider), LoRA strength 1.0, seed 1766580932 (repeat jobs 1766580933)

command.txt · workflow graph · times of the four jobs · decode-only extra · sha256 of clips and weights · environment and sources · ffprobe · All raw files

The two house prompts

The two house prompts are published word for word in prompts.json; they are also inside the graph, in workflow_api.json (node 14).

• V1 · Violinist on a rooftop: sha256 dc9e8231e0a3…
• V3 · Motorcycle in neon rain: sha256 7a2c7ae3ee41…

Also made this possible

• Model makerNVIDIA (Sana team)GitHub Hugging Face Website
• ComfyUI and the ComfyUI weightsComfy OrgGitHub Hugging Face Website
• SwiGLU-fixed LoRA file (the one used here)DDrakenZAHugging Face
• Base model MiniMax H3MiniMaxHugging Face Website
• Draft clips (Pika H3 Flex)PikaGitHub Hugging Face Website
• Latent upscaler codeLBH-123-AIGitHub

What is like for like here

Every video setup gets the same treatment: the model card's own task, fixed prompts and seeds, a free box (nothing else running), a first run and then warm repeat runs with the median. The time is the wall time of the whole job, and the stage times come from the runner. Every clip on these pages is the real output of that run, published with the container metadata removed and the streams unchanged (the hash of the original is in sha256.txt). Quality is not scored here: for video I show the clips and say what I see, I do not give a number. All clips on these pages are AI-generated.