# MiniMax H3 in ComfyUI: come eseguirlo in locale — file, GPU, impostazioni

> MiniMax H3 gira in ComfyUI 0.30 e successivi con template pronti T2V, I2V e R2V. Il primo clip chiede circa 42 GB: il modello, l’encoder di testo Qwen3-VL-32B, due VAE e una Turbo LoRA. Non c’è un minimo ufficiale di VRAM; il build più leggero pesa 16 GB, e il 2K non c’è in locale — solo nell’API MiniMax.

Pubblicato il 2026-10-26 · Aggiornato il 2026-10-26
URL: https://ai2face.com/it/blog/minimax-h3-comfyui

[MiniMax H3](/it/models/minimax-h3) è un modello video con audio stereo. MiniMax ha pubblicato i pesi aperti il 3 agosto 2026. In ComfyUI gira in modo nativo, senza nodi di terze parti: i template testo-video (T2V), immagine-video (I2V) e video da riferimenti (R2V) stanno nella libreria dei template. Qui sotto: cosa scaricare, quanto pesa, quale build scegliere per la tua GPU, come accelerare la generazione e dove il modello incontra i limiti. Tutte le cifre vengono dalla documentazione di ComfyUI e MiniMax al 26 ottobre 2026.

## Che cosa ti serve per MiniMax H3 in ComfyUI

- **ComfyUI 0.30.0 o più recente.** Le funzioni più nuove chiedono versioni successive: Multiframe Reference vuole 0.34, Fun ControlNet e sparse attention 0.35, FastH3 0.36, e il build più leggero w6a8 vuole 0.38.
- **Una GPU solida.** Le accelerazioni della documentazione ComfyUI (INT8, NVFP4, Sage Attention) puntano a NVIDIA. MiniMax supporta AMD solo nell’ambiente server vLLM-Omni, tramite ROCm. MiniMax non pubblica una VRAM minima per ComfyUI e consiglia di provare sul tuo hardware — i riferimenti sono più sotto.
- **Circa 42 GB su disco** per il primo template e circa altri 23 GB per i riferimenti.

Sono aperti due modelli della famiglia H3-Base: **FL2VA**, video da testo e da un primo e ultimo fotogramma, e **Ref2VA**, video da riferimenti. Il modulo di preparazione deli riferimenti H3-Context-IR e l’ingrandimento a 2K H3-Regenerate-2K non sono pubblicati e funzionano solo tramite l’API MiniMax. In locale, quindi, H3 dà un fotogramma di circa 1 MP: 1344×768 in 16:9, un clip di 5–15 secondi a 24 fotogrammi al secondo e stereo a 32 kHz.

In che cosa H3 differisce dal precedente Hailuo 2.3, e quanto costa nell’API, è sulla pagina di [Hailuo AI](/it/models/hailuo).

## Quali file di MiniMax H3 scaricare e dove metterli

La via più semplice è aprire **Template Library → Video**, scegliere un template MiniMax H3 e scaricare i modelli dalla finestra. A mano, i file arrivano dal repository Comfy-Org/MiniMax-H3 su Hugging Face:

| Cosa | File predefinito | Dimensione | Cartella |
|---|---|---|---|
| Modello T2V e I2V | `minimax_h3_fl2va_pruned_int8_convrot` | 21 GB | `models/diffusion_models/` |
| Modello R2V | `minimax_h3_ref2va_pruned_int8_convrot` | 21 GB | `models/diffusion_models/` |
| Encoder di testo Qwen3-VL-32B | `qwen3vl_32b_minimax_h3_nvfp4_awq` | 15,7 GB | `models/text_encoders/` |
| VAE video | `minimax_h3_video_vae_int8_convrot` | 2,8 GB | `models/vae/` |
| VAE audio | `minimax_h3_audio_vae_fp32` | 0,6 GB | `models/vae/` |
| Turbo LoRA per T2V e I2V | `minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16` | 2 GB | `models/loras/` |
| Turbo LoRA per R2V | `minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16` | 2 GB | `models/loras/` |

