Gemini 4: Neon local install, is it possible? Questions Answered

Logeshwaran
—

Gemini Neon 4 went live on the 18th. By the next morning my inbox had the usual question: can I install it on my own machine? Short answer as usual is — no. Long answer is below, along with what to install instead and the fake files already doing the rounds.

⚡ Quick Answer

Can you run Gemini 4 Neon locally? No. There are no weights, no GGUF, no Ollama tag. Nothing to download.

Run this instead: ollama run gemma4:12b — Gemma 4, Google's open family, Apache 2.0.

See a file called "gemini-4-neon.Q4_K_M.gguf"? It is not from Google. It does not exist. Walk away.

Need Neon itself? API only. Model ID gemini-4-neon, paid tier, $3 in / $15 out per million tokens.

The exact searches, answered,as usual: 

If you landed here from Google at 1am, skip to your line.

Can you run Gemini 4 Neon locally?

No. Closed model, no weights published, no licence that lets you host it. There is nothing to download.

Is there a Gemini 4 Neon GGUF download?

No, and there cannot be one yet. A GGUF is a converted weights file. No weights, nothing to convert. If a site is offering gemini-4-neon.Q4_K_M.gguf, it is selling you malware or a renamed Gemma file.

Is there an Ollama tag for it?

No. Ollama hosts open-weight models. Gemini is not one, and never has been.

Are the weights on Hugging Face?

No. Gemma weights are on Hugging Face and Kaggle. Gemini weights are not, for any generation.

So what do I run instead?

Gemma 4. On a normal laptop: ollama run gemma4:12b. The rest of this post is about making that actually work.

What "locally" actually means

Three different things get called local, and the confusion is why people end up disappointed.

Local inference — the weights sit on your disk, the maths runs on your GPU, nothing leaves the machine. You can unplug the network and it still answers. That is Gemma 4 in Ollama.

Self-hosted — your own server, your own cloud account. Same thing as far as your laptop is concerned.

Private cloud — someone else's GPU, a contract saying they will not train on your data. This is what enterprises usually mean when they say "we need it on-prem", and it is the one Neon can do.

Neon does the third. It cannot do the first. Most "how to run X locally" articles quietly answer the third question while pretending to answer the first. This one doesn't.

Where Neon sits in the Gemini 4 family

Four models in six weeks. The names make them sound interchangeable. They are not, and knowing which is which saves you money.

ModelArrivedPrice / 1M tokensBuilt for
Argon13 Oct$2 / $10
$4 / $20 from 1 Dec
Long scientific and agentic reasoning. Thinking stops at high.
Carbon10 Nov$2 / $10
$4 / $20 from 1 Dec
The flagship. Hardest work, cyber defence. Defaults to medium.
Hydrogen12 Nov—Fast everyday work. Defaults to high.
Neon18 Nov$3 / $15
cached $0.15
Carbon-ish quality at Flash speed. Defaults to high.

All four share one 1,048,576-token pool across input and output — thinking tokens included. None is on the free tier. That catches people out on their first request.

Watch the calendar if you are budgeting. Argon and Carbon jump from $2/$10 to $4/$20 on 1 December. Neon sits at $3/$15 and does not move. So from December, Neon is the cheap one — a detail the launch posts skipped.

What Neon actually scores

Google's numbers, not mine. They chose the tests, so read them with that in mind.

BenchmarkNeonWhat it measures
Artificial Analysis Intelligence Index61 · #3Blended reasoning, measured at xhigh
AA Coding Agent Index58.6 · #1Agentic coding, multi-step edits
Vals Index70.9% · #2Independent evaluation suite
Terminal-Bench 4.165.2%Real command-line tasks
FrontierCode 2.046.2%Production-grade code, at high
SWE-sweep12.8% → 39.0%Mini harness vs Antigravity

That last row is the one I would frame and hang on the wall. Same model, same weights, same day — 12.8% in a basic harness, 39.0% inside Antigravity. Tripled by the software around it.

Which means most "which model is best" arguments are asking the wrong question. If you are choosing a coding setup, the harness matters more than the model, and switching harness is free while switching models costs money every month.

Why it cannot run on your machine

