DEV Community: Uday Dolas

I Embedded Gemma 4 Into a Real Desktop App — Here's Exactly What I Learned

Uday Dolas — Sat, 09 May 2026 19:18:24 +0000

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

I Embedded Gemma 4 Into a Desktop App — Here's What I Learned

I didn't set out to write about Gemma 4. I set out to build something.

I've been working on Sowser — a spatial canvas browser for Windows where
every website is a draggable live card on an infinite canvas instead of a
hidden tab. Think of it like a whiteboard where your browser tabs are actual
windows you can move around, group, and connect visually.

The problem I kept running into: users open 20 tabs for a research session
and the canvas gets chaotic fast. I needed something to automatically
understand what all those pages are about and organise them into groups.

That's where Gemma 4 came in. And what happened next genuinely surprised me.

Why I Chose Gemma 4 Over Everything Else

My requirements were specific:

Must run locally — a browser tool that phones home with your tab history is a privacy disaster
Must be fast enough to feel like a UI feature, not a loading screen
Must follow strict JSON instructions reliably — my app can't babysit malformed output
Must run without a GPU — I want regular Windows users to use this

I tested three options before landing on Gemma 4 E4B via Ollama.

GPT-4o API — perfect output, but cloud-only. Every tab URL leaves the
user's machine. Hard no.

Gemma 2B local — fast, but grouping quality was noisy. It kept merging
unrelated topics and sometimes ignored the JSON format requirement entirely.

Gemma 4 E4B local — this is the one. Clean JSON every time, genuinely
smart semantic grouping, runs in 1-3 seconds after the first load, no GPU
needed.

The jump in instruction-following quality from 2B to E4B is not small. It
feels like a completely different category of model.

How the Integration Actually Works

The feature is called AI Smart Organize. Here is exactly what happens
when a user clicks it:

Step 1 — Collect
The app grabs every open browser card's title and URL and builds a JSON array:

[
  { "title": "Neural Networks - Wikipedia", "url": "wikipedia.org/wiki/Neural_network" },
  { "title": "React Docs", "url": "react.dev/learn" },
  { "title": "Nike Running Shoes", "url": "nike.com/search?q=running+shoes" }
]

