Google a publié Gemma 4 12B le 3 juin 2026, et il occupe exactement le créneau que la plupart des développeurs qui travaillent en local attendent : assez puissant pour bien raisonner, assez léger pour tourner sur un portable que vous possédez déjà.

La grande nouveauté, c’est cette taille intermédiaire. La gamme Gemma 4 précédente proposait un petit modèle edge et un modèle phare 26B, avec un vide entre les deux. Le 12B comble ce vide. Google affirme que ses performances dans les benchmarks approchent celles du modèle 26B tout en utilisant moins de la moitié de la mémoire, et l’ensemble passe sous la barre des 16 Go que la plupart des Mac récents et des GPU milieu de gamme dépassent déjà.

Ce guide présente les nouveautés de la variante 12B, puis explique comment l’exécuter avec Ollama et le connecter à OpenCode comme assistant de code local et privé.

Les nouveautés de Gemma 4 12B

  • 12 milliards de paramètres, positionné entre le modèle edge E4B et le modèle phare 26B Mixture-of-Experts.
  • Entrée multimodale native. Le texte, la vision et l’audio passent par le même modèle. L’architecture est sans encodeur : les images transitent par un module d’embedding léger, et l’audio brut est projeté directement dans l’espace des tokens de texte. Une architecture plus simple qu’avec un encodeur de vision rapporté.
  • Un raisonnement qui approche celui du modèle 26B. Google rapporte que les performances du 12B dans les benchmarks approchent celles de la variante 26B, avec moins de la moitié de l’empreinte mémoire.
  • Des drafters Multi-Token Prediction (MTP) pour réduire la latence, ce qui est précieux en usage interactif, lorsque vous attendez chaque token.
  • Conçu pour les workflows agentiques : l’appel d’outils et les boucles de code multi-étapes sont pris en charge nativement, au lieu d’être un ajout de dernière minute.
  • Licence Apache 2.0. Usage commercial, fine-tuning, redistribution. La famille Gemma 4 a désormais dépassé les 150 millions de téléchargements.

Les poids sont disponibles sur Hugging Face et Kaggle, avec une prise en charge immédiate par Transformers, llama.cpp, MLX, SGLang et vLLM. Ollama repose sur llama.cpp et GGUF, donc le 12B s’y exécute de la même manière que les modèles Gemma 4 précédents.

Gemma 4 12B vs le reste de la famille

VarianteIdéal pourMémoire
E4B (edge)Téléphones, systèmes embarqués et applications sur appareilMinimale
12B (nouveau)Code local, vision et audio sur un portable16 Go+
26B MoE (modèle phare)Raisonnement plus lourd, travail multi-fichiers important24 Go+

Si vous disposez d’une machine plus légère ou si vous préférez simplement le modèle par défaut plus petit, l’ancienne configuration Gemma 4 + Ollama + OpenCode reste valable. Le 12B est la mise à niveau à privilégier quand vous avez de la marge en mémoire et que vous voulez un raisonnement nettement plus solide sans passer au 26B.

Prérequis

  • Un Mac avec Apple Silicon (M1–M5) et au moins 16 Go de mémoire unifiée, ou un PC avec un GPU de 16 Go ou plus
  • Homebrew sur macOS
  • OpenCode installé (voir opencode.ai)

Le seuil indiqué par Google est de 16 Go. À ce niveau, vous pouvez exécuter le 12B confortablement pour le travail quotidien. Si vous avez 24 Go ou plus, les longues sessions et les grandes fenêtres de contexte ne sont plus un souci.

Étape 1 : Installer Ollama

Sur macOS :

brew install --cask ollama-app
open -a Ollama

Sur Linux :

curl -fsSL https://ollama.com/install.sh | sh

Attendez que l’icône apparaisse dans la barre de menus (macOS) ou que le service démarre, puis confirmez que le serveur est bien opérationnel :

ollama list

L’API locale est accessible sur http://localhost:11434.

Étape 2 : Télécharger Gemma 4 12B

ollama pull gemma4:12b

Avec la quantification 4 bits par défaut, le téléchargement représente environ 8 Go. Vérifiez qu’il est bien présent :

