Qwen3.8 vs Gemma 4 : quel LLM local pour GPU 24 Go ?

Vous voulez exécuter un LLM open weight sur votre propre GPU pour traiter des données sensibles sans rien envoyer vers un cloud américain ? Le choix du modèle décide de la faisabilité, de la qualité et du budget. En 2026, une carte avec 24 Go de VRAM (comme le RTX 4090) reste le point d'entrée réaliste pour de l'inférence locale, et trois modèles y tiennent en quantisation Q4 : Qwen3.8-27B, Qwen3.6-27B et Gemma 4 31B-it.

Réponse directe : le test de Kingy.ai (un RTX 4090, llama.cpp, suites synthétiques) désigne Qwen3.8-27B comme le meilleur choix par défaut sur un GPU 24 Go : même vitesse de décode que Qwen3.6 (~49 tokens/s), mais 12/12 tâches de codage au premier essai, 39/40 cas de raisonnement et 23/24 questions documentaires. Gemma 4 31B-it reste l'alternative crédible pour les appels d'outils stricts et la vision. Qwen3.6-27B ne se justifie plus que pour une intégration existante déjà stabilisée.

Pourquoi un LLM local intéresse une entreprise européenne

Un modèle exécuté sur vos serveurs garde vos données en interne. Aucun prompt, aucun document, aucun log ne quitte votre infrastructure. C'est la réponse structurelle aux deux questions posées par l'IA cloud :

• L'Article 44 du RGPD interdit les transferts de données personnelles hors UE sans garanties adéquates.
• Le CLOUD Act (2018) permet aux autorités américaines d'exiger l'accès aux données détenues par des entreprises US, même lorsqu'elles sont stockées en Europe.

Un déploiement local sur du matériel que vous possédez élimine ces deux risques à la source. C'est le cœur de l'IA souveraine : des modèles open weight sous licence Apache 2.0 qui tournent sur votre infrastructure, pour un coût d'inférence marginal indépendant des tarifs d'API. La CNIL documente les bonnes pratiques de l'IA sur cnil.fr, et l'article open weights : le débat qui façonne l'IA souveraine explique pourquoi cette voie gagne du terrain face aux modèles propriétaires.

Comment le comparatif a été mené

Kingy.ai a mesuré les trois modèles sur un seul RTX 4090 (24 564 MiB), avec llama.cpp (commit b10453), Ubuntu 22.04.3, driver NVIDIA 570.195.03 et CUDA 11.8, sur un Ryzen 9 7950X avec 128 Go de RAM et sans swap.

Les réglages étaient communs : offload GPU complet, flash attention, cache K/V en F16, batch 2 048, décode spéculative désactivée pour les tests de qualité. Deux couloirs de comparaison ont été définis :

• Q4 égalitaire : les trois fichiers Q4_K_M exacts, mêmes réglages.
• Meilleur profil dans 24 Go : seuls les changements utiles sont autorisés (Gemma passe son cache K/V en Q8_0 pour tenir le 64K).

La suite de tests contient 50 vérifications d'instructions, 40 cas de raisonnement sur trois seeds, 30 appels d'outils simples, 10 appels multi-étapes, 12 tâches de codage, 24 questions documentaires (packs 8K et 32K) et 20 images synthétiques. Le runtime compte 27,32 milliards de paramètres pour Qwen3.8, 26,90 pour Qwen3.6 et 30,70 pour Gemma.

Quels fichiers Q4 choisir et combien ils pèsent

Modèle	Fichier GGUF	Taille
Qwen3.8-27B	Qwen3.8-27B-Q4_K_M.gguf	15,932 GiB
Qwen3.6-27B	Qwen3.6-27B-Q4_K_M.gguf	15,662 GiB
Gemma 4 31B-it	gemma-4-31B-it-Q4_K_M.gguf	17,065 GiB

Les trois cartes modèles déclarent 262 144 positions maximales. Architecture réelle : 64 couches texte pour les Qwen (48 en attention linéaire, 16 en attention pleine, une couche pleine tous les 4 niveaux) et 60 couches pour Gemma (50 en attention glissante, 10 pleines). Les encodeurs vision comptent 27 couches pour les trois. Cette limite déclarée est une borne d'architecture, pas une promesse : le contexte le plus stable mesuré reste 64K.

Quel modèle choisir selon la tâche ?

Priorité	Choix	Résultat mesuré
Agents de codage, édition de dépôt	Qwen3.8-27B	12/12 pass@1, 35/36 runs seedés
Raisonnement sous budget de tokens	Qwen3.8-27B	39/40 pass@3, 117/120
Questions sur documents privés	Qwen3.8-27B	23/24, devant Gemma (22/24)
Appels d'outils stricts	Gemma 4 31B-it	90/90 simples, 30/30 multi-étapes
Tâches vision	Gemma 4 31B-it	19/20, contre 18/20 pour Qwen3.8
Écriture et relecture	Égalité	94/96, 93/96, 93/96
Contexte 64K avec marge	Qwen3.8 ou Qwen3.6	4,20 GiB libres en F16 K/V
Migration minimale	Qwen3.6-27B	Stack existante déjà validée

