# Gemma 4 12B: l’AI multimodale di Google che gira sul laptop

> Fonte: https://francescogruner.it/gemma-4-12b-ai-locale/

Gemma 4 12B è il primo modello della famiglia Gemma che mette testo, immagini e audio dentro un’unica architettura, senza encoder separati. E gira in locale con 16 GB di RAM o VRAM. Niente cloud, niente workstation da 5.000 euro.

 

In pratica:

 

→ multimodalità nativa (testo + immagini + audio)

 

→ 256K token di contesti

 

→ licenza Apache 2.0, quindi anche uso commerciale

 

→ tutto su un laptop con scheda dedicata o memoria unificata

 

Attenzione però: i benchmark che vedi qui sotto sono quelli dichiarati da Google. Vanno verificati nei test reali della community. Lo dico subito perché è la parte che conta.

   

Indice dei contenuti

 [Toggle](#) 

- [Cos’è Gemma 4 12B](#Cose_Gemma_4_12B)
- [La vera novità: niente encoder](#La_vera_novita_niente_encoder)
- [Ti sta piacendo?](#Ti_sta_piacendo)

- [Visione](#Visione)
- [Audio](#Audio)
- [L’audio nativo è la sorpresa](#Laudio_nativo_e_la_sorpresa)
- [Prestazioni: vicine al 26B, ma con i numeri di Google](#Prestazioni_vicine_al_26B_ma_con_i_numeri_di_Google)
- [256K di contesto e Multi-Token Prediction](#256K_di_contesto_e_Multi-Token_Prediction)
- [Come provarlo subito](#Come_provarlo_subito)
- [Cosa fare se qualcosa non parte](#Cosa_fare_se_qualcosa_non_parte)
- [FAQ](#FAQ)
- [In sintesi: vale la pena?](#In_sintesi_vale_la_pena)
- [Fonti](#Fonti)

- [Introducing Gemma 4 12B](#Introducing_Gemma_4_12B)
- [Gemma 4 12B: The Developer Guide](#Gemma_4_12B_The_Developer_Guide)
- [google/gemma-4-12B](#googlegemma-4-12B)
- [Gemma 4](#Gemma_4)
- [Welcome Gemma 4](#Welcome_Gemma_4)

 

## Cos’è Gemma 4 12B

 

Gemma 4 12B è un modello open weight da circa 12 miliardi di parametri, multimodale e con architettura encoder-free: elabora testo, immagini e audio in un solo transformer decoder-only, senza componenti dedicati per visione e audio. Pesa abbastanza poco da girare in locale su hardware consumer.

 

Si piazza nel mezzo della famiglia Gemma 4:

 

→ sotto ci sono E2B ed E4B, pensati per mobile e dispositivi edge

 

→ sopra c’è il 26B A4B MoE e il 31B Dense, i fratelli grossi da workstation o server

 

Il 12B è il compromesso: capacità da modello medio, requisiti da modello locale.

 

Secondo Google serve:

 

- 16 GB di RAM o memoria unificata (tipo i Mac Apple Silicon)
- oppure 16 GB di VRAM su GPU dedicata

 

Con la release, la famiglia Gemma ha superato i 150 milioni di download. Segno che la domanda di modelli aperti e leggeri c’è, ed è grossa.

 

## La vera novità: niente encoder

 

Qui sta il punto interessante, ed è tecnico ma vale la pena capirlo.

 

I modelli multimodali “classici” usano componenti separati per elaborare immagini e audio. Questi encoder convertono i dati in rappresentazioni, che poi passano al modello linguistico. Più pezzi, più memoria, più latenza.

 

Gemma 4 12B butta via questo schema.

                  

## Ti sta piacendo?

 

Ricevi una guida pratica ogni settimana. AI, tool e automazioni.

            Iscriviti gratis             Perfetto, sei dentro.         

### Visione

 

Niente encoder visivo. Al suo posto un embedder da appena 35M di parametri: le patch grezze da 48×48 pixel vengono proiettate nello spazio del modello con una singola moltiplicazione di matrici. Da lì in poi è il modello linguistico a leggere direttamente le immagini.

 

Per fare un confronto: gli altri Gemma 4 medi usano un encoder visivo da ~550M di parametri. Qui sono 35M.

 

### Audio

 

Ancora più radicale. L’encoder audio sparisce del tutto.

 

Il segnale grezzo a 16 kHz viene tagliato in frame da 40ms (640 valori ciascuno) e proiettato linearmente nello stesso spazio dei token testuali. Audio, immagini e testo finiscono nella stessa architettura, con gli stessi pesi.

 

Il risultato concreto:

 

→ meno memoria occupata

 

→ meno latenza quando elabori input multimodali

 

→ fine-tuning in un solo passaggio (LoRA o full), perché non devi co-allenare encoder separati

 

Non è un dettaglio da paper. È quello che permette di far stare il modello su un laptop.

 

## L’audio nativo è la sorpresa

    

Per la prima volta nella famiglia Gemma, un modello medio ingerisce audio nativamente. Prima era roba riservata ai modelli edge piccoli (E2B, E4B).

 

Cosa ci fai:

 

- trascrizione vocale (ASR)
- comprensione audio
- traduzione del parlato (speech-to-translated-text)
- formattazione di contenuti vocali

 

Google ha mostrato una demo con l’app Google AI Edge Eloquent: il modello ascolta una registrazione, la trascrive, la formatta e la traduce. Tutto offline, senza una riga che esce dal dispositivo.

 

Limiti dichiarati: l’audio supporta massimo 30 secondi per input, il video massimo 60 secondi a 1 frame al secondo. Non è ancora il dettatore infinito, ma per assistenti vocali locali è un passo vero.

 

## Prestazioni: vicine al 26B, ma con i numeri di Google

 

Google dichiara che il 12B arriva vicino al fratello maggiore 26B A4B MoE usando meno della metà delle risorse. Ecco i benchmark dichiarati (modelli instruction-tuned):

 BenchmarkGemma 4 12BGemma 4 26B A4BGemma 4 E4BMMLU Pro77,2%82,6%69,4%AIME 2026 (no tools)77,5%88,3%42,5%LiveCodeBench v672,0%77,1%52,0%GPQA Diamond78,8%82,3%58,6%MMMU Pro (vision)69,1%73,8%52,6%MATH-Vision79,7%82,4%59,5% 

Tradotto: sul ragionamento e sul coding il 12B sta dietro al 26B, ma di poco. E stacca nettamente i modelli edge. Per chi costruisce agenti o automazioni in locale, è uno dei migliori rapporti prestazioni/hardware in giro adesso.

 

Ripeto il caveat di prima: sono numeri Google, su benchmark scelti da Google. La prova vera arriva quando la community lo mette contro Qwen, Llama, Mistral e Kimi sui propri task.

 

## 256K di contesto e Multi-Token Prediction

 

Due cose che fanno la differenza nell’uso quotidiano.

 

Il contesto arriva a 256.000 token. Significa dare in pasto al modello documentazione lunga, intere codebase, conversazioni complete, senza spezzettare tutto in riassunti continui. I modelli edge della stessa famiglia si fermano a 128K.

 

Poi c’è il Multi-Token Prediction (MTP). Google rilascia un modello “drafter” dedicato che prevede più token insieme invece di sputarli uno alla volta. Risultato: risposte più rapide e inferenza più efficiente, che su un laptop si sente.

 

## Come provarlo subito

 

Gemma 4 12B è già compatibile con gli strumenti che probabilmente usi già:

 

- Ollama
- LM Studio
- Hugging Face Transformers
- llama.cpp
- MLX (per i Mac)
- vLLM, SGLang
- LiteRT-LM CLI

 

Per il fine-tuning Google indica Unsloth e Hugging Face. Le novità di questa release sul fronte locale:

 

→ app desktop native per macOS (Apple Silicon), via Google AI Edge Gallery, che girano offline

 

→ `litert-lm serve`, un server API OpenAI-compatible locale, da collegare a integrazioni come Continue, Aider o OpenCode

 

I pesi li scarichi dalla [model card su Hugging Face](https://huggingface.co/google/gemma-4-12B-it); i dettagli ufficiali sull’architettura sono nel [Developer Guide di Google](https://developers.googleblog.com/gemma-4-12b-the-developer-guide/).

 

Se hai già un setup di AI locale, non devi rifare niente. Se parti da zero con Ollama, [ne ho scritto una guida completa qui](https://francescogruner.it/ollama-cloud-guida/), e il discorso su come usare modelli locali dentro Claude Code [lo trovi in questo articolo](https://francescogruner.it/claude-code-ollama-glm-guida-2026/).

 

## Cosa fare se qualcosa non parte

 

Tre intoppi tipici quando provi un modello come questo in locale.

 

**“Va in out of memory / si blocca.”** I 16 GB dichiarati sono il minimo per la versione quantizzata. Se carichi i pesi a piena precisione ne servono molti di più. Su Ollama o LM Studio scegli una quantizzazione (Q4_K_M è un buon punto di partenza) e chiudi le altre app che mangiano RAM.

 

**“L’audio non funziona.”** L’input audio è supportato solo su E2B, E4B e 12B, e solo con la pipeline giusta (Transformers con il processor multimodale, o le app Edge). Non aspettarti che ogni client desktop lo gestisca subito. E ricorda il limite dei 30 secondi.

 

**“Gira lentissimo.”** Senza GPU dedicata o memoria unificata veloce, un modello da 12B in locale è lento, soprattutto sui contesti lunghi. Attiva il drafter MTP se il tuo runtime lo supporta, abbassa il budget di token visivi per le immagini (70 o 140 bastano per classificazione e caption) e tieni i prompt corti.

 

## FAQ

    Gemma 4 12B è gratis?  

Sì, i pesi sono scaricabili gratis da **Hugging Face** e **Kaggle** con licenza Apache 2.0, che permette anche l’uso commerciale. Il costo reale è l’hardware su cui lo fai girare.

    Su che hardware gira Gemma 4 12B?  

Google indica **16 GB di RAM o memoria unificata**, oppure **16 GB di VRAM** su GPU dedicata. Funziona su laptop con scheda video discreta o su Mac Apple Silicon. La quantizzazione aiuta a stare nei limiti.

    Cosa vuol dire “encoder-free”?  

Vuol dire che il modello non usa componenti separati per elaborare immagini e audio prima di passarli al modello linguistico. Le immagini e l’audio grezzi vengono proiettati direttamente nello spazio del modello, riducendo memoria e latenza.

    Gemma 4 12B capisce l’italiano?  

Sì. Gemma 4 supporta più di **140 lingue in pre-training** e oltre **35 lingue out-of-the-box**, italiano incluso. Le prestazioni sull’italiano vanno comunque verificate nei test reali.

    Meglio Gemma 4 12B o un modello da cloud?  

Dipende dal task. In locale vinci su **privacy, costo a regime e zero dipendenza dal cloud**. Sui task pesanti e i contesti enormi, un modello cloud di punta resta più potente e veloce. Gemma 4 12B è il punto giusto se vuoi capacità decenti senza mandare dati fuori.

     

## In sintesi: vale la pena?

 

Torniamo al punto di partenza. La cosa interessante di Gemma 4 12B non è il numero di parametri. È l’architettura encoder-free che unifica testo, immagini e audio nello stesso modello e lo fa stare su un laptop.

 

Se questa strada regge nei test reali, è il tipo di release che sposta l’asticella dell’AI locale: multimodale, con audio nativo, 256K di contesto e licenza permissiva, senza cloud.

 

Per chi sviluppa agenti, automazioni o app multimodali con un occhio a privacy e costi, è uno dei candidati più seri del 2026. Con un però onesto: aspetta i confronti della community contro Qwen, Llama e Mistral prima di buttarci sopra un progetto in produzione.

 

Se vuoi i miei test su questi modelli locali prima degli altri, iscriviti alla [newsletter settimanale](https://francescogruner.it). E se il setup non parte, scrivimi nella [community Facebook](https://www.facebook.com/groups/1614848349007261).

 

## Fonti

  

Per la stesura dell’articolo sono state consultate fonti ufficiali Google, Google DeepMind, Google Developers e Hugging Face relative a Gemma 4 12B, alla sua architettura encoder-free, ai requisiti hardware e al supporto multimodale.

  [Google Blog  

### Introducing Gemma 4 12B

 

Annuncio ufficiale di Google su Gemma 4 12B, con panoramica su architettura encoder-free, audio nativo, requisiti hardware da 16 GB, licenza Apache 2.0 e Multi-Token Prediction.

 Apri fonte](https://blog.google/innovation-and-ai/technology/developers-tools/introducing-gemma-4-12b/) [Google Developers  

### Gemma 4 12B: The Developer Guide

 

Guida tecnica per sviluppatori: spiega come funziona l’architettura encoder-free, la proiezione diretta di immagini e audio, il supporto locale e gli scenari agentici.

 Apri fonte](https://developers.googleblog.com/gemma-4-12b-the-developer-guide/) [Hugging Face  

### google/gemma-4-12B

 

Model card ufficiale del modello Gemma 4 12B, con dettagli su licenza, architettura, input multimodali, contesto da 256K token, lingue supportate e modalità d’uso.

 Apri fonte](https://huggingface.co/google/gemma-4-12B) [Google DeepMind  

### Gemma 4

 

Pagina ufficiale della famiglia Gemma 4, utile per contestualizzare il 12B rispetto agli altri modelli della serie, ai benchmark, agli scenari on-device e agli agentic workflow.

 Apri fonte](https://deepmind.google/models/gemma/gemma-4/) [Hugging Face Blog  

### Welcome Gemma 4

 

Approfondimento sulla famiglia Gemma 4, con dettagli su dimensioni dei modelli, supporto multimodale, contesto, deployment locale, llama.cpp, MLX, Transformers e fine-tuning.

 Apri fonte](https://huggingface.co/blog/gemma4)