DEV Community: Shivam Singh

E2B? E4B? 26B A4B? The Gemma 4 Model Names Finally Explained

Shivam Singh — Wed, 20 May 2026 22:22:54 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Gemma 4 Explained: Which Model Should You Use and Why It Changes Everything for Local AI

I built an offline AI crop diagnostic tool for Indian farmers using Gemma 4. During that process I made every possible mistake - downloaded the wrong model variant, crashed my system, misunderstood what "E4B" meant, and spent hours confused about why multimodal wasn't working.

This article is what I wish I had read before starting.

By the end you'll know exactly which Gemma 4 model to use for your use case, what makes the architecture genuinely different from anything before it, and why this family of models is a bigger deal than most developers realize.

First: Why Gemma 4 Is Different

Most open-source models are powerful but come with a catch - they either need the cloud (OpenAI, Anthropic), require massive hardware (LLaMA 70B), or sacrifice too much quality for local use (older 2B/7B models).

Gemma 4 breaks that tradeoff.

The 31B model currently ranks #3 among all open models globally on the Arena AI leaderboard. The 26B MoE ranks #6. Both run on consumer hardware. Both are Apache 2.0 licensed - meaning you can use them commercially, modify them, and deploy them anywhere, for free.

But more importantly: Gemma 4 processes text, images, video, and audio natively. Not bolted-on, not a separate pipeline - natively, in a single model call. That changes what's possible to build locally.

Decoding the Model Names: E2B, E4B, 26B A4B, 31B

This is the part that confuses everyone. Let's decode it once and for all.

The "E" Models: Edge

E2B = Effective 2 Billion parameters

E4B = Effective 4 Billion parameters

The word "effective" is doing real work here. These aren't traditional dense models - they use architectural tricks (Per-Layer Embeddings) to punch above their weight class. The "E" signals they're built for edge deployment: phones, Raspberry Pi, laptops, embedded hardware.

Both E2B and E4B support:

Text + Image + Audio input natively
Up to 128K token context window
Fully offline via Ollama
No GPU required (CPU inference possible)

The Workstation Models: 26B and 31B

26B A4B = 26 Billion total parameters, 4 Billion Active per inference

31B = 31 Billion Dense parameters

The 26B A4B uses a Mixture of Experts (MoE) architecture — it has 26B parameters but only activates 4B of them for any given token. This means it runs at roughly the speed of a 4B model while producing quality closer to a full 26B model. That "A" stands for Active.

Both workstation models support:

Text + Image + Video (up to 60 seconds at 1fps) input
Up to 256K token context window
Hybrid attention (local sliding window + full global)

The Decision Table

Your Hardware	Best Model	Reason
Phone / Raspberry Pi	E2B	Lowest memory, fast responses
Any modern laptop (8GB RAM)	E4B	Sweet spot — good quality, runs anywhere
16GB RAM desktop / workstation	26B A4B	Near-26B quality at 4B inference speed
80GB VRAM GPU (H100)	31B	Maximum quality, #3 open model globally

When I built KhetAI I chose E4B — it needed to run on a mid-range Windows laptop with a consumer GPU, handle crop photos, and respond in 8 Indian languages. E2B was too limited, 26B/31B too heavy for the target hardware.

The Architecture That Makes It Work

Hybrid Attention: Fast AND Deep

Traditional transformers use full attention - every token attends to every other token. This is expensive. Gemma 4 uses a hybrid attention mechanism that interleaves:

Local sliding window attention for nearby tokens (fast, memory-efficient)
Full global attention for the final layer (captures long-range dependencies)

This gives you the processing speed of a lightweight model without losing the deep contextual understanding you need for complex tasks. The final layer is always global — ensuring nothing important gets missed.

Proportional RoPE (p-RoPE)

For long contexts (up to 256K tokens), Gemma 4 uses Proportional RoPE — a smarter positional encoding that scales proportionally with sequence length. Combined with unified Keys and Values in global attention layers, this dramatically reduces memory usage at long contexts compared to standard transformers.