ollama list
# NAME             ID              SIZE      MODIFIED
# gemma4:12b       ...             ~8 GB     ...

Lancez un test rapide :

ollama run gemma4:12b "Write a small TypeScript function that debounces a callback"

Confirmez que le GPU fait bien le travail :

ollama ps
# Should show a CPU/GPU split, e.g. 12%/88% CPU/GPU

Sur Apple Silicon, les versions récentes d’Ollama utilisent automatiquement le backend MLX d’Apple, donc aucune configuration supplémentaire n’est nécessaire pour l’accélération.

Tag introuvable ? Gemma 4 12B est tout récent, donc si gemma4:12b n’est pas encore dans le registre Ollama, téléchargez le GGUF officiel depuis Hugging Face et importez-le, ou mettez à jour Ollama (brew upgrade ollama-app) et réessayez.

Étape 3 : Connecter Gemma 4 12B à OpenCode

OpenCode lit sa configuration dans ~/.config/opencode/opencode.jsonc. Ajoutez Ollama comme fournisseur personnalisé :

{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:12b": {}
      }
    }
  }
}

Ollama ne valide pas les clés, mais OpenCode attend quand même une entrée d’authentification. Ajoutez une valeur factice dans ~/.local/share/opencode/auth.json :

{
  "ollama": {
    "type": "api",
    "key": "ollama"
  }
}

Redémarrez OpenCode, exécutez /models, puis basculez sur ollama/gemma4:12b. Vous avez maintenant un assistant de code qui n’envoie jamais la moindre ligne de votre code hors de votre machine.

Étape 4 : Garder le modèle en mémoire

Par défaut, Ollama décharge un modèle après environ cinq minutes d’inactivité, ce qui signifie un démarrage à froid à chaque fois que vous revenez au terminal. Gardez-le chargé :

launchctl setenv OLLAMA_KEEP_ALIVE "-1"

Redémarrez Ollama pour que la modification soit prise en compte. Pour conserver ce réglage après un redémarrage, ajoutez cette ligne dans ~/.zshrc :

export OLLAMA_KEEP_ALIVE="-1"

Depuis l’icône Ollama dans la barre de menus, vous pouvez aussi activer Lancer à l’ouverture de session pour que le serveur soit prêt avant vous.

Ce que Gemma 4 12B gère bien dans OpenCode

Les paramètres supplémentaires et les drafters MTP se font surtout sentir sur les tâches qui étaient un peu justes avec le modèle plus petit :

  • Modifications en plusieurs étapes. Il conserve un plan cohérent sur plusieurs fichiers, mieux que ne le faisait le 8B, et les petits refactorings aboutissent plus souvent du premier coup.
  • Explication et revue de code. Demandez ce que fait un module ou où un bug pourrait se cacher, et les réponses sont plus précises.
  • Boilerplate et scaffolding. Les fichiers de configuration, bouchons de test, gestionnaires de routes et couches CRUD sortent propres.
  • Entrée visuelle. Comme le 12B est multimodal, vous pouvez lui fournir une capture d’écran d’un message d’erreur ou d’une maquette UI et demander un correctif ou un composant, sans avoir à mettre en place un modèle de vision séparé.

Là où il montre encore ses limites

  • Refontes transverses de grande ampleur. Les modifications coordonnées sur une douzaine de fichiers finissent encore par dévier. Le 12B fait mieux que le 8B, mais le problème n’est pas réglé.
  • Le débogage le plus complexe. Les bugs qui traversent plusieurs couches d’abstraction ou nécessitent une connaissance métier approfondie restent le domaine où un modèle cloud de pointe justifie encore sa place.
  • Contexte très long sur 16 Go. Le modèle supporte de grandes fenêtres de contexte, mais la qualité se dégrade quand la mémoire est trop sollicitée sur une machine de 16 Go. Gardez des entrées de contexte modérées, ou passez à 24 Go+.

Passez en hybride : Gemma 4 12B local + modèles cloud

La configuration que la plupart des gens finissent par adopter : le local pour les 70 % de tâches courantes et le cloud pour les 30 % difficiles. Voici où trouver chacun :

  • haimaker.ai — une seule clé API pour Claude Opus, GPT-5, Gemini Pro et des centaines d’autres modèles, avec une tarification unifiée et des benchmarks pour comparer avant d’orienter vos requêtes.
  • Ollama — votre Gemma 4 12B local, gratuit et privé, pour les modifications et lectures quotidiennes.
  • Appels directs aux API des fournisseurs — si vous n’avez besoin que d’un seul fournisseur cloud et que vous préférez gérer vous-même les clés pour chaque fournisseur.

Ajoutez Haimaker à côté d’Ollama dans OpenCode :

{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:12b": {}
      }
    },
    "haimaker": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.haimaker.ai/v1"
      },
      "models": {
        "anthropic/claude-sonnet-4-6": {},
        "openai/gpt-5": {},
        "google/gemini-2.5-pro": {}
      }
    }
  }
}

Ajoutez votre clé Haimaker dans auth.json :

{
  "ollama": {
    "type": "api",
    "key": "ollama"
  },
  "haimaker": {
    "type": "api",
    "key": "YOUR_HAIMAKER_API_KEY"
  }
}

Utilisez Gemma 4 12B pour les tâches rapides, puis basculez avec /models vers Sonnet ou GPT-5 quand une tâche devient difficile. Votre facture cloud ne représente plus qu’une fraction de ce que coûterait l’exécution de tout sur un modèle de pointe. Pour éviter de passer manuellement d’un modèle à l’autre, le routeur automatique de Haimaker peut détecter la complexité de la tâche et choisir le modèle à votre place.

Inscrivez-vous sur haimaker.ai et parcourez l’ensemble du catalogue de modèles.

OBTENEZ VOTRE CLÉ API HAIMAKER

Dépannage

Le fournisseur n’apparaît pas dans /models. Redémarrez OpenCode après avoir modifié la configuration. Il ne recharge pas opencode.jsonc en cours d’exécution.

« Modèle introuvable. » Exécutez ollama list et vérifiez que l’ID du modèle correspond exactement, généralement gemma4:12b. Si le tag n’est pas encore dans le registre, consultez la note de l’étape 2 concernant l’import du GGUF depuis Hugging Face.

Erreurs d’authentification avec Ollama. La valeur factice "key": "ollama" dans auth.json suffit. OpenCode a simplement besoin qu’une entrée existe.

Génération lente. Assurez-vous d’utiliser une version récente d’Ollama pour bénéficier de l’accélération MLX sur Apple Silicon (ollama --version). Fermez les applications gourmandes en mémoire. Sur 16 Go, quelques onglets du navigateur qui lisent une vidéo peuvent faire basculer la machine en swap.

Baisse de qualité sur les prompts longs. C’est la conséquence d’une mémoire trop sollicitée sur une machine de 16 Go. Gardez des entrées de contexte modestes, ou passez à 24 Go+ pour avoir de la marge.

Commandes Ollama utiles

CommandeDescription
ollama listLister les modèles téléchargés
ollama psAfficher les modèles en cours d’exécution et l’utilisation de la mémoire
ollama run gemma4:12bChat interactif
ollama stop gemma4:12bDécharger de la mémoire
ollama pull gemma4:12bMettre à jour vers la dernière version
ollama rm gemma4:12bSupprimer le modèle

En résumé

Gemma 4 12B est le modèle local que beaucoup attendaient : multimodal, sous licence Apache, et assez performant pour gérer l’essentiel du code quotidien sur un portable 16 Go. Exécutez-le via Ollama, connectez OpenCode à ce modèle, et vous disposez d’un assistant privé pour le travail courant. Gardez un modèle cloud à portée d’un simple /models pour les problèmes difficiles, et vous conservez la rapidité et la confidentialité de l’exécution locale sans vous heurter à ses limites de raisonnement.

Vous débutez avec les configurations locales ? Commencez par le guide Gemma 4 + OpenCode pour le modèle par défaut plus petit, ou la configuration Gemma 4 + OpenClaw si vous utilisez OpenClaw comme agent. Pour les tarifs cloud, consultez le catalogue de modèles.