Three reasons. Any one would be enough on its own.

1. No weights were published

Gemma ships weights on Hugging Face and Kaggle. Gemini never has. Google's own announcement lists where Neon lives — API, AI Studio, Gemini for business, Antigravity, the Gemini app. No download link, because there is no file.

2. Nobody outside Google knows how big it is

The model card says Neon is adapted from Carbon. That is all it says. No parameter count, no architecture. Which means you cannot even estimate the disk space, let alone the VRAM. Every "Neon 400B" headline you have seen is a guess someone made for a thumbnail.

3. It is served, not shipped

A frontier model is not a file you drag into a folder. Weights, tokenizer, serving stack, tuned to their hardware. A leaked checkpoint would not open in Ollama without months of work nobody has done, because nobody has the checkpoint.

The fake downloads are already online

This is the part I actually care about. Within hours of the announcement there were pages offering "Gemini 4 Neon GGUF", torrent bundles, and a file called gemini-4-neon.Q4_K_M.gguf — for a model that has never existed as a file.

Three flavours, none of them good:

  • An .exe or .msi that asks you to switch off your antivirus "because the model is large". Nothing legitimate has ever asked that.
  • A real Gemma file with the name changed, so the page can rank for a term nobody can honestly satisfy.
  • No file at all. A countdown, a survey, your email address.

The 30-second check

Learn this once and you will use it every launch for the rest of the year.

  1. Hugging Face, google organisation. Gemma weights live there. Not there, does not exist.
  2. ollama.com/library. Ollama adds real models within days.
  3. Google's own announcement post. If they published weights, they link them — the Gemma 4 launch is what that looks like.
  4. File size versus parameter count. A 200B model at 4-bit is about 100 GB. A 4 GB download claiming to be one is a small model wearing a costume.

All four have been no for Neon since day one.

We have been here before, twice this year — with Gemini 3.8 Flash and with Argon last month. Same playbook every time.

What to run instead: Gemma 4

Jake rang me about this one, which is how I know it is worth writing down. He had seen a video thumbnail, spent an hour hunting for a download, and found three sites offering one. All three were junk. His actual question, once he calmed down, was the sensible one: what do I install instead?

Ethan's answer, which I am stealing: "Gemini is the one you call. Gemma is the one you install. Everything else is somebody selling you a renamed file."

Gemma 4 is Google's open family. Apache 2.0, weights on Hugging Face and Kaggle, supported by Ollama, llama.cpp, LM Studio, MLX, vLLM and SGLang. It is not Neon and I am not going to pretend it is. But a 26B model that only fires 4B parameters per token, sitting on your desk, covers most of what people actually want a local model for.

Ollama tagDownloadContextInputsWho it is for
gemma4:e2b~7.2 GB128KText, image, audioOld laptops, small VMs, Raspberry Pi territory
gemma4:e4b~9.6 GB128KText, image, audioAny laptop. Also what gemma4:latest actually gives you
gemma4:12b~7.6 GB256KText, image16 GB machine. The one most of you should install
gemma4:26b~18 GB256KText, image24 GB card, and you hate waiting
gemma4:31b~20 GB256KText, imageBest open quality. Only if you have measured that you need it

One trap before you type anything. gemma4:latest is e4b, not the 12B. Run the bare name expecting the big one, get the small one, spend twenty minutes wondering why the answers are thin. Name the size.

Sizes move as new quantisations land. Check the library page before you plan a download around a number.

26B or 31B? The mixture-of-experts question

The 26B is a mixture of experts, and that phrase is doing a lot of work. Instead of running all 25.8 billion parameters for every token, it routes each token through 8 of its 128 experts plus one shared one. About 3.8 billion parameters fire per word. The other 22 billion sit and wait.

Which splits memory from speed. You still hold all 26B in RAM — about 18 GB at Q4 — but generation behaves like a much smaller model.

ModelTypeMemorySpeedQuality
12bDense~7.6 GBModerateGood
26bMoE, ~4B active~18 GBFastVery good
31bDense~20 GBSlowBest

So if you have 24 GB, take the 26B. It needs 31B-class memory and answers near 12B speed, which is the best deal in the family. The 31B is for people who want the best answer and genuinely do not mind waiting.

