JR H3 → LTX Latent Adapter (Experimental)

Why this node exists

MiniMax H3 makes lovely video with real synced audio, and it costs you. Thirty-three billion parameters, a 24 fps grid and native stereo audio mean every extra hundred pixels and every extra second is paid for in sampling time. LTX-2.5 is the opposite kind of model: fast, cheap, and happy to spend three steps polishing something that already exists.

So the bridge workflow is: do the creative work in H3 at low resolution (640×640, 175 frames, four Turbo steps is the pack's own starting point), lift that finished draft with JR's neural latent upscaler, then let LTX-2.5 refine the latent at 1024. A few LTX updates instead of a second full H3 pass. H3 keeps the story and the audio; LTX supplies resolution.

This node is the door between them. Feed it a completed H3 video latent, get an LTX-shaped latent back. Two things it isn't: not an upscaler, and not a VAE decode/encode round trip. Nothing here ever becomes pixels.

How the conversion actually works

ComfyUI's native H3 latent is [1, 24, T, H, W] at 16× spatial and 4× temporal compression. LTX-2.5 wants 128 channels at 32× spatial and 8× temporal. Different channel count, different compression, different temporal grid - there's no reshape that gets you across that gap.

What happens instead, in order: the node reconstructs the exact H3 pixel-frame coordinates for that latent (17-frame clips, 4× compression, the 3-token drop), resamples along time into LTX's 8× grid using linear interpolation plus nearest temporal packing, applies a 2× pixel-unshuffle - a layout conversion between the two VAE geometries, not a pixel enlargement - and runs a trained Conv3D network (22 blocks, width 752, frozen at the released weights) that emits 128 channels. Duration is preserved by padding the timeline internally: 175 H3 frames need 177 LTX frames, 124 needs 129. The extra tail is deleted later, by JR_H3LTXFinishMedia.

Normalization is handled for you, and that matters: native ComfyUI H3 latents are already per-channel normalized, and the adapter is trained on that. Don't pre-process or renormalize the latent.

The inputs and outputs that matter

video_latent is the H3 video stream on its own - split the AV latent first with JR MiniMax H3 Split AV Latent. Hand it the joined two-stream latent and you get a flat Connect a plain video LATENT, split the AV latent first. It also has to be a finished draft: batch size 1, no residual noise_mask, no batch_index, and latent frames on H3's native T = 5k+2 grid. If you're coming out of a Progressive Sampler mid-flight, stop - let sigma reach zero. Partially denoised noise doesn't survive a channel change.

adapter_name lists model.safetensors files under ComfyUI/models/h3_ltx_adapters/. An empty dropdown isn't a bug; it means you haven't put the adapter on disk.

Out comes ltx_video_latent, which feeds JR_H3LTXRefineSetup (its ltx_video_latent input) and gets reused as the bridge_latent in JR_H3LTXFinishMedia, plus a status string reporting resolution, source frames and the internal padded length. That string is the fastest way to check that your 640×640 became the 1024×1024 you expected.

Installing it

Install the pack once via ComfyUI Manager (search ComfyUI JR MiniMax H3 Node), or by hand:

cd ComfyUI/custom_nodes
git clone https://github.com/Goldlionren/ComfyUI_JR_MiniMaxH3Node
<ComfyUI-Python> -m pip install -r ComfyUI_JR_MiniMaxH3Node/requirements.txt

Use the Python that runs ComfyUI - on portable or launcher installs, never your system Python. Restart, then hard-refresh the browser. Worth knowing what's in that requirements file: imageio-ffmpeg>=0.5, plus nvidia-vfx on Windows, so the pack pulls the NVIDIA VFX wheel even if you never touch the RTX nodes.

The adapter weights are not downloaded by the node. Grab Efficient-Large-Model/H3-to-LTX-Latent-Adapter at revision cfcd8a7cc36c135142287584728f7fe362df0867 and lay it out like this:

ComfyUI/models/h3_ltx_adapters/H3-to-LTX-Latent-Adapter/
  config.json
  model.safetensors

Both files, same folder. The node validates the config's declared architecture and hashes the safetensors against the released file (170199a3…0724ac) before running. That's deliberate: a truncated download or a re-converted copy fails loudly instead of producing beautiful mush.

Common issues

It refuses your latent. Almost always one of three things: it's the joined AV latent (split it), it carries a mask or batch index (finish the H3 pass first), or the spatial dimensions aren't a clean step. The rule is even latent H/W, i.e. pixel dimensions in multiples of 32 - JR's neural latent upscaler already lands on that grid, so let it resize rather than throwing a plain resize node at the latent.

It needs BF16 CUDA. The frozen network runs bf16 on GPU and the node says so plainly when the device can't. It reserves workspace before running and moves the adapter back to CPU afterwards, so expect a VRAM sawtooth rather than a permanent tenant. On the dev's own 5090 they ran ComfyUI with --reserve-vram 3 after one unexplained stall during an H3/LTX switch without it - cheap insurance when you're flipping between two big models in one graph.

Wrong files, wrong error. Drop the adapter in without config.json and you get a config error, not a missing-file error - the two are validated together on purpose.

If the result looks soft rather than wrong, that's expected: you're looking at a latent conversion, not a render.