TL;DR: I built a Chrome extension that runs Llama, DeepSeek, Qwen, and other LLMs entirely in-browser. No server, no Ollama, no API keys. Here's the full story—why I built it, how the architecture works, and what I learned shipping it.

Try it: noaibills.app

The backstory

I kept running into the same friction with AI tools.

Privacy made me hesitate. Every time I wanted to draft something sensitive—work emails, code reviews, personal notes—I'd pause before hitting enter. "This is going to OpenAI's servers." That thought never stopped bothering me.

Local AI meant yak-shaving. Ollama is fantastic if you're technical. But I've tried recommending it to non-dev friends. The moment you say "open terminal," you've lost them. And if you're on a work laptop where IT locks everything down? You're stuck.

Subscriptions for occasional use felt wasteful. I don't use AI every day. Maybe a few times a week for grammar fixes, quick summaries, or getting unstuck on code. $20/month for that? Didn't sit right.

So I asked myself: what if the AI ran inside the browser? No installs. No backend. No monthly fee. Just a Chrome extension that works.

WebGPU has matured enough to make this viable. So I built it.

What NoAIBills actually is

It's a Chrome extension that runs open-source LLMs locally in your browser.

Three inference backends:

• WebLLM (MLC): WebGPU-based. Fast on decent GPUs. Runs Llama 3.2, DeepSeek R1, Qwen, Mistral, Gemma, Hermes.
• Transformers.js: ONNX Runtime on CPU. Lighter footprint. Good for smaller models like SmolLM.
• Browser AI (Prompt API): Chrome's built-in Gemini Nano. Zero download—just works.

Key features:

• All messages stored locally in IndexedDB. Export or delete anytime.
• Works offline once models are cached.
• Real-time memory monitor that alerts at 80% usage and helps you clear unused model weights.
• Reasoning UI for models like DeepSeek R1 that emit <think>...</think> blocks.

One install. No config. No server.

The honest positioning

Let me be upfront about what this is and isn't.

Local AI is good enough for most things. I'm not claiming it replaces GPT-4. But for the 80% of tasks—drafts, summaries, quick coding questions—a 3B parameter model running locally is plenty.

Not positioned as a cloud LLM replacement—it's for local inference on basic text tasks (writing, communication, drafts) with zero internet dependency, no API costs, and complete privacy.

Core fit: organizations with data restrictions that block cloud AI and can't install desktop tools like Ollama/LMStudio. For quick drafts, grammar checks, and basic reasoning without budget or setup barriers.

Need real-time knowledge or complex reasoning? Use cloud models. This serves a different niche—not every problem needs a sledgehammer 😄.

Architecture deep dive

For those who want the technical details, here's how it all fits together.

The core pattern: one transport, multiple backends

The app is a Next.js front end using useChat from the Vercel AI SDK. But instead of calling an API, it uses a custom BrowserAIChatTransport that runs streamText directly in the browser.

The transport:

• Reads provider and model from a Zustand store
• Resolves the language model via a model manager
• For reasoning models, wraps with extractReasoningMiddleware to parse think tags
• Returns result.toUIMessageStream() so the UI stays unchanged

const baseModel = modelManager.getModel(provider, modelId);
const model = isReasoningModel(modelId)
  ? wrapLanguageModel({
      model: baseModel,
      middleware: extractReasoningMiddleware({ tagName: "think", startWithReasoning: true }),
    })
  : baseModel;
const result = streamText({ model, messages: modelMessages, ...streamOptions });
return result.toUIMessageStream();

One transport. Three providers. The UI doesn't know the difference.

Model management

The model manager handles:

• Instantiating the right adapter for each provider
• Caching instances by provider:modelId so switching threads doesn't re-download
• Progress callbacks for the loading UI

All model IDs live in a single models module—filtered for low VRAM, tagged for capabilities like "supports reasoning" or "supports vision."

The loading experience

Browser models need to download weights—sometimes gigabytes. Nobody wants to stare at a blank screen.

I built a useModelInitialization hook that:

1. Checks if the model is cached (availability() returns "available")
2. If not, triggers a minimal streamText call to start the download
3. Merges progress from both the model manager and stream into one smooth progress bar

Chrome extension quirks

Making it work as an extension was the fiddly part.

Static export. Next.js builds with output: "export". The side panel loads ui/index.html.

CSP restrictions. Chrome extensions don't allow inline scripts. I wrote a post-build script that extracts inline scripts, saves them as separate files, and rewrites the HTML.

WASM loading. Transformers.js needs ONNX Runtime WASM files. Can't load from CDN in an extension. So the build copies them into extension/transformers/ and sets web_accessible_resources.

One codebase. One build. Dev runs at localhost, production becomes an extension.

Persistence

Chat history lives in IndexedDB via Dexie. Each conversation stores: id, title, model, provider, created date, and the full messages array.

When you load a conversation, it rehydrates everything—including which model you were using—so you can continue right where you left off.

What I learned building this

Abstract the backend early. The single transport pattern was a lifesaver. Adding a new provider is just "wire up the adapter, add the model IDs." No UI changes.

Browser limitations are solvable. CSP, WASM loading, storage quotas—annoying but not blockers. Budget time for post-build scripts.

Progress feedback is everything. Users will wait for a 2GB download if they can see it happening. A blank screen? They'll close the tab.

Distribution is harder than building. Chrome Web Store organic discovery is basically zero. You have to bring your own traffic.

The business side

I made it free—for now.

The deal: use it in exchange for your email and anonymous usage stats (via GA4). Your actual conversations never leave your device.

Why free? Because I don't know enough yet. Who wants this? What do they use it for? Would they pay? Charging upfront would slow down learning.

I'm optimizing for information, not revenue. Once I understand the audience better, I'll figure out if there's a paid tier worth building.

Try it out

If you've read this far, you're probably curious.

👉 noaibills.app

Install it, play with the models, and let me know what you think. I'm genuinely interested in feedback—what works, what doesn't, what you'd want to see.

And if you're building something similar with WebGPU or browser-based inference, I'd love to chat. Drop a comment or reach out.