And if you have not run the comparison yourself, be honest about that before you argue about it online. I have not run a proper blind test either. What I can tell you is that the 26B is the one I would hand to someone who just wants it to work.

If not Gemma 4, then what?

Gemma 4 is a good default, not the only option. Two specialists worth knowing:

Recursive Flint — a 40B coding model that only activates about 2.5B parameters per token. Faster than it has any right to be, and better at code than Gemma 4 31B.

Nemotron 3.5 Super VL — heavy vision work, and heavy hardware to match. If you are not doing image or video analysis, skip it.

The pattern worth remembering is that a specialist beats a generalist at its own job. One use case, pick the specialist. Several, install Gemma 4 12B and stop reading model release posts for a month. You will get more done.

Quantisation, explained properly

Every model you download is compressed. The original weights are 16-bit floats; quantisation squeezes them to 4 or 8 bits and loses a little quality doing it. This is the single biggest factor in whether a model fits your machine, and most tutorials skip straight past it to the command.

Real file sizes for Gemma 4 12B, measured from published GGUF builds. They vary a few hundred MB between converters:

QuantWeights+ KV @16KQuality
Q2_K~4.8 GB~7.8 GBDamaged. Only if nothing else fits
Q3_K_M~6.1 GB~9.1 GBNoticeable. Fine for chat, not for code
Q4_K_M (default)~7.4 GB~10.4 GBThe one you want
Q5_K_M~8.5 GB~11.5 GBVery close to full. Worth it on 16 GB
Q6_K~9.8 GB~12.8 GBNear-lossless, lighter than Q8
Q8_0~12.7 GB~15.7 GBEffectively lossless. Needs 24 GB
BF16~23.8 GB~26.8 GBReference only. Not for a home machine

Three things the table cannot show you. Q4_K_M is the answer for nearly everyone — below it quality drops faster than memory saves, above it you pay 60% more for a difference you will not hear. The cache is not in the download, which is why a 7.4 GB file can still refuse to load on an 8 GB card: the model needs room for the conversation too. And you can halve the cache in llama.cpp with --cache-type-k q8_0 --cache-type-v q8_0, at a small quality cost and a big memory saving.

The context window trap

12B advertises 256K context. True, and misleading, and it causes more failed installs than anything else on this page.

Memory for context grows roughly linearly. At 16K the cache is about 3 GB on this model. At 128K it is closer to 24 GB. A card that runs 12B happily at 8K will crawl or refuse at 128K — which is exactly why Ollama's default context is far below the model's maximum.

Size the model for the context you use, not the context on the box. Chat and coding fit in 8K–16K. Whole repositories and long PDFs are when a bigger card, or an API call, starts making sense.

Running Gemma 4: the one command you need

You do not need a tutorial to find out whether this works. Three commands.

# Windows and macOS — install from ollama.com/download first,
# then open a NEW terminal (an old one won't know the command yet)
ollama pull gemma4:12b
ollama run gemma4:12b

# Kali, Ubuntu, Debian, WSL — official install script
curl -fsSL https://ollama.com/install.sh | sh
ollama run gemma4:12b

# is the GPU actually doing the work?
ollama ps

If it answers, you are done and you have spent nothing. If it is slow, ollama ps tells you why — 100% CPU on a machine with a graphics card means the driver is not being used, and that is a fixable problem, not a hardware problem.

One caveat. Kali in VirtualBox or VMware cannot see your graphics card, so everything runs on the CPU. In a VM, use gemma4:e4b and expect it to be slow.

For the step-by-step versions with GPU drivers and VM settings, the guides already on the site: Gemma 4 on Windows 11 and 10, Gemma 4 on Kali Linux, and updating Ollama on any platform feel free to check them folks!

It will take some 30mins for that file to download, again depending on your internet speed.

The llama.cpp route, if you want the controls

Ollama is llama.cpp with the sharp edges filed off. When you want to set context, GPU layers and cache type yourself, go to the source.

# one-shot answer
llama-cli -m gemma-4-12B-it-Q4_K_M.gguf -p "explain what a VLAN is" -st

