Configuration de LTX-2.3 dans ComfyUI : Pipeline en deux étapes, corrections VRAM et encodeur Gemma

Salut tout le monde. Je m’appelle Dora. Je n’avais pas prévu de changer. Ma configuration LTX-2 dans ComfyUI fonctionnait bien, et je ne suis pas du genre à tout refaire juste parce que c’est nouveau. Mais la semaine dernière (mars 2026), je continuais à voir de petites notes sur LTX-2.3 : meilleure cohérence, nouveau encodeur de texte (Gemma 3 12B), et un pipeline en deux étapes qui promettait des images plus nettes sans sacrifier la VRAM.

J’ai profité d’une matinée calme pour migrer mon workflow. Voici ce qui a réellement changé pour moi, où j’ai rencontré des obstacles, et les éléments qui ont rendu le travail plus fluide. Si vous cherchez juste les étapes d’installation : elles sont là, mais l’essentiel réside dans les compromis que j’ai observés en construisant un workflow LTX-2.3 ComfyUI jour après jour.

Ce qui est différent dans LTX-2.3 sous ComfyUI (par rapport à la configuration LTX-2)

LTX-2.3 ComfyUI ressemble davantage à un pas vers la fiabilité qu’à un bond en avant. Le modèle attend Gemma 3 12B comme encodeur de texte, et le chemin recommandé est un pipeline en deux étapes : générer à mi-résolution pour la cohérence de base, puis upscaler les latents avec un upsampler spécifique à LTX. En pratique, cela a changé deux choses pour moi :

Les prompts se tenaient mieux avec un nombre d’étapes modeste. J’ai remarqué moins de détails « flous » en restant entre 25 et 35 étapes à l’Étape 1.
La VRAM était moins instable que je ne le craignais, à condition de respecter les limites des étapes et de ne pas tenter de forcer la pleine résolution en une seule passe.

J’ai aussi constaté que les anciens nœuds LTX-2 fonctionnaient pour la plupart, mais LTX-2.3 préfère ses propres nœuds sampler/latent upsampler. Simplement remplacer le checkpoint ne suffisait pas. C’est là que j’ai trébuché la première fois.

Fichiers requis et structure des dossiers

Voici la configuration à laquelle je suis arrivée après quelques faux départs. Rien de compliqué : c’est le minimum qui a fait disparaître les boîtes d’erreur rouges.

Options de checkpoint (dev / fp8 / distilled + distilled LoRA)

dev : Idéal pour l’exploration. Un peu plus lourd, mais je l’ai trouvé plus tolérant quand les prompts s’égaraient.
fp8 : Plus léger sur la VRAM. Avec ma carte 12 Go, fp8 m’a permis de garder une taille de lot de 1 sans OOM pendant le décodage. Légère perte de qualité, rien de dramatique pour des contenus destinés aux réseaux sociaux ou au marketing.
distilled + distilled LoRA : Les sorties les plus nettes pour des prises de vue de type produit dans mes tests, mais il faut penser à charger réellement le LoRA et à définir un poids (0,6–0,8 a fonctionné pour moi). Sans le LoRA actif, les résultats ressemblaient davantage au mode dev.

Tous les checkpoints se trouvaient dans ComfyUI/models/checkpoints. Je gardais les LoRAs dans ComfyUI/models/loras et je les nommais avec le même nom de base que le checkpoint principal pour retrouver la paire rapidement.

Encodeur de texte Gemma 3 12B : téléchargement et emplacement

LTX-2.3 attend l’encodeur de texte Gemma 3 12B. Selon votre pile de nœuds, vous utiliserez soit un poids PyTorch, soit un fichier GGUF (pour les nœuds basés sur llama.cpp). J’ai essayé les deux.

Route PyTorch : placé dans ComfyUI/models/clip (certains nœuds détectent automatiquement cet emplacement). Si votre nœud demande un dossier différent, suivez sa documentation, ne luttez pas contre elle.
Route GGUF : placé dans ComfyUI/models/llm (ou un dossier text_encoders spécifique au nœud). Q4_K_M était le bon compromis pour moi : Q3 économisait plus de mémoire mais perdait en nuance sur les prompts longs.

