SolarRenderer H3 Full Workflows: Singularity V2 , FastH3-OmniRef - For Patreon Supporters (Patreon)
Videos
-
cond.mp4 -
video_00033.mp4
Downloads
Content
Hey everyone. If you watched the video, you saw the blockout-to-movie pipeline and the tests. This post has the production workflows I actually ran, all of them, with the exact settings. Plus the prompt skill file that makes the whole thing work.
https://www.patreon.com/aifuturetech/posts/minimax-h3-new-173450100/
----------------------------------------
WHAT'S INCLUDED
----------------------------------------
1. h3_singularity_V2_solarrenderer.json
..............................................
File: h3_singularity_V2_solarrenderer.json
The action variant - 69 nodes. This is the one that rendered the rooftop jump. It runs MiniMax H3 Singularity V2 (int8) as the base model with the SolarRenderer LoRA pair on top, and it's tuned for high-motion scenes with fast camera work.
Here's what makes it special. The SolarRenderer four-step LoRA and control LoRA both sit at full strength 1.0 on the model, so the structure video is followed frame by frame while sampling drops to four steps. The SelfLift progressive sampler does the two-stage resolution trick (low-res 0.5 up to 1.0 megapixel) inside one sampler node using the MiniMax latent 3D upscaler. Four total steps on this one. And since the video, I added a DLSS 5 enhance stage at the end - the output sharpness is a clear step up from the RTX super resolution alone.
The pipeline:
- Minimax-h3_Singularity_ref2va_v2_int8.safetensors as the base model
- SolarRenderer 4-step LoRA at 1.0, then LMS distilled LoRA r64 at 0.7, then SolarRenderer control LoRA at 1.0
- Qwen3VL 32B int8 text encoder
- MiniMaxH3ReferenceToVideo conditioning: first frame to the reference image input, structure video to the reference video input
- MiniMaxH3SigmaShift at 12 / 3
- SelfLiftH3Sampler: euler, fixed noise, low-res scale 0.5, minimax_h3_latent_upscaler_3d_fp32.pth, 4 steps
- VedaSparseAttention (VSA) at 32x32 + BlockSparseAttention + MiniMax chunk feed forward
- Sage attention patches: PathchSageAttentionKJ with the MiniMax H3 memory-efficient patch
- RTX Video Frame Generation 2x, RTX Video Super Resolution, RTXTrueHDR left bypassed
- DLSS 5 enhance pass: DLSS5Settings + DLSS5EnhanceImages as the final sharpen/upscale stage
- Video VAE fp16 for the frames, audio VAE fp32 for the soundtrack
- AIO Preprocessor (Metric3D normal map) wired into the structure input
Resolution 1344x768 at 24 fps, 158 frames per pass. The structure video drives every frame - motion, placement and camera come from it, the prompt decides the world.
2. minimax_fasth3_ominiref_solarrenderer.json
.............................................
File: minimax_fasth3_ominiref_solarrenderer.json
The speed variant - 66 nodes. Same skeleton, different engine: fasth3_omniref_8step_pruned_int8_convrot.safetensors instead of Singularity V2, and the SelfLift sampler runs 6 steps instead of 4. The LMS distilled LoRA goes up to 0.8 here to keep the pruning in line.
Use this one when you want the fastest turnaround or you're testing prompt ideas. Switch to the Singularity variant for the final render on action scenes - that's where the motion quality difference shows.
This is also the workflow that's shared with the public post, so your supporters on the free tier have a working base. The Singularity variant, the Qwen first-frame workflow and the prompt skill below stay exclusive here.
3. QwenImg_2-1-firstframe-RefToImg.json
..............................................
File: QwenImg_2-1-firstframe-RefToImg.json
The first-frame generator - 45 nodes. This is how the first frame in the video got made. You give it a reference image (the AI character) and a reference video, it captures a frame, extracts the pose with the DWpose preprocessor, and Qwen-Image-2.1 re-poses your character to match. The output goes straight into the SolarRenderer first frame input.
Here's what makes it special. Qwen-Image-2.1 runs with the viggle-turbo 5-step LoRA at full strength for fast character-consistent generation, and the workflow uses both of the 2.1 prompt encoders - the t2i embedding for the look and the i2i embedding for the pose transfer. So the prompt tells the model to move the image 1 character into the image 2 control pose, and it follows.
The pipeline:
- qwen-image-2_1_bf16.safetensors as the base model
- Qwen-Image-2.1-viggle-turbo-v0.2-5step-lora-r256 at 1.0
- Qwen3.5 9B prompt encoders: pe_t2i int8 + pe_i2i int8, plus qwen3vl_8b_bf16
- VHS_LoadVideoPath captures the reference frame, AIO Preprocessor extracts the DWpose skeleton
- VHS_LoadImagePath loads the AI character image
- Two KSampler passes: 12 steps, CFG 1.0, euler, simple scheduler, fixed seeds
- QwenImage21Cache keeps the conditioning cached between passes
- Image resize/mask nodes normalize both inputs to the same canvas before encoding
Why a separate workflow for this: the first frame is fully preserved as frame 0 of the render, so it deserves its own generation pass with the exact pose from your reference. A generic portrait gives the render a camera seam it can't fix.
4. SKILL.md (SolarRenderer prompt skill)
..............................................
File: SKILL.md
The six-part prompt format SolarRenderer was trained on, packaged as an agent skill. Give it to Codex, Claude Code or any coding agent with your structure video and it writes the prompt for you - subject definitions, summary, retention analysis, the 350-500 word detailed description, soundscape. Or just read it and write the prompts by hand like I do.
This file is the difference between the failed renders and the good ones in the video. The rule that matters most: when your 3D camera turns to an angle the first frame can't show, the detailed description has to spell out that new scene - the buildings, the ground, what the character does there. Without it the model falls back to raw grey blocks. With it, the grey houses became a modern city.
----------------------------------------
WHAT YOU NEED
----------------------------------------
For the video workflows (both):
- minimax-h3/Minimax-h3_Singularity_ref2va_v2_int8.safetensors (huggingface.co/WarmBloodAban/Minimax-h3_Singularity)
- minimax-h3/fasth3_omniref_8step_pruned_int8_convrot.safetensors (huggingface.co/FastVideo/FastH3-Omni-Comfy)
- minimax-h3/qwen3vl_32b_h3_ultra_uncensored_heretic_int8_convrot.safetensors (text encoder)
https://huggingface.co/ethanfel/Qwen3-VL-32B-Ultra-Heretic-H3-ComfyUI-INT8-ConvRot/tree/main
- minimax-h3/minimax_h3_lms_v1.0_r64.safetensors (distilled sampling LoRA) https://huggingface.co/Alissonerdx/Minimax-H3-ComfyUI/blob/main/loras/minimax_h3_lms_v1.0_r64.safetensors
- minimax-h3/minimax_h3_video_vae_fp16.safetensors and minimax_h3_audio_vae_fp32.safetensors
- minimax_h3_latent_upscaler_3d_fp32.pth (SelfLift stage)
- minimax_h3_r2va_veda_preview_fp8.safetensors (VSA kernel)
- SolarRenderer/solarrenderer_control_lora.safetensors and solarrenderer_4step_lora.safetensors (huggingface.co/Enderfga/SolarRenderer)
For the Qwen first-frame workflow:
- QwenImage/qwen-image-2_1_bf16.safetensors
- QwenImg2_1/Qwen-Image-2.1-viggle-turbo-v0.2-5step-lora-r256.safetensors
- qwen3vl_8b_bf16.safetensors (CLIP)
- qwen3.5_9b_qwen_image_2.1_pe_t2i.int8_convrot.safetensors and qwen3.5_9b_qwen_image_2.1_pe_i2i.int8_convrot.safetensors (prompt encoders)
- qwen_image_2.1_vae_bf16.safetensors
Custom nodes:
- ComfyUI v0.30 or newer (native MiniMax H3 and Qwen-Image-2.1 nodes)
- comfyui-SelfLift (github.com/facok/comfyui-SelfLift)
- ComfyUI-VideoHelperSuite
- ComfyUI-KJNodes (Sage attention patch)
- rgthree-comfy (Any Switch)
- ComfyUI-NVIDIA-RTX-VFX (frame generation + super resolution)
https://github.com/Comfy-Org/ComfyUI_Nvidia_VFX_Nodes
- DLSS 5 enhance nodes (DLSS5Settings / DLSS5EnhanceImages) for the Singularity workflow's final stage
https://github.com/Blueforcer/ComfyUI-DLSS5-Enhancer
- ComfyUI-Easy-Use (the cleanGpuUsed / clearCacheAll maintenance nodes in the Qwen workflow)
- The Veda/Spare attention pack for the VSA kernel
An NVIDIA RTX GPU for the RTX and DLSS nodes. The generation itself runs on the int8 models, so VRAM stays reasonable - the enhance nodes are the part you can bypass if needed.
----------------------------------------
TIPS
----------------------------------------
Both video workflows:
- SolarRenderer control and 4-step LoRAs are at 1.0 and that's correct. This is the released pairing - don't scale them down like a style LoRA. The 4-step LoRA is what makes four-step sampling work at all, and the control LoRA is what locks the motion to your structure video.
- Structure video resolution matters more than you'd think. Render your 3D blockout at exactly 1344x768 and let the workflow feed it in unsquashed. A 1280x720 source gets subtly resized and the camera geometry drifts with it.
- The first frame is fully preserved as frame 0. If it doesn't match your blockout's opening pose and camera, the whole clip fights that seam. Generate the first frame with the Qwen workflow from the blockout's actual first frame - the pose doesn't need to match perfectly (mine didn't) but the framing should.
- Metric3D normal map beats raw grey box in my tests. Grey blocks with a white sky give the model almost no silhouette signal; normal maps carry layering and depth. Try grey box first since it's a trained condition type, but if the motion fidelity isn't there, switch the AIO Preprocessor on.
- The SelfLift low-res scale at 0.5 with 1.0 megapixel output is the tested pair. Lower stages make it faster but softer.
h3_singularity_V2_solarrenderer.json:
- Four steps on SelfLift with this model. If you see incoherent frames in fast camera moves, bump to 5 before touching anything else.
- LMS LoRA at 0.7. The Singularity V2 int8 is already aggressive on motion - 0.8 with this model over-sharpens the character in my tests.
- The DLSS 5 stage at the end is where the final sharpness comes from now. If faces look over-processed after it, dial the DLSS5Settings strength down before touching the sampler.
minimax_fasth3_ominiref_solarrenderer.json:
- Six steps here. The OmniRef pruned model needs the extra steps compared to Singularity.
- LMS LoRA at 0.8 compensates for the pruning. Below 0.7 the skin texture softens too much.
- This workflow uses VHS_LoadVideo instead of LoadVideoPath - both work, just match the node to how your ComfyUI is set up.
QwenImg_2-1-firstframe-RefToImg.json:
- The viggle-turbo 5-step LoRA stays at 1.0. It's what keeps the character face and body consistent between the reference image and the re-posed output.
- Keep the DWpose input and the character image straight: image 1 is the character you want, image 2 is the captured frame whose pose gets transferred. Swap them and you'll restyle the wrong picture.
- Both KSamplers run 12 steps at CFG 1.0 with euler/simple. Qwen-Image-2.1 wants CFG at 1.0 - raising it doesn't help and hurts the skin texture.
- Fixed seeds keep the generation reproducible while you iterate on the prompt. Change the seed only after the prompt is right.
RTX nodes:
- Frame generation multiplier 2 doubles the fps from 24 to 48 and that doubles playback speed against your 24 fps source. For 1:1 comparison with the reference video, set it back to 24 or bypass the node.
- RTXTrueHDR stays bypassed. It's unnecessary for most AI video and costs render time. Only enable it if you're finishing a shot for real.
Prompts:
- Use the SKILL.md format. Short free-form prompts render noticeably worse - the model was trained on one six-part form and it shows.
- Time your events in words ("midway", "near the end"). Timestamps only belong at a hard cut.
----------------------------------------
COMMON ISSUES
----------------------------------------
Render ignores the blockout motion: Your structure video is being resized or re-timed. Render the blockout at 1344x768, 24 fps, and turn off force_rate resampling in the video loader.
Camera goes wrong after a turn: The first frame can't describe the second angle. Add the post-turn scene to the detailed description - what the buildings look like, the ground, what the character does. This single fix saved my grey-box test.
Output looks like the raw grey blocks after the first seconds: The model is falling back to the structure look. Two causes: a prompt with no descriptive detail, or a grey box with too little contrast. Fix the prompt first, then try the Metric3D normal map as the structure input.
First frame and blockout fight each other: The generated first frame moved the camera or the pose too far from blockout frame 0. Regenerate it with the Qwen workflow using the blockout's frame 0 as the reference, keeping camera, framing and layout identical.
Qwen output ignores the pose: The DWpose preprocessor output isn't reaching the i2i encode, or the two input images are swapped. Check that the skeleton comes from the captured reference frame, not from the character image.
Qwen output loses the character's identity: Lower the viggle-turbo LoRA strength too far and the face drifts. Keep it at 1.0; adjust the prompt wording instead.
Playback speed doubles: That's the RTX frame generation at 2x. Set the multiplier to 1 or bypass the node if you need real-time pacing.
VRAM pressure at 1344x768: Both video workflows run int8 models. If you still crash, drop the DLSS 5 and RTX Super Resolution stages first (they hold the upscaled frames), then lower the frame count per pass and chunk the clip. The easy clearCacheAll node in the Qwen workflow is there for the same reason.
Structure input shows but the character ignores it: Check which LoRA order you're loading. Four-step LoRA first, LMS second, control LoRA last - the control LoRA must be closest to the sampling for the structure pathway to read right.
----------------------------------------
The workflow files are attached. Start with the FastH3-OmniRef variant to get your pipeline working, generate your first frame with the Qwen workflow, then swap in the Singularity variant for the final action render with the DLSS 5 finish.
Questions? Drop them in the comments and I'll help you sort it out.
Thanks for supporting the channel. You guys make these deep dives possible.
- Benji