# server with a web UI on localhost:8080
llama-server -m gemma-4-12B-it-Q4_K_M.gguf -ngl 99 -c 8192 -fa on

# or straight from Hugging Face, no manual download
llama-server -hf user/gemma-4-12B-it-GGUF:Q4_K_M -ngl 99 -c 8192 -fa on

-ngl 99 puts every layer on the GPU. -c 8192 sets the context and is the number that decides your memory use. -fa on enables flash attention. If a model will not fit, lower -c before you buy anything — it is almost always the answer.

llama-server also serves an OpenAI-compatible endpoint on port 8080, so anything that talks to OpenAI can talk to it.

LM Studio, if you would rather not use a terminal

Model browser, chat window, local server, no command line. Install it, search "gemma 4", pick a quantisation from the table above, load. The RAM estimate it shows before loading is the useful part — trust it over the marketing.

It starts an OpenAI-compatible server on port 1234, and unlike Ollama it refuses loudly. If a model will not fit, it names the quantisation that would. When it errors instead, our LM Studio error guide decodes each message.

Using your local model like an API

This is the bit that turns it from a toy into a tool. Ollama serves an OpenAI-compatible endpoint, so code written for OpenAI works against your local model with two lines changed.

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:12b",
    "messages": [{"role": "user", "content": "Summarise this in one line: ..."}],
    "keep_alive": "30m"
  }'
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama",  # the SDK wants it, Ollama ignores it
)

reply = client.chat.completions.create(
    model="gemma4:12b",
    messages=[{"role": "user", "content": "Explain DNS in two sentences."}],
)
print(reply.choices[0].message.content)

Three things that will bite you. keep_alive decides how long the model stays in memory — "30m" if you are calling it repeatedly, 0 to unload and free the RAM. num_ctx is not reliably honoured through this layer; set it in a Modelfile if you need a specific context. And the API has no authentication — anything that can reach the port can use your model.

# Modelfile — pin a bigger context for one model
FROM gemma4:12b
PARAMETER num_ctx 16384

# then
ollama create gemma4-16k -f Modelfile
ollama run gemma4-16k

Want a proper chat window instead of a terminal? Open WebUI is the usual pick — one Docker container, connects to Ollama, gives you conversations, file upload and model switching. Port 3000, everything stored locally.

Images and audio, not just text

Gemma 4 is multimodal and almost nobody uses that half. All five sizes read images. The three smaller ones — E2B, E4B, 12B — also take audio, which is unusual for something running on a laptop.

# read an error dialog off your desktop
ollama run gemma4:12b "what error is on this screen? /home/you/Desktop/error.png"

# transcribe a recording (e2b, e4b, 12b only)
ollama run gemma4:12b "transcribe this /home/you/meeting.m4a"

Through the API, images go in an images array as base64. Which makes a genuinely useful habit possible: screenshot the error, send it to a local model, get the fix — and the screenshot never leaves your machine. For a blog about Windows error codes, that is a tool worth having.

Honest limit: small models read text in screenshots worse than frontier models do, especially dense UI. Crop to the dialog you care about. The 12B is noticeably better at this than E4B.

Build something real: ask questions about your own PDFs

A chat window is a demo. This is what people actually want from a local model — point it at your documents and ask questions, with nothing leaving the machine. About forty lines of Python.

The idea: split the document into overlapping chunks, turn each chunk into a vector, find the chunks closest to the question, paste only those into the prompt. That last step is what makes it work. You are not sending the whole document, just the three paragraphs most likely to hold the answer.

# one-time setup
pip install pypdf requests
ollama pull nomic-embed-text   # embedding model, ~275 MB
ollama pull gemma4:12b         # the one that writes the answer
import sys, math, requests, pypdf

OLLAMA = "http://localhost:11434"

def chunks(text, size=1200, overlap=200):
    out, i = [], 0
    while i < len(text):
        out.append(text[i:i + size])
        i += size - overlap
    return out

def embed(t):
    r = requests.post(f"{OLLAMA}/api/embeddings",
                      json={"model": "nomic-embed-text", "prompt": t})
    return r.json()["embedding"]

