Hunyuan 3 Generate (Large Budget)

"Hunyuan 3 Generate (Large Budget)" is the memory-conscious sibling of the Large/Offload generator: it renders 2MP–8MP images with CPU offload, and it adds a gpu_budget_gb slider plus memory telemetry on top. The pitch is simple - you tell it how much VRAM it's allowed to assume, it uses the loader's recorded budget for its "smart" offload math, and it reports what actually happened in the status output. If you're doing big renders on a 96GB card with an INT8 or BF16 model, this is the node the README steers you toward.

The inputs that matter

The core controls are shared with the other generators: model, prompt, seed, steps, resolution, guidance_scale, offload_mode, and post_action. But three things are specific to this node:

• offload_mode - smart (default) reads the loader's reserve/budget metadata, estimates cost at roughly 15GB per megapixel plus 6GB, and only enables accelerate CPU offload when VRAM is critically low. disabled forces fully-on-GPU sampling - use it for ≤2MP jobs that already fit, it's the fastest. always offloads before sampling, which you only want at extreme resolutions where you'll definitely exceed VRAM; otherwise it slows INT8 inference to CPU speeds.
• gpu_budget_gb - an override (default -1) that tells smart mode to assume a different budget than the loader recorded, without remapping any tensors. The README gives a concrete use: set it to 65 if you want smart mode to leave more headroom than the loader's default, without reloading the model.
• post_action and keep_model_loaded behavior - when the model is released after a run, the node calls the same cache-clearing logic as the Unload node, so successive runs on the same workflow reload from disk unless you keep it loaded.

Outputs are image, rewritten_prompt, status (which now carries the memory telemetry), and trigger.

How to actually use it

The recommended pairing for a 96GB RTX 6000 Pro-class card is the INT8 Budget loader with reserve_memory_gb around 20 and gpu_memory_target_gb around 80, then this generator with offload_mode: disabled for 1–2MP work. Reserve enough VRAM up front in the loader and smart mode never panics - the README is explicit that the generation overhead is where people get burned: if you don't reserve ~30GB+ for a 4K target, smart offload will suddenly shuttle the whole model to RAM mid-run to avoid a crash, and your "fast" render turns into a slideshow.

Pick a specific resolution, too. "Auto" makes the node assume ~2.5MP for safety and can trigger offloading even when your actual image is small. Telling it exactly what you're rendering lets it skip the offload when you have the room.

Installing

Standard pack install - Manager, or:

cd ComfyUI/custom_nodes
git clone https://github.com/EricRollei/Comfy_HunyuanImage3
cd Comfy_HunyuanImage3
pip install -r requirements.txt

Restart ComfyUI. This node depends on the same stack as the rest of the pack (accelerate, bitsandbytes), and it's only as good as the loader's budget metadata, so use it with the INT8 Budget or Full BF16 loaders - not the plain NF4 loader, which doesn't record a budget this node can read.

Honest limits

There's a sibling that outclasses it at the very top end: on 96GB GPUs, standard Large nodes OOM at 3MP+ because the MoE dispatch_mask tensor grows quadratically with token count. For 3MP–4K renders on BF16, the pack's HighRes Efficient node is the answer instead - same quality, ~75× less MoE intermediate memory. Use Large Budget for the 2–3MP middle ground and for INT8 workflows, and reach for HighRes when you cross into 3MP territory.