La Turbo LoRA serve anche con la modalità turbo spenta: il template controlla che il file ci sia al caricamento. T2V e I2V arrivano a circa 42 GB, e con R2V a circa 65 GB.

```text
ComfyUI/models/
├── diffusion_models/
│   ├── minimax_h3_fl2va_pruned_int8_convrot.safetensors
│   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors
├── text_encoders/
│   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors
├── vae/
│   ├── minimax_h3_video_vae_int8_convrot.safetensors
│   └── minimax_h3_audio_vae_fp32.safetensors
└── loras/
    ├── minimax_h3_fl2v_turbo_8step_v1.0_comfyui_bf16.safetensors
    └── minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors
```

## Quale build di MiniMax H3 scegliere per la GPU

Comfy consiglia di prendere **il build più piccolo che entra nella VRAM**: l’offload sulla CPU costa più della precisione che perdi. Cambia solo il file nel nodo `UNETLoader`. ComfyUI legge il tipo di quantizzazione dal file stesso.

| Build | Dimensione | Quando usarlo |
|---|---|---|
| `pruned_w6a8` | 16 GB | il più leggero; serve ComfyUI 0.38+ |
| `pruned_int8_convrot` | 21 GB | il predefinito dei template |
| `pruned_fp8_scaled` | 21 GB | la stessa dimensione dell’INT8 |
| `pruned_bf16` | 40,2 GB | senza quantizzazione; serve per Comfy Kitchen attention |
| `bf16` | 66,3 GB | il build completo |

Anche l’encoder di testo ha tre varianti: NVFP4 da 15,7 GB (nei template), INT8 da 27,1 GB e bf16 da 51,5 GB. Le schede RTX serie 30 non hanno FP8, e lì l’INT8 è circa il doppio più veloce dell’FP16 — usa i build INT8.

Non ci sono misure ufficiali solo per ComfyUI. Le cifre più vicine che MiniMax pubblica riguardano gli ambienti server SGLang e vLLM-Omni:

| Hardware | Modalità | Risultato |
|---|---|---|
| 1 × RTX 4090, 24 GB | offload sulla CPU + INT8 | picco di circa 18 GB di VRAM; il tempo dipende dalla RAM |
| 2 × RTX 5090, 32 GB | 5 s, 1344×768, 50 passi | 559,67 s, picco di 26,3 GB per scheda |
| 2 × RTX 5090, 32 GB (vLLM-Omni) | lo stesso | 8 min 38 s, picco di circa 22,6 GB per scheda |

I template ComfyUI usano 20 passi di default, non 50, quindi sulle stesse schede il clip esce prima. Per FastH3, FastVideo ha profili pronti per RTX 5090 e DGX Spark, a 480p di default.

## Come lanciare il primo clip

1. Aggiorna ComfyUI e apri il template **MiniMax H3 T2V**.
2. Lascia **0,4 MP** per la prova: sono 864×480 in 16:9. Una bozza così si calcola in fretta e mostra se la scena va nella direzione giusta.
3. Per il clip finale imposta **0,98 MP** oppure scrivi **1344 × 768** a mano. Non impostare 1,0 MP: dà 1376×768, più superficie di quella su cui il modello è stato addestrato. I lati sono multipli di 32.
4. La durata si imposta in secondi e si arrotonda per eccesso sulla griglia **17k+5**: 5 secondi danno 124 fotogrammi, circa 5,17 s. Il modello è stato addestrato su 5–15 secondi.
5. Avvialo a 20 passi. Alle scene semplici bastano 12–16. Il dettaglio fine, come la cotta di maglia e i motivi, guadagna fino a 50.

Più la risoluzione si allontana da 1344×768, più la generazione è lenta e la qualità bassa; oltre quella misura non si aggiunge dettaglio. I clip lunghi a piena risoluzione urtano prima la VRAM — allora abbassa i megapixel.

## Come scrivere i prompt per MiniMax H3