def cos(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    na = math.sqrt(sum(x * x for x in a))
    nb = math.sqrt(sum(y * y for y in b))
    return dot / (na * nb)

# 1. read the PDF
reader = pypdf.PdfReader(sys.argv[1])
text = "\\n".join(p.extract_text() or "" for p in reader.pages)
parts = chunks(text)

# 2. embed every chunk once (slow part — cache this in a real tool)
vecs = [embed(c) for c in parts]

# 3. find the closest chunks
q = "what does this document say about backups?"
qv = embed(q)
best = sorted(zip(parts, vecs), key=lambda p: -cos(qv, p[1]))[:3]
context = "\\n\\n".join(p[0] for p in best)

# 4. answer from that context only
r = requests.post(f"{OLLAMA}/api/generate", json={
    "model": "gemma4:12b",
    "prompt": f"Answer using only this context. If the answer is not there, say so.\\n\\n{context}\\n\\nQuestion: {q}",
    "stream": False,
})
print(r.json()["response"])

Run it with python ask.py yourfile.pdf. On a 12B the answer takes a few seconds.

Two warnings. The naive chunking above is fine for a manual or a contract, and falls apart on tables and scanned PDFs — scanned documents need OCR first. And "answer only from this context" is a request, not a guarantee; a small model will still occasionally answer from memory. For anything that matters, show the retrieved chunks alongside the answer so the reader can check it against the source.

This is the real reason to care about local models. Not that they match Neon — they do not — but that you can point one at your own medical reports or client files and know, rather than hope, that nothing left the room.

Getting good answers out of a 12B model

A small model is not a worse big model. It is a different instrument, and the prompts that work on Neon produce mush on it.

Give it a role and a shape. "You are a Linux sysadmin. Answer in numbered steps, under 100 words." A 12B follows explicit structure far better than it infers intent.

One task per request. Big models juggle "summarise, then translate, then critique". Small ones lose the thread by step two. Split it — three calls are free and fast.

Show, don't describe. Two examples of the output you want beat a paragraph explaining it. Biggest single quality jump available to you, and it costs nothing.

Keep context tight. Long context on a small model degrades attention and eats memory. Paste the function, not the file.

And when you need structure, ask for it properly. Ollama takes a JSON schema and constrains the output to match, which turns extraction and classification from flaky into reliable:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:12b",
  "messages": [{"role": "user", "content": "Extract the name and error code: ..."}],
  "format": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "error_code": {"type": "string"}
    },
    "required": ["name", "error_code"]
  },
  "stream": false
}'

When it goes wrong: the error table

Nearly every local-model failure is one of eight things.

What you seeWhat it meansTry, in order
"model requires more system memory"Model plus context is too bigLower context → smaller quant → close other apps → smaller model
Works, but painfully slowCPU, or partly offloadedollama ps → PROCESSOR column → fix driver → restart service
"could not connect to Ollama app"Service is not runningTray icon on Windows, systemctl start ollama on Linux
"pull model manifest: file does not exist"That tag is not realCheck ollama.com/library — do not trust the name in the tutorial
"unknown model architecture"Ollama is older than the modelUpdate. There is no ollama update command — rerun the installer
First answer slow, rest fastLoading into memoryNot a fault. Set keep_alive
Repeats itself, drifts off topicContext too long to trackFresh conversation, less paste, tighter system prompt
Disk filling upOld models you forgotollama list, then ollama rm name

The habit that saves the most time: check the version first. Half the "Ollama is broken" threads online are an old server meeting a model it has never heard of, and ollama -v takes two seconds.

Measuring your own machine instead of guessing

Every "is my PC good enough" thread ends in opinions. You can have a number in one command — Ollama reports timing on every native response.