Le verdict du test : pour un nouveau déploiement, Qwen3.8-27B est difficile à battre. Gemma gagne sur les appels d'outils déclarés, la vision et l'écriture, mais consomme plus de VRAM et sa boucle de codage itérative est moins fiable. Qwen3.6 ne reste pertinent que si votre pipeline est déjà réglé dessus. Le test complet et sa méthodologie sont publiés sur kingy.ai.

Qu'est-ce qui tient vraiment dans 24 Go ?

Un fichier de poids de 16 à 17 GiB ne laisse pas sept ou huit GiB pour le contexte : le runtime, le cache K/V, les projecteurs vision et la décode spéculative consomment aussi de la VRAM. "Ça charge", "ça répond à un prompt court" et "c'est confortable en session longue" sont trois états différents.

Profil	8K	32K	64K
Qwen3.8-27B, F16 K/V	16 626 MiB	18 186 MiB	20 266 MiB, passe, 4 298 MiB libres
Qwen3.6-27B, F16 K/V	16 626 MiB	18 186 MiB	20 266 MiB, passe
Gemma 4 31B-it, F16 K/V	19 962 MiB	21 906 MiB	OOM CUDA
Gemma 4 31B-it, K/V Q8_0	non mesuré	non requis	21 956 MiB, passe

À 64K, les deux Qwen passent avec un cache F16 et 4,20 GiB libres. Le cache F16 de Gemma échoue à l'allocation ; en passant son cache K/V en Q8_0, Gemma tient le 64K (21 956 MiB) mais avec seulement 2,55 GiB libres. Un environnement de bureau, un projecteur vision, une slot parallèle ou une sortie longue peuvent consommer cette marge rapidement.

Vitesse : débit et latence mesurés

Qwen3.8 et Qwen3.6 sont au coude à coude sur toutes les mesures de vitesse. Gemma est à égalité sur les prompts courts puis décroche à mesure que le contexte grandit, avec un décode environ 8,3% plus lent.

Mesure	Qwen3.8-27B	Qwen3.6-27B	Gemma 4 31B-it
Prompt 512 tokens	3 001 tok/s	2 980 tok/s	2 975 tok/s
Prompt 8 192 tokens	2 844 tok/s	2 840 tok/s	2 682 tok/s
Prompt 32 768 tokens	2 554 tok/s	2 555 tok/s	2 235 tok/s
Décode 256 tokens	49,09 tok/s	49,04 tok/s	45,00 tok/s
TTFT à chaud (512)	0,107 s	0,108 s	0,421 s

La latence avant premier token est le vrai écart : 0,107 s pour Qwen3.8 contre 0,421 s pour Gemma sur un prompt de 512 tokens. Pour une interface utilisateur, cette différence se ressent immédiatement. Avant d'acheter une carte, estimez votre besoin VRAM avec le simulateur VRAM.

La décode spéculative (MTP) vaut-elle le coup ?

Le mode MTP (multi-token prediction) accélère la génération, au prix de la VRAM et d'un comportement potentiellement différent. Sur 15 prompts pratiques :

• Qwen3.8 : 1,64× plus rapide en bout en bout, 1,66× sur le décode, +1 032 MiB de VRAM. Les sorties avec et sans MTP n'étaient identiques dans aucune paire (0/15).
• Gemma : 1,52× en bout en bout, 1,67× sur le décode, +574 MiB, drafter de 0,479 GiB. Sorties identiques dans 1/15 paires.

MTP est un compromis volontaire entre vitesse et comportement, pas un interrupteur transparent. Gardez-le désactivé si la reproductibilité des sorties est une exigence, activé si le débit prime.

TL;DR

Pour un déploiement local sur GPU 24 Go en 2026 : Qwen3.8-27B est le meilleur choix par défaut (codage, raisonnement, questions documentaires, mêmes performances que Qwen3.6). Gemma 4 31B-it l'emporte sur les appels d'outils stricts et la vision, au prix d'une VRAM plus élevée et d'une latence de premier token environ 4 fois plus lente. Qwen3.6-27B ne se justifie que pour une intégration existante.

Le contexte stable maximum mesuré est 64K (pas les 262K annoncés) et la marge VRAM à 64K reste fine : planifiez vos sessions et votre décode spéculative avec le simulateur VRAM.

Un modèle open weight sur votre GPU, c'est de l'IA souveraine conforme à vos contraintes RGPD, sans dépendance aux tarifs d'API. En tant que freelance IA, j'accompagne les PME et startups sur ces architectures : intégration RAG, choix de modèle et dimensionnement GPU. Pour passer en production, lisez aussi le guide LLM local et RGPD.

Vous hésitez entre un LLM local et une API cloud pour vos données sensibles ? Parlons-en.