Variable-Resolution Vision

When you send an image to Gemma 4, it doesn't resize everything to a fixed resolution. It uses a dynamic number of soft tokens fitted exactly to the image's content and resolution. A high-detail photo gets more tokens than a simple diagram. This matters enormously for real-world tasks like document analysis, medical imaging, or - in my case - crop disease detection where fine texture details are diagnostic signals.

Per-Layer Embeddings (PLE) in Edge Models

The E2B and E4B models use Per-Layer Embeddings instead of shared embeddings across all layers. This lets them carry more representational richness per parameter - which is why they're called "Effective" rather than just "2B" and "4B". They genuinely outperform models of equivalent raw parameter count.

The Thinking Mode: Built-in Reasoning

Every Gemma 4 model has a configurable thinking mode - the model can reason step-by-step before producing its final answer.

In Ollama, you enable it like this:

response = ollama.chat(
    model="gemma4:e4b",
    messages=[{"role": "user", "content": "your prompt"}],
    options={"thinking": True}  # enables step-by-step reasoning
)

This is particularly powerful for:

Diagnosis tasks - reasoning through symptoms before concluding
Code debugging - thinking through the logic before suggesting a fix
Multi-step math - working through the problem before giving an answer
Agentic workflows - planning before acting

The thinking tokens are separate from the response — you get clean output plus the reasoning chain if you want to inspect it.

Running Gemma 4 Locally: Complete Setup

1. Install Ollama

Download from ollama.com - available for Mac, Windows, Linux.

2. Pull Your Model

# Edge models (recommended for most developers)
ollama pull gemma4:e2b   # ~7GB - phones, Pi, very low-end hardware
ollama pull gemma4:e4b   # ~10GB - any modern laptop ✅ recommended start

# Workstation models (need a good GPU)
ollama pull gemma4:26b   # ~16GB - MoE, great quality/speed balance
ollama pull gemma4:31b   # ~20GB - maximum quality

3. Basic Text Usage

import ollama

response = ollama.chat(
    model="gemma4:e4b",
    messages=[
        {"role": "user", "content": "Explain the difference between MoE and Dense transformers"}
    ],
    options={"temperature": 0.7}
)

print(response["message"]["content"])

4. Multimodal Usage (Image + Text)

import ollama
import base64

# Load and encode the image
with open("crop_photo.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

response = ollama.chat(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": "What disease does this crop have? Suggest treatment.",
            "images": [image_b64],  # pass base64 encoded image
        }
    ],
    options={"temperature": 0.2}  # low temp for factual tasks
)

print(response["message"]["content"])

That's it. No separate vision model. No preprocessing pipeline. One call.

5. Structured JSON Output

For applications, you want reliable structured output. Use a system prompt with low temperature:

import ollama
import json

SYSTEM = """Always respond ONLY with valid JSON. No preamble, no markdown.
Format: {"answer": "...", "confidence": "High/Medium/Low", "reasoning": "..."}"""

response = ollama.chat(
    model="gemma4:e4b",
    messages=[{"role": "user", "content": "Is this tomato leaf diseased?", "images": [image_b64]}],
    system=SYSTEM,
    options={"temperature": 0.1}
)

result = json.loads(response["message"]["content"])

6. Using the 128K Context Window

The E4B's 128K context window means you can pass entire codebases, long documents, or full conversation histories in a single call:

# Pass an entire document for analysis
with open("research_paper.txt", "r") as f:
    document = f.read()

response = ollama.chat(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": f"Summarize the key findings and methodology:\n\n{document}"
        }
    ]
)

Choosing Temperature: A Practical Guide

Temperature is the most impactful parameter after model selection:

Task	Temperature	Why
Structured JSON output	`0.1 - 0.2`	Consistency over creativity
Factual Q&A / diagnosis	`0.2 - 0.4`	Reliable, grounded answers
General conversation	`0.7`	Natural, balanced responses
Creative writing	`0.9 - 1.0`	Varied, imaginative output
Brainstorming	`1.0+`	Maximum diversity of ideas

What This Means for Developers

Here's the shift Gemma 4 represents, stated plainly:

Before Gemma 4, building a multimodal, multilingual, locally-running AI application required:

A separate vision model (CLIP, LLaVA, etc.)
A separate language model
A translation/multilingual layer
A cloud API for inference at any serious quality level
Significant engineering to glue it all together

With Gemma 4 E4B, you get all of that in a single 10GB model that runs on a laptop, costs nothing to operate, and sends zero data to any server.

That's not an incremental improvement. That's a different category.

For developers building for markets with unreliable internet — rural areas, developing countries, privacy-sensitive domains (medical, legal, financial), air-gapped enterprise environments - Gemma 4 is the first model that makes a fully capable local AI genuinely feasible.

What I Learned Building With It

I built KhetAI - an offline crop diagnostic tool for Indian farmers — using gemma4:e4b. A farmer uploads a crop photo, asks a question in Hindi or Kannada, and gets a structured diagnosis with treatment steps and local remedies. Zero internet. Zero cloud. Zero cost to operate.

The things that surprised me:

Multilingual works without any configuration. I just tell the model the language in the system prompt. It responds in that language natively — Hindi, Kannada, Tamil, Telugu. No translation layer, no separate multilingual model.

Image quality really matters. The dynamic soft-token system means a blurry photo gives fewer tokens to work with. For diagnostic tasks, tell your users to take clear, well-lit photos.

Low temperature is your friend for structured output. Setting temperature to 0.2 and adding "respond ONLY with JSON" to the system prompt gives remarkably consistent structured responses.

First inference is slow, subsequent ones are fast. The model loads into GPU memory on the first call. After that, it stays loaded and responses come quickly. Tell your users to expect a 30-90 second wait on the first analysis.

The Bigger Picture

There are 400 million Gemma model downloads. Over 100,000 community fine-tuned variants. Google calls this the "Gemmaverse."

The Apache 2.0 license means none of that growth has a ceiling. No usage fees, no terms that restrict commercial use, no platform lock-in. A developer in Bengaluru building for Indian farmers and a startup in São Paulo building for Brazilian doctors and a researcher at a university in Nairobi are all working with the same foundation model, improving it, specializing it, and sharing their work.

That's what open-weight AI at this capability level actually means. Not just "a free model" — a foundation that any developer anywhere can build on without asking permission.

Gemma 4 is the clearest example yet of that becoming real.

Quick Reference

# Install Ollama: https://ollama.com

# Pull recommended model for most developers
ollama pull gemma4:e4b

# Test immediately
ollama run gemma4:e4b "What is the Mixture of Experts architecture?"

# Python
pip install ollama

import ollama

# Text
r = ollama.chat(model="gemma4:e4b", messages=[{"role":"user","content":"Hello"}])

# Image
r = ollama.chat(model="gemma4:e4b", messages=[{"role":"user","content":"Describe this","images":["base64string"]}])

# Structured output
r = ollama.chat(model="gemma4:e4b", messages=[...], system="Return only JSON", options={"temperature":0.1})

Built KhetAI with Gemma 4 E4B for the Gemma 4 Good Hackathon 2026. GitHub: https://github.com/Tech-Psycho95/KhetAI

gemma, ai, python, ollama

No Internet? No Problem. How I Built a Crop Disease Detector for Rural India

Shivam Singh — Tue, 19 May 2026 00:17:14 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

How I Built an Offline AI Crop Doctor for Indian Farmers Using Gemma 4

Every year, Indian farmers lose 20–30% of their harvest to crop diseases they cannot identify in time. Agricultural experts are concentrated in cities. Internet is unreliable in villages. And most existing tools are in English - a language most farmers don't read or speak.