La documentazione ComfyUI consiglia di scrivere il prompt **in inglese**, e le battute dei personaggi dentro tag `<d>` con un’etichetta di lingua: `<d>[Italian] …</d>`. Chi parla, e come, va prima del tag. MiniMax include l’italiano tra 11 lingue con parlato stabile. Descrivi prima l’intera scena, poi le inquadrature con timecode, la camera e l’audio — in un solo blocco:

```text
integrated_multimodal_description: [Shot 1] Live-action, cinematic, a wide shot of a misty mountain lake at sunrise. The camera pushes in slowly as a young woman in a red raincoat walks along the wooden pier, turns to the camera, and the calm, warm-voiced woman (S1) says: <d>[Italian] Buongiorno.</d> [Shot 2] At 00:03.000, the camera cuts to a close-up of ripples spreading across the water.
overall_soundscape: Gentle water lapping against the pier, distant birds, wooden planks creaking under footsteps.
non_diegetic_music: Soft ambient piano.
```

- **Niente negativi.** H3 in ComfyUI gira con `cfg` 1 e senza ramo negativo: un elenco di «ciò che non vuoi» aggiunge solo quegli oggetti. Scrivi ciò che deve stare nel fotogramma.
- **I tagli** usano un solo timecode, `At 00:03.500, the camera cuts to…`, non un intervallo.
- **Il testo a schermo** va tra virgolette doppie inglesi, parola per parola, nella lingua della scritta.

## Video da un’immagine e da riferimenti

**I2V.** Il template **MiniMax H3 I2V** prende il primo e l’ultimo fotogramma nel nodo `MiniMaxH3ImageToVideo`, e il movimento si costruisce fra i due. Il primo fotogramma viene stirato sulla tela senza conservare le proporzioni, l’ultimo viene ritagliato al centro. Il template si apre in 1:1 e 640×640 — imposta subito le proporzioni della tua immagine, altrimenti si deforma.

**R2V.** Il template **MiniMax H3 R2V** funziona solo con il modello Ref2VA e accetta fino a 9 immagini, 3 video e 3 audio. Nel prompt i riferimenti si chiamano `<Picture 1>`, `<Video 1>`, `<Audio 1>` — e per ciascuna dici che cosa fissa: volto, stile, movimento, camera o voce.

- Un riferimento video si legge a 24 fotogrammi al secondo — riconverti prima le altre frequenze.
- L’audio porta il timbro della voce, non le parole: ciò che va detto si scrive nel prompt.
- Per una somiglianza precisa resta su 20–25 passi. Con la turbo LoRA a 4 passi i riferimenti quasi non si applicano, e volto e posa slittano.

## Come accelerare MiniMax H3

| Metodo | Accelerazione | Contropartita |
|---|---|---|
| Turbo LoRA (`turbo_mode`) | 8 passi invece di 20 in T2V e I2V, 4 in R2V | movimento e audio più morbidi, riferimenti più deboli |
| FastH3 8-step V2 | 8 passi, un modello distillato proprio | solo T2V e I2V, il numero di passi è fisso, ComfyUI 0.36+ |
| Sage Attention | circa 2× | artefatti possibili in coda al clip su INT8 |
| Sparse attention `sol-attn` | meno calcolo sui clip lunghi | sperimentale, ComfyUI 0.35+ |

L’audio si assesta più tardi dell’immagine: parlato e timbro chiedono da 12 passi, e a 8 passi l’audio è di solito il punto debole. Una Turbo LoRA taglia il numero di passi, non il tempo di un passo: una LoRA da 4 passi eseguita a 20 impiega quanto la base.

Sage Attention si installa come wheel per la tua versione di PyTorch e CUDA, poi si collega col nodo `Patch Sage Attention KJ` di KJNodes, tra `UNETLoader` e `BasicGuider`, oppure col flag `--use-sage-attention`. Gli avvisi in console, quando una parte dei layer torna all’attention normale, sono normali.