curl -s http://localhost:11434/api/generate -d '{
  "model": "gemma4:12b",
  "prompt": "Write a haiku about backups.",
  "stream": false
}' | python -c "
import sys, json
d = json.load(sys.stdin)
secs = d['eval_duration'] / 1e9
print(f\"{d['eval_count']/secs:.1f} tokens/sec, load {d['load_duration']/1e9:.1f}s\")
"

How to read it: under 5 tokens/sec is painful for chat. 10–20 is usable. 30+ feels natural. 60+ is faster than most people read. And watch prompt_eval_cached_count — if it climbs between requests, your prompt cache is working and repeated long prompts are getting cheaper.

Running local models without getting burned

Local AI has its own security posture, and it is not the one people assume.

Ollama listens on 127.0.0.1 by default. Good. Lots of guides tell you to set OLLAMA_HOST=0.0.0.0 so your phone can reach it. On a laptop you take onto client networks, do not. The API has no authentication — anyone on that network can run models on your hardware and read what is loaded.

Need remote access? Tunnel it. ssh -L 11434:localhost:11434 you@machine from the other device, and leave the service bound to localhost.

Treat GGUFs like any downloaded file. The model is data, but the tooling around it is not. Installers, "converter" scripts and one-click bundles from unknown sites are the actual risk. Hugging Face and the official Ollama library, and prefer uploaders with a history.

Watch your disk. Models are large and they pile up. A few experiments can quietly eat 100 GB.

Fine-tunes are not official. A "heretic" or "uncensored" build has had its safety behaviour deliberately stripped and may behave in ways the original would not. Fine for experiments, not for anything you hand to a colleague.

Local vs API: the actual arithmetic

"Is local cheaper" has two answers depending on how much you use it.

A realistic coding request: 100,000 tokens in, 20,000 out. On Neon that is $0.30 plus $0.30 — about $0.60 a request. A hundred a day is $60. Three levers bring it down: cached input at $0.15 per million, batch pricing at roughly half rate for work that can wait, and a lower thinking level for work that does not need depth.

Same requestNeonGemma 4 local
Full price~$0.60fractions of a cent in electricity
With cached input~$0.32same
Batch tier~$0.30same
Speedfast, someone else's problemyour hardware, your ceiling

Heavy, repetitive, private work belongs local. Occasional hard problems belong on the API. Almost nobody needs to pick one, and the people insisting on picking one are usually optimising the wrong variable.

What "local" buys you on privacy

When Gemma 4 runs in Ollama, the weights are on your disk and inference happens on your GPU. Nothing you type leaves the machine. You can prove it — pull the network cable and ask it something. That is a property you test, not a promise you trust.

With Neon, your prompt goes to Google and is subject to their retention policies. For organisations that need the work to stay in a region, Vertex AI offers data-residency options — global, us and eu for the Gemini 4 models. That is a compliance answer, not a privacy purist's answer, and the difference matters.

Which bucket your work falls into is the whole decision. Client data, credentials, patient records, anything under an NDA — local. A question about a public library — whichever is convenient.

If you specifically need Neon: the API, properly

Model ID gemini-4-neon, paid tier only. Install the current SDK — automatic continuation on long decodes needs google-genai 2.34.0 or newer on Python.

pip install --upgrade "google-genai>=2.34.0"
from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_API_KEY")

response = client.models.generate_content(
    model="gemini-4-neon",
    contents="Explain what an EKS service account is.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level="HIGH"  # LOW, MEDIUM, HIGH (default), XHIGH
        ),
    ),
)

print(response.text)

The four thinking levels

This is your main control over quality, latency and cost. Price per token does not change — the number of tokens does, because thinking is billed like output.

LevelCostFor
lowfewest tokens, fastestClassification, routing, summarising, field extraction
mediumlower, fasterInteractive coding, live prototyping, latency-sensitive tools
high (default)balancedMost things. Start here
xhighmost tokens, slowestHard multi-step work, proofs, science. When high fails

Google's own advice is right: start at high, reach for xhigh only when a specific task fails. And note the headline score of 61 was measured at xhigh — at the default you get somewhat less than the marketing number.

Four API gotchas

  • thinking_budget and MINIMAL return HTTP 400. Porting code from Gemini 3 will fail on that line.
  • Custom temperature, top_p and top_k are ignored on the Gemini 4 family. Leave them out rather than debugging why they do nothing.
  • Explicit caching is not supported. Implicit caching kicks in at a 4,096-token minimum, free of charge.
  • The 1M context is shared between input and output. A 900,000-token prompt leaves 100,000 for the answer, thinking included.

So which one should you actually use?