I built KhetAI to change that.

What I Built

KhetAI is a fully offline AI crop diagnostic tool for Indian smallholder farmers. A farmer:

Takes a photo of their affected crop
Asks a question in their native language (Hindi, Kannada, Tamil, Telugu, and more)
Gets an instant structured diagnosis with treatment steps, local remedies, and an escalation flag

No internet needed. No cloud. No data ever leaves the device.

Tech Stack:

Layer	Technology
AI Model	Gemma 4 (`gemma4:e4b`) via Ollama
Backend	FastAPI (Python)
Frontend	HTML + Tailwind CSS (single file, no build step)
Inference	Ollama - fully on-device

The result the farmer sees includes:

Diagnosis with confidence level (High / Medium / Low)
Numbered treatment steps
Affordable local remedies like neem oil and copper sulfate
Prevention tips
A red escalation warning if they need to see a real expert

Demo

▶️ Demo Video: Watch on YouTube

Real output from KhetAI - tested with a flower photo asking "What is it's name?":

{
  "diagnosis": "Healthy crop - Black-eyed Susan (Rudbeckia family)",
  "confidence": "Medium",
  "treatment": [
    "Ensure soil remains consistently moist but not waterlogged",
    "Feed with balanced slow-release fertilizer at start of growing season"
  ],
  "local_remedies": [
    "Add compost around the base to improve soil nutrients",
    "Light mulch layer of wood chips conserves moisture"
  ],
  "prevention": [
    "Avoid overhead watering - water the base instead",
    "Deadhead spent flowers regularly to encourage new blooms"
  ],
  "escalate": false,
  "summary": "Your crop is healthy - maintain consistent watering and add compost for best yields"
}

Gemma 4 correctly identified the plant, gave practical advice, and suggested affordable local remedies - all in one response, in the farmer's chosen language.

Code

🔗 GitHub Repository: https://github.com/Tech-Psycho95/KhetAI

Run it yourself:

# 1. Pull the model
ollama pull gemma4:e4b

# 2. Install dependencies
pip install fastapi uvicorn python-multipart ollama

# 3. Start the backend
uvicorn main:app --reload --port 8000

# 4. Open frontend
# Just double-click index.html in your browser

The backend /analyze endpoint accepts a crop photo + question, converts the image to base64, and sends both to Gemma 4 via Ollama:

response = ollama.chat(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": f"[Language: {language}]\nFarmer's question: {question}",
            "images": [image_b64],
        }
    ],
    system=SYSTEM_PROMPT,
    options={"temperature": 0.2},
)

The system prompt instructs Gemma 4 to always return a clean structured JSON object with diagnosis, treatment, remedies, prevention, and an escalation flag. Low temperature (0.2) ensures consistent, reliable output every time.

How I Used Gemma 4

I chose Gemma 4 E4B (gemma4:e4b) - here's why it was the right fit:

Multimodal out of the box
Gemma 4 processes both a crop photo and a text question together in a single API call. No separate vision pipeline, no extra model. The farmer uploads an image and asks their question — Gemma 4 analyzes both simultaneously.

Runs fully offline via Ollama
gemma4:e4b runs locally on a consumer GPU with no API key, no internet, and no subscription. This is non-negotiable for rural India deployment where connectivity is absent.

Multilingual natively
Gemma 4 handles Hindi, Kannada, Tamil, Telugu, Marathi, Bengali, Gujarati, and Punjabi without any translation layer. I simply pass the farmer's preferred language in the system prompt — the model responds in that language automatically.

Why E4B over E2B or 31B Dense?

E2B is too small for reliable multimodal diagnosis accuracy
31B Dense requires expensive hardware beyond a typical village kiosk
E4B hits the sweet spot — strong diagnostic accuracy, runs on a mid-range GPU, 9.6GB model size