En cas de doute, ouvrez l’aide « ? » du nœud ou son README. Le nom du dossier a son importance.

Modèles d’upscaler : quand les inclure

Vous n’avez pas besoin d’un upscaler d’image externe si vous utilisez le latent upsampler LTX. Cela dit, je gardais un 4x ESRGAN et un latent upscaler SDXL x2 dans ComfyUI/models/upscale_models pour les images non-LTX. Pour LTX-2.3, le LTXVLatentUpsampler intégré donnait de meilleurs résultats qu’ESRGAN pour les contours et les formes rappelant du texte.

Explication du pipeline en deux étapes

Je continuais d’essayer de sauter l’Étape 1. C’était une erreur. Le pipeline en deux étapes s’est finalement avéré plus simple à appréhender et plus doux avec la VRAM.

Étape 1 : cohérence de base à mi-résolution

Je génère à la moitié de ma taille cible (par exemple, 640×384 pour un rendu final en 1280×768). Cette étape établit la composition et les détails du sujet. 25–35 étapes, CFG modeste (4–6), taille de lot 1. Si quelque chose cloche — les mains, la mise en page, la dominante colorée —, c’est moins coûteux à corriger ici.

Ce que j’ai remarqué : moins de « dérives » quand je simplifiait les prompts et utilisais un ou deux ancres stylistiques au maximum. LTX-2.3 semble récompenser un langage ciblé.

Étape 2 : upscaling des latents pour la netteté (LTXVLatentUpsampler)

Ensuite, je passe les latents de l’Étape 1 dans le LTXVLatentUpsampler. Cela affine les contours et restaure les détails fins sans rebattre la composition. Je lance généralement 15–20 étapes pour l’upsampling. Ce n’est pas une baguette magique : si la base est ratée, l’upsampler ne fait qu’en produire une version plus nette du raté.

Dev + Distilled LoRA vs Full Distilled : lequel choisir

Dev + Distilled LoRA : Mon choix par défaut quand j’explore un style. Légèrement plus flexible. Je règle la force du LoRA autour de 0,7 et j’ajuste si les textures semblent trop marquées.
Full Distilled : Quand j’ai besoin de sorties rapides et cohérentes pour un lot. Plus exigeant sur les prompts, mais économise de l’énergie mentale — moins de surprises d’une génération à l’autre.

Si vous êtes bloqué, essayez dev pour l’Étape 1 (plus souple) et distilled pour l’Étape 2 (plus précis). Cette combinaison m’a sauvé une série de portraits dans une ambiance particulière.

Configuration de l’encodeur Gemma 3 12B : gestion de la VRAM

Gemma 3 12B est la principale raison pour laquelle je m’attendais à des problèmes. Ce n’était pas si terrible, mais il faut des garde-fous.

Décharger l’encodeur sur CPU/RAM quand la VRAM est limitée

Avec une carte 12 Go, j’ai déchargé l’encodeur Gemma sur le CPU pour la passe texte. Cela a ajouté quelques secondes par génération, mais a évité les OOM pendant l’Étape 1. Si votre nœud prend en charge le chargement sur appareils mixtes, placez les couches d’attention sur GPU et le reste sur CPU. La sensation : pas plus rapide, mais plus calme — plus de plantages brutaux en plein milieu d’une idée.

Flag —novram et autres correctifs au démarrage

Si vous lancez ComfyUI avec des flags en ligne de commande, —novram a aidé à lisser les pics mémoire lors des changements de modèle. J’ai aussi :

Désactivé « keep loaded » sur les grands modèles entre les tests.
Défini torch.set_grad_enabled(False) dans un petit init personnalisé (si votre configuration le permet) pour éviter des gradients inutiles.
Utilisé des filets de sécurité plus petits : checkpoints en 16 bits ou fp8 quand je savais que j’allais empiler des LoRAs.

Stratégies pour faible VRAM sur GPU grand public (12 Go / 16 Go / 24 Go)

Ce qui a fonctionné sur trois machines que j’ai testées (RTX 3060 12 Go, 4070 12 Go et 4090 24 Go) :

Modèles GGUF quantifiés : compromis entre Q3 et Q4

Q3 : Mémoire minimale, chargement le plus rapide, mais j’ai perdu en nuance de prompt et vu plus de répétitions dans les descripteurs.
Q4 : Légèrement plus lourd, cohérence nettement meilleure. Mon choix pour les cartes 12–16 Go. Pour 24 Go, je passe la quantification ou j’utilise Q5 si disponible.

Déchargement du VAE pour réduire les pics mémoire

Le décodage est là où je rencontrais le plus d’OOM. Décharger le VAE sur le CPU ou utiliser un VAE plus léger a réduit les pics en fin d’Étape 2. Avec 12 Go, j’ai aussi réglé le décodage final sur une seule image (sans lot), même si les nœuds précédents traitaient par lot — moins de drama.

Autres petits gains :

Garder une résolution modeste à l’Étape 1 : upscaler ensuite.
Éviter d’empiler plusieurs astuces de guidage. Un CFG, un LoRA à la fois.

Erreurs courantes au premier lancement et correctifs

J’ai rencontré les boîtes rouges habituelles. Voici les correctifs qui ont tenu.

Erreurs de nœuds manquants après le chargement

Si ComfyUI ne trouve pas les nœuds LTX-2.3, mettez à jour votre dépôt de nœuds personnalisés et redémarrez. Certains nœuds LTX nécessitent également une version plus récente du cœur ComfyUI. J’ai résolu une erreur persistante en supprimant le dossier cache du nœud et en le laissant se reconstruire au démarrage.

OOM pendant le décodage

Deux leviers ont aidé immédiatement : passer le checkpoint en fp8 ou décharger le VAE sur CPU. Réduisez aussi le lot de la dernière étape à 1. Si vous continuez à planter, divisez la résolution cible par deux et laissez un upscaler d’image externe finir le travail.

Plantage de l’encodeur Gemma

Cela signifiait généralement une inadéquation de dossier ou un fichier quantifié que le nœud n’appréciait pas. J’ai re-téléchargé Gemma 3 12B depuis la source indiquée dans le README du nœud, vérifié le checksum, et placé le fichier où le nœud l’attendait (clip vs llm). Q4 fonctionnait : Q3 échouait parfois au chargement sur mon 4070 jusqu’à ce que je mette à jour vers le dernier build basé sur llama.cpp.

FAQ

Les nœuds ComfyUI LTX-2.3 doivent-ils être installés séparément ?

Généralement oui. Mettre à jour le modèle seul ne suffit pas. Récupérez le dernier dépôt de nœuds LTX et redémarrez ComfyUI pour qu’il enregistre les nouveaux samplers et le latent upsampler.

Puis-je utiliser des workflows LTX-2 existants avec des checkpoints LTX-2.3 ?

En partie. J’ai pu réutiliser la structure, mais j’ai dû remplacer par le sampler LTX-2.3 et le LTXVLatentUpsampler, et rediriger les prompts vers Gemma 3 12B. Après ça, la plupart des contrôles se comportaient normalement.

Quelle est la VRAM minimale pour faire tourner LTX-2.3 dans ComfyUI ?

J’ai obtenu des générations d’images uniques utilisables sur 12 Go avec fp8 ou GGUF Q4 pour l’encodeur, l’Étape 1 à mi-résolution et le VAE déchargé. C’est plus fluide à 16 Go. À 24 Go, vous pouvez rester en PyTorch et aller plus vite.

Le pipeline en deux étapes est-il plus rapide ou plus lent qu’en une seule étape ?

Le temps total peut être similaire, mais ça semble plus léger. Je passe moins de temps à relancer des générations en pleine résolution ratées. L’Étape 1 stabilise l’idée : l’Étape 2 la peaufine. Sur une carte 12 Go, c’est aussi la différence entre créer et planter.

Je ne suis pas tombée « enthousiaste » à propos de LTX-2.3 ComfyUI. Plutôt soulagée. Les images ressemblaient à ce que je demandais plus rapidement, et le workflow a arrêté de se battre avec la VRAM. Je vais garder le pipeline en deux étapes. Il est discret, et il fonctionne.

Articles précédents :