La versione più veloce con riferimenti, FastH3-Omni, è uscita il 20 ottobre 2026 — i dettagli sono nella notizia [FastH3-Omni: pesi aperti di MiniMax H3](/it/news/fasth3-omni).

## Come ottenere il 2K e un clip più lungo di 15 secondi

**Ingrandimento.** Il 2K ufficiale non è disponibile in locale. La documentazione ComfyUI propone un latent upscaler non ufficiale: il file `minimax_h3_latent_upscaler_3d_conv_v1_bf16` va in `models/latent_upscale_models/`, il nodo **Minimax H3 Latent Upscaler (3D)** si mette dopo la bozza (scala da 1 a 4, default 2), poi un passaggio di refine gira alla dimensione finale con `denoise` 0,1–0,5. Quel percorso risparmia tempo, non VRAM: il refine gira a dimensione piena. L’audio non cambia finché il refine non lo tocca.

**Durata.** I nodi accettano fino a 3.600 fotogrammi, ma il modello è stato addestrato su 5–15 secondi. Più lungo si fa a catena: il template `video_minimax_h3_i2v_continuation` prende l’ultimo fotogramma del pezzo precedente. Gli errori si accumulano, e la texture del volto se ne va per prima; taglia in inquadrature corte.

## LoRA e fine-tuning di MiniMax H3

- **Le LoRA di stile** competono con i riferimenti: in R2V tieni la forza intorno a 0,5.
- **Build pruned e completi.** Una LoRA addestrata sul build completo perde parte dei pesi (adaln) su un build pruned — ComfyUI li salta in silenzio. Le Turbo LoRA funzionano su entrambi.
- **La tua LoRA.** MiniMax descrive il fine-tuning di FL2VA in miles-diffusion, ma la macchina di riferimento è 8 × H200, e l’encoder occupa circa 70 GB di RAM in quella fase. Su un computer di casa non si ripete.

## Errori frequenti di MiniMax H3 in ComfyUI

| Sintomo | Causa e correzione |
|---|---|
| Niente template o nodi H3 | ComfyUI è più vecchio di 0.30.0 — aggiornalo |
| I riferimenti non cambiano il clip | sono collegate a un template T2V o I2V, che le ignora in silenzio; serve il template R2V |
| R2V non parte | è caricato FL2VA al posto di Ref2VA |
| L’immagine I2V è stirata | il primo fotogramma viene adattato alla tela senza proporzioni — imposta le proporzioni dell’immagine |
| Il clip è un po’ più lungo di quanto hai impostato | arrotondamento sulla griglia 17k+5: 5 s = 124 fotogrammi |
| Audio debole, parlato poco chiaro | pochi passi: ne servono 12 o più; il turbo a 8 passi cala |
| Morphing in coda, testo rotto con Sage | quantizzazione INT8 dell’attention; passa a `pruned_bf16` e a Comfy Kitchen attention |
| Comfy Kitchen attention non parte | non funziona con i build `int8_convrot`, solo con bf16 |
| VRAM insufficiente | un build più piccolo, 0,4 MP e 5 s, poi alza un’impostazione alla volta |

## Si può usare MiniMax H3 in ambito commerciale?

I pesi sono gratuiti da scaricare e da eseguire. L’uso commerciale dei risultati dipende dal paese e dal fatturato. Dalla documentazione ComfyUI:

- **Fuori da Stati Uniti, UE, Regno Unito e Corea del Sud, con un fatturato sotto i 20 milioni di dollari l’anno,** l’uso commerciale è coperto dalla licenza comunitaria gratuita di MiniMax H3. Serve la dicitura «Powered by MiniMax H3», e la regola territoriale copre anche dove i clip vengono mostrati.
- **Negli Stati Uniti, nell’UE, nel Regno Unito, in Corea, o con un fatturato oltre i 20 milioni di dollari,** serve una licenza a pagamento — Professional da 5.000 $ al mese, oppure Enterprise su accordo. La vende Comfy, come unico rivenditore ufficiale.
- **In Comfy Cloud,** i diritti commerciali sono già inclusi.

