Gemini 4: Neon local install, is it possible? Questions Answered
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.
| Model | Arrived | Price / 1M tokens | Built for |
|---|---|---|---|
| Argon | 13 Oct | $2 / $10 $4 / $20 from 1 Dec | Long scientific and agentic reasoning. Thinking stops at high. |
| Carbon | 10 Nov | $2 / $10 $4 / $20 from 1 Dec | The flagship. Hardest work, cyber defence. Defaults to medium. |
| Hydrogen | 12 Nov | — | Fast everyday work. Defaults to high. |
| Neon | 18 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.
| Benchmark | Neon | What it measures |
|---|---|---|
| Artificial Analysis Intelligence Index | 61 · #3 | Blended reasoning, measured at xhigh |
| AA Coding Agent Index | 58.6 · #1 | Agentic coding, multi-step edits |
| Vals Index | 70.9% · #2 | Independent evaluation suite |
| Terminal-Bench 4.1 | 65.2% | Real command-line tasks |
| FrontierCode 2.0 | 46.2% | Production-grade code, at high |
| SWE-sweep | 12.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.
- Hugging Face,
googleorganisation. Gemma weights live there. Not there, does not exist. - ollama.com/library. Ollama adds real models within days.
- Google's own announcement post. If they published weights, they link them — the Gemma 4 launch is what that looks like.
- 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 tag | Download | Context | Inputs | Who it is for |
|---|---|---|---|---|
| gemma4:e2b | ~7.2 GB | 128K | Text, image, audio | Old laptops, small VMs, Raspberry Pi territory |
| gemma4:e4b | ~9.6 GB | 128K | Text, image, audio | Any laptop. Also what gemma4:latest actually gives you |
| gemma4:12b | ~7.6 GB | 256K | Text, image | 16 GB machine. The one most of you should install |
| gemma4:26b | ~18 GB | 256K | Text, image | 24 GB card, and you hate waiting |
| gemma4:31b | ~20 GB | 256K | Text, image | Best 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.
| Model | Type | Memory | Speed | Quality |
|---|---|---|---|---|
12b | Dense | ~7.6 GB | Moderate | Good |
26b | MoE, ~4B active | ~18 GB | Fast | Very good |
31b | Dense | ~20 GB | Slow | Best |
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:
| Quant | Weights | + KV @16K | Quality |
|---|---|---|---|
Q2_K | ~4.8 GB | ~7.8 GB | Damaged. Only if nothing else fits |
Q3_K_M | ~6.1 GB | ~9.1 GB | Noticeable. Fine for chat, not for code |
Q4_K_M (default) | ~7.4 GB | ~10.4 GB | The one you want |
Q5_K_M | ~8.5 GB | ~11.5 GB | Very close to full. Worth it on 16 GB |
Q6_K | ~9.8 GB | ~12.8 GB | Near-lossless, lighter than Q8 |
Q8_0 | ~12.7 GB | ~15.7 GB | Effectively lossless. Needs 24 GB |
BF16 | ~23.8 GB | ~26.8 GB | Reference 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 see | What it means | Try, in order |
|---|---|---|
| "model requires more system memory" | Model plus context is too big | Lower context → smaller quant → close other apps → smaller model |
| Works, but painfully slow | CPU, or partly offloaded | ollama ps → PROCESSOR column → fix driver → restart service |
| "could not connect to Ollama app" | Service is not running | Tray icon on Windows, systemctl start ollama on Linux |
| "pull model manifest: file does not exist" | That tag is not real | Check ollama.com/library — do not trust the name in the tutorial |
| "unknown model architecture" | Ollama is older than the model | Update. There is no ollama update command — rerun the installer |
| First answer slow, rest fast | Loading into memory | Not a fault. Set keep_alive |
| Repeats itself, drifts off topic | Context too long to track | Fresh conversation, less paste, tighter system prompt |
| Disk filling up | Old models you forgot | ollama 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 request | Neon | Gemma 4 local |
|---|---|---|
| Full price | ~$0.60 | fractions of a cent in electricity |
| With cached input | ~$0.32 | same |
| Batch tier | ~$0.30 | same |
| Speed | fast, someone else's problem | your 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.
| Level | Cost | For |
|---|---|---|
low | fewest tokens, fastest | Classification, routing, summarising, field extraction |
medium | lower, faster | Interactive coding, live prototyping, latency-sensitive tools |
high (default) | balanced | Most things. Start here |
xhigh | most tokens, slowest | Hard 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_budgetandMINIMALreturn HTTP 400. Porting code from Gemini 3 will fail on that line.- Custom
temperature,top_pandtop_kare 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 situation | Answer |
|---|---|
| I want AI that works offline and never sends my data anywhere | Gemma 4 locally. 12b on 16 GB, 26b on 24 GB |
| I want the strongest model and do not mind paying | Neon or Carbon over the API |
| I am learning what LLMs are and do not want a bill | Gemma 4 e4b in Ollama. Zero cost, zero risk |
| I have 900 posts to process in bulk | Batch API tier. Half price, runs overnight |
| I am on a laptop with no GPU | API. e4b will run, slowly enough to annoy you |
| I want both | That 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.
| Task | Gemma 4 31B | Neon |
|---|---|---|
| Summarising a long document | Good enough that most people will not notice | Better structure, fewer missed points |
| Explaining an error message | Usually right, occasionally confidently wrong | Usually right, more likely to admit doubt |
| Writing working code | Fine for scripts. Fails at multi-file work | Handles repositories and tool loops |
| 100K+ context | Possible on paper, painful in practice | Built for it |
| Confidential material | Never leaves the machine | Goes 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
| Term | What it means |
|---|---|
| Weights | The file of numbers that is the model. "Open weights" means you may download and run that file |
| GGUF | The file format llama.cpp and friends use. A quantised model packaged for local running |
| Quantisation | Compressing weights from 16-bit to 4 or 8 bits. Small quality loss, large memory saving |
| Mixture of experts | A model split into specialist blocks where only a few fire per token |
| Active parameters | How many blocks actually run per token — the number that governs speed |
| Context window | How much text the model holds in view at once, counted in tokens |
| KV cache | The working memory for that context. Lives in RAM or VRAM, on top of the weights |
| Harness | The 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.
Keep reading
- Gemini 4 Argon locally: pricing, release date and the Gemma 4 route
- Can Gemini 3.8 Flash and Cyber be installed locally?
- Run Gemma 4 locally on Windows 11 and 10
- Install Gemma 4 on Kali Linux and run it offline
- How to update Ollama on Windows, Mac, Linux and Docker
- Ollama not using your GPU? Why, and how to fix it
- Ollama "model requires more system memory" — every fix
- LM Studio "failed to load model": every error decoded
- Ollama vs LM Studio vs Jan AI vs Unsloth
- Run AI locally on Windows and Kali — the full guide series