Before Gemma 4, this project would have required a separate vision model, a separate language model, a translation layer, and a cloud API — meaning internet dependency. Gemma 4 collapses all four into a single local model call.

What's Next

KhetAI today runs on a single device for a single farmer. The roadmap:

Phase 2 - Shared village kiosk over local WiFi, no internet needed
Phase 3 - Fine-tune on Indian crop disease datasets using Unsloth + LoRA
Phase 4 - Voice input in local languages + government scheme alerts
Phase 5 - Federated learning across villages, models improve from anonymised farm data

The infrastructure cost to serve 1,000 farmers? Zero. Because everything runs locally.

🌀 Unhelpful Helper 3000

Shivam Singh — Sun, 12 Apr 2026 18:30:08 +0000

🎯 Project Concept
The Unhelpful Helper 3000 is a parody web app designed to frustrate, amuse, and confuse. It takes everyday UI patterns and deliberately breaks them in the most ridiculous ways possible. Instead of helping, it actively makes things worse — because why not?

✨ Features
CSS Un‑centering Engine
Every div you try to center is shoved into a random corner of the screen. Sometimes it overlaps with other divs, just to keep things spicy.

Shake‑to‑Volume Slider
Want louder music? Forget dragging a slider. Shake your phone violently until the app decides you’ve “earned” it. Sometimes it lowers the volume instead.

Infinite Loading Spinner
A button labeled “Do Something” that only shows a spinner forever. No action. No result. Just eternal anticipation.

Reverse Progress Bar
Starts at 100% and drains to 0% as you “complete” tasks. Congratulations, you’re failing successfully.

AI Compliment Generator

Every form submission is ignored and replaced with a random sarcastic compliment like “Nice try, champ.”

Tech-Psycho95 / Unhelpful-Helper-300

useless

View on GitHub

unhelpful-helper-300.vercel.app

🛠️ Tech Stack

HTML, CSS, JavaScript (because anything more serious would defeat the point)

Random number generators for maximum chaos

Zero optimization, zero usability, infinite confusion

🗣️ Fake Testimonials
“I tried to center a div, and now it lives in the corner forever. 10/10.”

“I shook my phone so hard I dropped it. Still didn’t get louder music.”

“The spinner is my new meditation app.”

Streamflow: From Vision to Velocity

Shivam Singh — Sun, 20 Jul 2025 02:51:57 +0000

This is submission for the World's Largest Hackathon Writing Challenge:

⚡️ Project Overview
As part of the Scaler Internship Challenge, I created Streamflow—a sleek, interactive streaming web app designed to deliver an elegant and engaging user experience. The idea was simple: build something functional, beautiful, and fast—without compromising the fun.

🧩 Tailwind CSS for rapid UI styling

🧠 JavaScript + TypeScript for reliable, type-safe dynamic functionality

🎨 CSS animations for bounce, pulse, and glow interactions

🌐 GitHub Pages for smooth deployment

🛠️ Bolt-new for fast environment setup and AI-powered dev support

Streamflow offers a cinematic browsing experience featuring responsive movie grids, glowing card transitions, and a polished layout designed for both desktop and mobile.

🔧 Dev Journey with Bolt:
Using Bolt-new streamlined my workflow dramatically:

Zero config—just start building

AI suggestions helped tweak layout issues and animation logic

Git + SSH integration worked like a charm

🌱 After the Hack:
This challenge was more than just a build—it launched me into a sharper mindset. Here’s what’s next:

🎯 Deepening my knowledge of C++ to explore low-level problem solving

🔄 Continuing my frontend journey by building projects with React and animation-heavy UIs

🔍 Enhancing Streamflow with search filters, genre tagging, and localStorage-powered watchlists

💡 Staying curious with coding challenges, creative builds, and portfolio refinement

The Scaler challenge reminded me that building isn’t just about output—it’s about bold experimentation and continuous learning. And Streamflow? It’s the beginning of something bigger.

Here's my project links: