Cine con IA · Render optimizado H3

This is the first sampling pass of an H3 render, wrapped in one node. The interesting part isn't the sampling - ComfyUI already does that - it's that the node takes its steps, sampler, scheduler and denoise from a config object produced by Cine con IA · Optimizador H3 instead of from widgets you twiddle. Wire the config, pick a seed, done.

If you've ever built a graph out of KSamplerSelect, BasicGuider, RandomNoise, BasicScheduler and SamplerCustomAdvanced and then got one of them wrong, this is that graph, pre-wired and consistent.

How the mechanism works

On run, the node checks that config is a real optimizer config (it looks for its internal schema tag) and raises "Conecta la salida config de CineConIA H3 Optimizer" if it isn't. Then it calls ComfyUI's own core advanced-sampling nodes directly from Python:

• BasicScheduler with the config's scheduler, steps and denoise to build the sigmas;
• KSamplerSelect for the config's sampler;
• BasicGuider from your model and positive conditioning;
• RandomNoise with your seed;
• SamplerCustomAdvanced to actually sample the latent.

No extra dependency, no reimplementation of the sampler, and if those core nodes are missing you get "Faltan los nodos de sampleo avanzado del core de ComfyUI" rather than a stack trace from ten frames deep.

There's a second path. If the optimizer was set to Progresivo, the node hands the whole job to SelfLift, a separate community pack you install yourself: the first steps run at a lower resolution, the rest at yours. The pack calls it, doesn't copy it, and checks compatibility - if the SelfLift you installed declares inputs this pack doesn't know, it stops and tells you which commit it was tested against instead of failing mysteriously.

The inputs, and the one that isn't there

Required: model (MODEL), positivo (CONDITIONING), latente (LATENT), config (CINECONIA_H3_CONFIG from the Optimizer) and semilla (INT).

semilla defaults to 833, is a full 64-bit integer, and has control_after_generate attached - which means the usual trap applies: by default the control fires after a run, so the seed in the box is the one for the next render, not the one that just made the clip you liked. If you're iterating on a shot, switch the global widget control mode to Before once and stop losing good seeds.

Notice what's absent: there is no negative input. The guider is built from positivo alone, so this is a CFG-1 style pass with no unconditional branch for a negative to steer. That is normal for H3 and for guidance-distilled video models generally, and it means the negative-prompt box in a copy-pasted workflow will do nothing here. Write your constraints as presence - "clean plate background, steady subject, sharp focus" - rather than as a list of things you don't want.

Outputs: latent (LATENT), which goes to Escalar y Refinar for a second pass or straight to Salida if you're just testing; and info (STRING), a one-liner with the active profile, steps, sampler/scheduler, seed, elapsed seconds and the Memory Planner's verdict. That info string is the cheapest diagnostic in the pack - read it before you assume the render was slow for mysterious reasons.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/chaLords/ComfyUI-Cine-con-IA.git

Restart ComfyUI; the node lives under Cine con IA/H3 as "Render optimizado H3". The pack installs no pip dependencies. ComfyUI Manager may not list it yet - it's in the Comfy Registry as cine-con-ia with versions still pending review, so install by git or from the release ZIP. And yes, the UI is Spanish.

For the progressive path you need two extra things: comfyui-SelfLift (facok/comfyui-SelfLift, tested at commit 835c3cf) in custom_nodes, and an H3 latent upscaler file - the pack looks for any filename containing "h3" in models/latent_upscale_models. Miss either and the Optimizer tells you which one by name.

One piece of housekeeping on the model side: MiniMax H3's open weights ship under a community licence whose Applicable Territory excludes the US, EU, UK and South Korea, so running the local weights is not licensed in those regions at all. That's a real constraint on this whole pipeline, not a footnote, and the hosted Hailuo API is the licensed path there.

When it goes wrong

Progressive mode not applying is usually not a bug. The plan is disabled when you request fewer than two steps, or when the low-resolution stage would come out almost as large as the final one - under roughly 0.5 MP there's nothing left to save, and the Optimizer says so in its info line rather than pretending. It also deliberately won't start a low-res segment below 384 px on the short side, because that's the range SelfLift was actually tested in for H3.

The other expectation to drop: progressive sampling saves time, not VRAM. Your peak still happens in the final stretch, at full resolution, so it does not rescue a render that doesn't fit. If you're OOM-ing, that's the Optimizer's chunking and refine scale, or a smaller first pass - not this switch.