Your situationAnswer
I want AI that works offline and never sends my data anywhereGemma 4 locally. 12b on 16 GB, 26b on 24 GB
I want the strongest model and do not mind payingNeon or Carbon over the API
I am learning what LLMs are and do not want a billGemma 4 e4b in Ollama. Zero cost, zero risk
I have 900 posts to process in bulkBatch API tier. Half price, runs overnight
I am on a laptop with no GPUAPI. e4b will run, slowly enough to annoy you
I want bothThat is the normal answer. Local for routine, API for hard

Honest comparison: Gemma 4 31B against Neon

How much are you giving up? Roughly this much. The only comparison that matters is the one you run on your own work, and I have not run yours.

TaskGemma 4 31BNeon
Summarising a long documentGood enough that most people will not noticeBetter structure, fewer missed points
Explaining an error messageUsually right, occasionally confidently wrongUsually right, more likely to admit doubt
Writing working codeFine for scripts. Fails at multi-file workHandles repositories and tool loops
100K+ contextPossible on paper, painful in practiceBuilt for it
Confidential materialNever leaves the machineGoes to Google

The gap is smallest on reading and summarising, widest on anything needing planning across steps. If your work is "read this and tell me what matters", a local 31B is genuinely enough. If it is "fix this codebase", it is not, and no prompt will close that.

Plain-English glossary

TermWhat it means
WeightsThe file of numbers that is the model. "Open weights" means you may download and run that file
GGUFThe file format llama.cpp and friends use. A quantised model packaged for local running
QuantisationCompressing weights from 16-bit to 4 or 8 bits. Small quality loss, large memory saving
Mixture of expertsA model split into specialist blocks where only a few fire per token
Active parametersHow many blocks actually run per token — the number that governs speed
Context windowHow much text the model holds in view at once, counted in tokens
KV cacheThe working memory for that context. Lives in RAM or VRAM, on top of the weights
HarnessThe software around a model — agent loop, tools, file access. Often worth more than a model upgrade

Frequently asked questions

Is Gemini 4 Neon open source?

No. Apache 2.0 covers the Gemma family. Neon is proprietary and available only through Google's products and API.

Will Google release the weights later?

Nothing suggests it, and Google has never released Gemini weights for any generation. Gemma is the open line and it has its own cadence — which is the practical reason to learn the Gemma side.

Can I load it in LM Studio or llama.cpp?

No. Both need a GGUF and there is none. If a tutorial shows Neon running in either, the model in the screenshot is something else.

Is Gemma 4 the same model as Neon?

No. Shared research lineage, separate families, separate weights, separate licences, very different capability. Gemma 4 is what you run. Neon is what you call.

Which Gemma 4 size is closest to Neon?

None of them, and I would rather say that than flatter the smaller model. The 31B is the strongest open Gemma and it is not in the same class. Expect good chat, decent coding help and reliable summarising — not frontier reasoning.

How much RAM for Gemma 4 12B?

About 10 GB at 8K context with the standard build — roughly 7.4 GB of weights plus about 3 GB of cache. Comfortable on a 12 GB card, fine on a 16 GB machine. At 128K context the same model wants closer to 25 GB, which is why the advertised context window is not the number to plan around.

Can I use Neon for free?

Not on the API free tier. Google AI Pro and Ultra subscribers get it inside the Gemini app, AI Studio and Antigravity as part of the subscription.

Why is my local model so slow?

Nine times out of ten it is on the CPU because Ollama cannot see your GPU, or because the model did not fit and some layers were offloaded. Run ollama ps and read the PROCESSOR column. If it says 100% CPU on a machine with a graphics card, you have your answer — our GPU fix guide covers the causes.

Does a local model need internet?

Only for the first download. After that it runs completely offline, and you should test that once by disconnecting — it is the entire point of running local.

So what does "running Neon locally" cost?

Nothing, because it cannot be done. Over the API it is $3 per million input tokens and $15 per million output, with cached input at $0.15.

Revision Note:

Published 19 November 2026, the day after Neon launched. If you are reading this later: Argon and Carbon pricing changes on 1 December 2026, and Gemma 4 will have been replaced by something newer. The commands, sizes and error fixes below stay valid — those are properties of the tools, not the models.

#AI

Related