MiniMax avvisa che la licenza può cambiare: ha valore legale il testo sulla pagina dei pesi.

## Quando è più semplice non installare MiniMax H3 in locale

L’H3 in locale ha senso se hai una GPU solida, ti serve la privacy o generi molto senza pagare a clip. Se ti serve un risultato oggi, senza scaricare 42 GB e senza scegliere i build, MiniMax H3 è nel generatore di AI2Face come [Hailuo](/it/models/hailuo). Paghi con carta o con criptovaluta. Il prezzo del clip si vede prima dell’avvio, e dopo la registrazione arrivano crediti di benvenuto. Il confronto con altri modelli video è nella rassegna dei [generatori di video AI](/it/blog/nejroseti-dlya-video).

## Conclusioni

MiniMax H3 in ComfyUI è la via più semplice verso un modello video aperto con l’audio: un template, 42 GB di file e 20 passi. Parti dal T2V a 0,4 MP e 5 secondi per verificare che tutto giri, poi alza la risoluzione a 1344×768. Se la VRAM è stretta, prendi `pruned_w6a8` o INT8 e una turbo LoRA per le bozze; per il finale torna a 20 passi. I riferimenti chiedono un Ref2VA a parte e più passi. Per il 2K, e per un risultato finito senza la tua GPU, usa il generatore di AI2Face.

## Domande frequenti

### Quanta VRAM serve a MiniMax H3 in ComfyUI?

Né MiniMax né Comfy pubblicano un minimo ufficiale. Il riferimento è la dimensione del file: da 16 GB del build w6a8 a 66 GB del bf16 completo. Secondo MiniMax, una RTX 4090 da 24 GB con offload sulla CPU gira con un picco di circa 18 GB.

### Quanto pesa il download di MiniMax H3?

Il template T2V e I2V in ComfyUI scarica circa 42 GB: modello da 21 GB, encoder di testo da 15,7 GB, due VAE da 3,4 GB e Turbo LoRA da 2 GB. I riferimenti R2V aggiungono circa altri 23 GB.

### Che cos’è MiniMax H3 Turbo?

È una LoRA che riduce la generazione da 20 passi a 8 in T2V e I2V, o a 4 in R2V. Il clip è più veloce, ma movimento e audio diventano più morbidi, e i riferimenti tengono meno.

### Si può fare il 2K con MiniMax H3 in locale?

No. Il modulo H3-Regenerate-2K non è pubblicato, e il 2K esiste solo nell’API MiniMax. In locale il modello è pensato per un fotogramma di circa 1 MP (1344×768); per ingrandire c’è un latent upscaler non ufficiale.

### In che cosa FL2VA è diverso da Ref2VA?

FL2VA è il modello per il video da testo e da un primo e ultimo fotogramma. Ref2VA è per il video da riferimenti: foto, video e audio. Sono file diversi, e il template R2V funziona solo con Ref2VA.

### Si possono usare i clip di MiniMax H3 a scopo commerciale?

Dipende dal paese e dal fatturato. Fuori da Stati Uniti, UE, Regno Unito e Corea del Sud, con un fatturato sotto i 20 milioni di dollari l’anno, l’uso commerciale è coperto dalla licenza comunitaria gratuita se aggiungi «Powered by MiniMax H3». Negli altri casi serve una licenza a pagamento.

## Fonti

- https://docs.comfy.org/tutorials/video/minimax/minimax-h3
- https://docs.comfy.org/tutorials/video/minimax/minimax-h3-native
- https://docs.comfy.org/tutorials/video/minimax/minimax-h3-fastvideo
- https://docs.comfy.org/tutorials/video/minimax/minimax-h3-prompt-guide
- https://platform.minimax.io/docs/guides/local-deploy-h3
- https://huggingface.co/MiniMaxAI/MiniMax-H3
- https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_base_en.md
- https://huggingface.co/Comfy-Org/MiniMax-H3
- https://haoailab.com/blogs/fastvideo-omniref-update/