Step 2 — Prompt
This exact system prompt goes to Gemma 4:
You are a browser tab organiser. You will receive a JSON list of open browser
tabs with their titles and URLs. Group them into 2-6 meaningful clusters based
on topic or purpose. Respond ONLY with a valid JSON array. No explanation, no
markdown, no code fences. Each element must have: groupName (string),
color (hex string like #FF6B6B), urls (array of url strings from the input).

Step 3 — Parse
Gemma 4 returns something like:

[
  { "groupName": "Research", "color": "#3b82f6", "urls": ["wikipedia.org/..."] },
  { "groupName": "Development", "color": "#8b5cf6", "urls": ["react.dev/..."] },
  { "groupName": "Shopping", "color": "#10b981", "urls": ["nike.com/..."] }
]

Step 4 — Organise
The app repositions cards into colour-coded vertical columns on the canvas,
applies group colours, and shows a toast: "Organised into 3 groups!"

The whole thing takes under 3 seconds. It looks like magic.

The Thing That Actually Impressed Me

I expected the JSON compliance to be a struggle. Every time I've used smaller
local models for structured output tasks, I've had to write defensive parsers,
retry logic, and fallback handlers because the model would leak prose or
forget to close a bracket.

Gemma 4 E4B returned valid, parseable JSON on the first call, every time,
across dozens of test runs with wildly different tab combinations. That
reliability is what makes it suitable for embedding into a real desktop
application where the user has no tolerance for errors.

I still kept the defensive parser (strip markdown fences, catch exceptions,
show toast on failure) — but I never actually needed it during testing.

Choosing the Right Gemma 4 Model

The Gemma 4 family has three distinct options and the right choice depends
entirely on your use case:

Model	Parameters	Best For
E2B	2B effective	Ultra-mobile, Raspberry Pi, browser-based, offline-first
E4B	4B effective	Desktop apps, local tools, interactive features needing speed + quality
31B Dense	31B	Server deployments, complex reasoning, batch processing

For an interactive desktop feature where the user is waiting for a
response, E4B is the answer. It is fast enough to feel snappy and smart
enough to produce production-quality output.

If I were building a background batch processor that organised workspaces
overnight, I would use 31B Dense. If I were building something that ran
in a browser extension or on a phone, I would use E2B.

The model selection is not a detail — it is the architecture decision.

What Running AI Locally Actually Means

Here is the thing nobody talks about enough: when your AI runs locally,
the product relationship with your user changes completely.

With a cloud API, every feature powered by AI has a privacy asterisk.
Users have to trust that their data is handled responsibly. For a browser
tool specifically — where the AI sees every URL you have open — that trust
ask is enormous.

With Gemma 4 running via Ollama on the user's own machine, there is no
asterisk. The model runs on their hardware. The data never leaves. The
feature works offline. There is no API cost to the developer per user.

This is what models like Gemma 4 at the E4B size actually unlock — not
just "local AI" as a technical curiosity, but a genuinely different product
category where privacy is a first-class feature, not a footnote.

Getting Started Yourself

If you want to try Gemma 4 locally right now, this is all you need:

Install Ollama from ollama.com (Windows, Mac, Linux)

Pull Gemma 4 E4B:

ollama pull gemma3:4b
ollama serve

Test it instantly:

ollama run gemma3:4b "Group these tabs into categories and return only JSON: 
[{title: 'React Docs', url: 'react.dev'}, {title: 'Nike Shoes', url: 'nike.com'}]"

You will have a locally running, privacy-preserving, genuinely capable AI
model in under 5 minutes. No API key. No credit card. No data leaving
your machine.

That is the Gemma 4 story that matters to me as a developer.

Final Thought

I built Sowser to make browsing spatial. Gemma 4 made it intelligent.

The combination of a capable open model, local execution via Ollama, and
strict instruction following opened up a product feature that simply was
not possible before — not without compromising user privacy or requiring
server infrastructure.

If you are building any kind of desktop tool that touches user data,
Gemma 4 E4B is worth a serious look. The barrier to entry is one terminal
command. The upside is a completely different class of product.

🔗 See Sowser on GitHub: https://github.com/noisyboy08/TREE-TABS

Sowser: Your Browser Tabs Are a Mess. I Fixed It With Gemma 4 and an Infinite Canvas.

Uday Dolas — Sat, 09 May 2026 19:04:01 +0000

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

What I Built

Sowser is a spatial canvas browser for Windows — instead of a strip of tabs, every website lives as a draggable, resizable live card on an infinite canvas. You pan, zoom, group, and connect pages the way your brain actually thinks, not the way a tab bar forces you to.

The problem is simple: traditional browsers trap you in a single column of tabs. When you are researching, comparing, or debugging across many sources, you constantly alt-tab and lose context. Sowser solves this by giving every page space — you see everything at once, arrange it meaningfully, and save that layout as a workspace to return to later.

Built with WPF and Microsoft Edge WebView2 on .NET 8. Cards are real live pages, not screenshots. The canvas supports sticky notes, image clips, connection lines between cards, a command palette (Ctrl+K), minimap, tracker blocking, per-card browser profiles, and full workspace save and load.

Gemma 4 powers the centrepiece feature: AI Smart Organize.

When you click AI Smart Organize, Sowser:

Collects every open card's title and URL
Sends them to Gemma 4 running locally via Ollama
Receives a JSON grouping of cards into named semantic clusters
Repositions cards into colour-coded columns on the canvas automatically

The canvas goes from chaos to clarity in one click — privately, locally, with no data leaving your machine.

Demo

🔗 github.com/noisyboy08/TREE-TABS

Watch the demo video in the repository (demo.mp4) to see:

Multiple browser cards open across different topics
One click on AI Smart Organize
Gemma 4 grouping them into labelled colour-coded columns instantly
Zooming out to see the full spatial layout

Code

🔗 github.com/noisyboy08/TREE-TABS

Core files for the Gemma 4 integration:
Models/GemmaSettings.cs — model config, endpoint, local vs cloud toggle
Services/GemmaService.cs — HTTP client to Ollama or Gemini API fallback
Services/GemmaOrganizeService.cs — parses groups, repositions cards on canvas
MainWindow.FeaturePack.cs — wires the AI Smart Organize menu handler

To run the AI feature locally with no API key:

ollama pull gemma3:4b
ollama serve

Then open Sowser, load some tabs, and click AI Smart Organize.

How I Used Gemma 4

Model chosen: Gemma 4 E4B — 4 billion effective parameters, running locally via Ollama.

Why E4B specifically

The Smart Organize feature needs to run fast, silently, and without sending your browsing history to any cloud. E4B is the exact right fit:

Fast enough to feel instant on a mid-range laptop. First call loads the model into memory. Every call after that returns in one to three seconds.
Smart enough to semantically cluster URLs and page titles into meaningful groups. This is not keyword matching — it is genuine topic understanding.
Local by default — your tabs never leave your machine. This matters deeply for a privacy-minded browser tool.
No GPU required — making it accessible to the widest possible Windows user base.

I tested the 2B model and found it produced noisier groupings that sometimes merged unrelated topics. The 31B Dense model is overkill for a clustering task and would feel sluggish in an interactive desktop UI. E4B hits the right balance between speed, accuracy, and hardware accessibility.

What Gemma 4 actually does inside Sowser

The prompt sent to the model is strict and unambiguous:

Receive a JSON array of open tab titles and URLs
Return only a JSON array of groups
Each group has a name, a hex colour, and the list of URLs belonging to it
No explanation, no markdown, no preamble — just structured data

Gemma 4's instruction-following quality is what makes this reliable in a production desktop app. The app strips any accidental markdown fences, parses the JSON, then immediately repositions and recolours cards on the canvas. If the model output is malformed for any reason, the app catches the error, shows a toast, and never crashes.

Why this only works because of Gemma 4

A browser that understands what you are looking at and organises it for you — locally, privately, instantly — is only possible because models like Gemma 4 exist at this size and capability level. That is the real unlock. Not AI as a cloud API you pay per token. AI embedded directly into a native desktop tool, running on your own hardware, with zero data leaving the device.

Sowser was already a spatial browser. Gemma 4 made it a spatial browser that thinks.

Think in space, not in tabs.

Nova: Autonomous GitHub PR Reviewer with OpenClaw — 20 Analyzers & Risk Scores in 8 Seconds

Uday Dolas — Sun, 26 Apr 2026 18:21:37 +0000

This is a submission for the OpenClaw Challenge.

What I Built

I built Nova — an autonomous GitHub PR reviewer
powered by OpenClaw. Every time someone opens a Pull Request,
Nova automatically reads the entire code diff and posts a
structured review comment in under 8 seconds.

No waiting for human reviewers. No rubber stamps.
No secrets leaking into main. Ever.

The core flow:

Developer opens a PR on GitHub
GitHub fires a webhook to Nova
20 analyzers run in parallel on the diff
Structured review comment appears in under 8 seconds
Slack/Telegram notification sent to the team
Dashboard updates with new risk score and findings

GitHub: https://github.com/noisyboy08/Nova

How I Used OpenClaw

Nova is built as a native OpenClaw skill. The SKILL.md
file defines the entire agent behavior — what triggers it,
what tools it uses, how it analyzes code, and how it learns
from every review.

What OpenClaw adds that a normal bot cannot:

Persistent Memory — OpenClaw remembers every developer
across every PR. After 20+ reviews it builds a pattern
profile per author. It knows which developers forget error
handling. It knows who skips tests. Future reviews are
tailored to that person specifically.

Proactive Notifications — Nova doesn't wait to be asked.
The moment a secret is detected it fires an urgent Telegram
DM to the repo owner. Fully autonomous. No polling.

Skill Composability — Nova chains into other OpenClaw
skills. After a review posts, a Slack notifier skill picks
up the result. A Jira linker connects the PR to the ticket.
Each skill does one thing and hands off cleanly.

Demo

GitHub: https://github.com/noisyboy08/Nova

The 20 analyzers running on every PR:

🔑 Secret Scanner — API keys, passwords, tokens
📦 CVE Checker — Vulnerable packages via OSV.dev
🛡️ OWASP Top 10 — All 10 categories per PR
📊 Risk Score — 0-100 with colored GitHub label
🔧 Auto-Fix — Writes the fix as inline suggestion
🧪 Test Generator — Generates missing unit tests
🏗️ Architecture — Blast radius for core file changes
⚖️ License Checker — Flags GPL in commercial projects
💳 Sensitive Data — Emails, SSNs in test data
👥 Auto-Assign — Git blame based reviewer suggestions
🎫 Jira Linker — Connects PR to ticket from branch name
📝 Changelog — Auto-commits entry on merge
🏆 Leaderboard — Per-developer metrics and streaks
🎭 Personalities — Strict / Mentor / Fast / Senior modes
📱 Notifications — Slack, Telegram, Discord cards
🔍 Pattern Learning — Remembers each author's mistakes
💡 Praise — Calls out genuinely elegant code
📏 Size Enforcer — Suggests how to split huge PRs
🌍 Multi-Language — Python/JS/Go/Java specific rules
📜 Git Context — Last 5 commits on changed files

Dashboard: Dark glassmorphism design with animated
risk gauge, team leaderboard, security timeline,
and real-time review feed.

What I Learned

1. OpenClaw's SKILL.md is the most underrated
feature in personal AI right now.
One Markdown file replaced what would have been
hundreds of lines of orchestration code.

2. Parallel execution changes everything.
20 analyzers sequentially = 40 seconds.
Same 20 with Promise.allSettled() in parallel = 8 seconds.
Architecture matters more than features.

3. The webhook pipeline is harder than the AI.
Verifying HMAC signatures, responding within 2 seconds,
processing async — that plumbing took longer than
building all 20 analyzers combined.

4. OpenClaw makes AI proactive not reactive.
Every other AI tool waits for you to ask. OpenClaw
watches your workflow and acts without being prompted.
That shift is what makes it fundamentally different
from everything else.

5. Personal AI is about to eat developer tooling.
Nova does what CodeClimate and Snyk do — but
self-hosted, free, and customizable in a single
Markdown file. A solo developer can build this
in 10 days with OpenClaw.

ClawCon Michigan

I did not attend ClawCon Michigan but the energy of
the OpenClaw community building in public inspired
every decision in this project.

The lobster stays. 🦞

Lord of Repo: Visualize Any GitHub Repo as an Anti-Gravity City 🌍 Powered by Google Gemini #googleai #github

Uday Dolas — Sat, 18 Apr 2026 19:51:35 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

Lord of Repo is an Enterprise SaaS Visualization Platform that transforms
any GitHub repository into an interactive Anti-Gravity City — a living,
floating 3D world where every module, folder, and component becomes a
structure hovering at different altitudes, connected by energy beams.

Instead of reading walls of code, you explore a repo like a planet.

🔗Live App: https://anti-gravity-city.vercel.app

Earth Day Connection:
We built this for climate and environment repositories specifically.
The open source climate tech ecosystem has thousands of repos — carbon
trackers, biodiversity monitors, emission calculators — but most developers
never contribute because codebases feel overwhelming and alien.

Lord of Repo turns any climate repo into a world you can understand
at a glance. See the architecture, understand the structure, and know
exactly where to contribute — all without reading a single line of code first.

Demo

🔗 Live: [(https://anti-gravity-city.vercel.app)]

[ADD SCREENSHOT HERE — drag your app screenshot into the editor]

The Anti-Gravity City renders modules floating at different altitudes,
connected by energy beams and orbits. Each floating structure represents
a part of the repository. It immediately makes complex repos look
approachable and unique — because they are.

Code

noisyboy08 / Anti-Gravity-City

"Anti-Gravity" city for your "Lore of the Repo" project is a genius move. Instead of a flat grid, you can have modules floating at different altitudes, connected by energy beams or orbits. This immediately makes it look more "high-end" and unique than a standard 3D city.

🌐 Lord of Repo

A Massively Gamified 3D Metaverse for Software Engineering Teams

Lord of Repo transforms your dull, static GitHub repositories into a sprawling, interactive, 3D Cyberpunk City. Instead of scrolling through an IDE tree view, you fly through a glowing metropolis where every building is a file, the altitude of the building represents its architectural depth, and real-time live effects visualize everything from Git commits to code complexity.

🚀 The Ultimate Gamified Developer Experience

This project takes 3D Code Visualization to the absolute extreme. Here are just a few of the 19+ Interactive Systems running concurrently inside the engine:

🎮 The Feature Lab

📈 Economy of Code: Repositories turned into a Stock Market. Files dynamically gain/lose LED-ticker "value" based on complexity algorithms.
🔫 FPS Mode (Glitch Hunt): Switch from aerial drone cameras to PointerLockControls. Land on the streets, walk around in First-Person, and shoot neon wireframe Spiders…

View on GitHub

How I Built It

Tech Stack:

Next.js / React (Frontend)
Google Gemini API (AI analysis & repo explanation)
GitHub OAuth (Login with GitHub)
Vercel (Deployment)

How It Works:

User logs in with GitHub
Pastes or selects any repository
Google Gemini analyzes the repo files and structure
The app renders the repo as an Anti-Gravity City — modules float at different altitudes based on their role in the codebase
Gemini provides natural language explanations of each "building" in the city — what it does, why it exists, how it connects to others

Key Technical Decisions:

I chose the "city floating in space" metaphor deliberately. A flat
folder tree gives you no sense of importance or relationships.
An Anti-Gravity City makes architectural relationships spatial and
intuitive — core modules float highest, utilities sit lower,
adapters connect everything like bridges.

Gemini's large context window was essential here. It processes
multiple repo files simultaneously and reasons across the entire
codebase as a whole — giving explanations that understand relationships
between files, not just individual files in isolation.

Prize Categories

Best Use of Google Gemini

Gemini is the brain of Lord of Repo. Specifically:

Input: Raw repository files uploaded from any GitHub repo
What Gemini does: Analyzes the full codebase structure, understands relationships between modules, and generates human-readable explanations for each component
Output: Powers the city visualization — each floating structure is labeled and explained by Gemini
Why Gemini specifically: Its large context window allows it to process an entire repository at once and reason across files — something smaller context models cannot do effectively

Without Gemini, Lord of Repo is just a 3D city with no meaning.
Gemini is what makes every floating building understandable.