Why We Built Typlx: A Privacy-First, Open-Source Grammar Checker
July 5, 2026
The honest answer is frustration. Not with grammar — with the tools that were supposed to help us write better. This is the story of why we spent months building a grammar checker when perfectly capable ones already existed, and what made us think the world needed another one.
The Moment We Realized Something Was Wrong
It started with a code review. One of our engineers was writing internal documentation — nothing sensitive, just architecture notes — and had Grammarly open. A colleague pointed out something unsettling: Grammarly's privacy policy explicitly states that your text can be used to improve their product. Our internal architecture notes were being sent to a third-party server, analyzed, and potentially stored.
We looked at the alternatives. LanguageTool has a self-hosted option, but the cloud version has the same problem. Most browser grammar extensions work the same way: your text leaves your machine, hits a server somewhere, and comes back with corrections. The "free" service is subsidized by your data.
For a developer writing code comments and commit messages, this is annoying. For a lawyer drafting a contract or a journalist writing a source-sensitive story, it's a real risk. We started asking: does a grammar checker actually need to send your text anywhere?
The Technical Question That Started Everything
Modern LLMs have become good enough at grammar correction that you can run useful models on consumer hardware. A 7B parameter model running locally with Ollama can catch most grammar errors, suggest natural rewrites, and handle context better than rule-based systems ever could.
So we tested it. We plugged Ollama into a browser extension prototype and checked grammar entirely on-device. It worked — not perfectly at first, but well enough that we knew the architecture was sound. The key insight was that grammar checking doesn't require a proprietary cloud model. Any capable LLM endpoint works, and users could bring their own.
That became the design principle: Typlx uses your LLM, not ours. You point it at OpenAI, Anthropic's Claude, a local Ollama instance, or any OpenAI-compatible API. The extension is the interface. The intelligence is yours to choose and control.
How Typlx Differs from Grammarly
We get this question a lot, so here's an honest comparison:
Data model
Grammarly is a service. You pay for access to their models, and their models learn from your usage. This is standard SaaS and it's not inherently bad — but it does mean your text is their training data unless you opt out, and opting out requires navigating settings most users never touch.
Typlx is a client. We provide the Chrome extension and Firefox add-on. We don't run the grammar model. We don't see your text. Your text goes from your browser to whatever LLM you configured — which you control.
Privacy by default vs. privacy by policy
Grammarly has a privacy policy. So does every company that handles your data. Policies can change, get acquired, or be enforced inconsistently. Technical architecture doesn't have these problems. When your text never leaves your browser, there's nothing to policy-protect.
Typlx's privacy guarantee comes from how the code works, not from what we promise in a document. You can read the extension source on GitHub and verify this yourself. We think "verify, don't trust" is the right default for software that touches your writing.
Open source vs. closed source
Grammarly's checking algorithms are proprietary. You have no idea why it flags something or what criteria it uses. Typlx's extension code is MIT-licensed and on GitHub. If you want to understand exactly what it does with your text, you can read it. If you want to change it, you can fork it.
How Typlx Differs from LanguageTool
LanguageTool is excellent software and we have a lot of respect for it. It's been around for years, it's genuinely open source, and the self-hosted option is solid. But there are a few real differences:
Rule-based vs. LLM-powered
LanguageTool catches errors through a database of linguistic rules. This works remarkably well for common mistakes but struggles with context. "I ate good" versus "I ate well" — LanguageTool can flag this. "Given the team's velocity, shipping by Thursday seems good" — rule-based systems have a harder time here. LLMs understand prose at the sentence level and can suggest rewrites that preserve your meaning while improving clarity.
Bring your own model
LanguageTool's self-hosted option requires running their Java stack. Typlx works with any LLM endpoint you already have access to. If you're already paying for an OpenAI API key, Typlx adds essentially zero marginal cost. If you already run Ollama locally, Typlx works with it out of the box.
Browser-native design
LanguageTool was designed as a standalone application that got browser integration later. Typlx was designed from the start to live inside the browser, which means it works on any text field — not just document editors — and integrates naturally with how web apps work.
The Open-Source Commitment
Typlx is MIT-licensed. That's not a marketing claim — it's a legal commitment. You can take our code, remove our branding, and ship your own grammar extension. You can build a commercial product on top of it. You can modify it and keep the changes private.
We chose MIT deliberately because we believe grammar checking infrastructure should belong to the community, not be locked behind a single vendor. If Typlx ever shuts down, the code survives. Anyone can fork it and keep it running.
This is different from "source available" licenses that restrict commercial use, or "open core" products where the interesting parts are proprietary. MIT means MIT.
The full codebase — Chrome extension, Firefox add-on, iOS keyboard, Android keyboard — is on GitHub at github.com/typlx. Pull requests are welcome.
What We're Still Figuring Out
We're not going to pretend we have everything solved. A few honest admissions:
LLM quality varies. If you point Typlx at a small Ollama model, you'll get worse results than if you use a large Claude or GPT-4 model. We're working on better model recommendations and fallback options, but right now the quality of your grammar checking depends heavily on the LLM you choose.
Latency is real. Local models are fast but not instant. Cloud models are faster but introduce the network round-trip. We've done a lot of work on debouncing and only-check-when-idle behavior, but if you're used to Grammarly's sub-second feedback, Typlx may feel a little slower in some configurations.
Setup has a learning curve. Telling someone to "get an API key and paste it in the settings" is a barrier that Grammarly doesn't have. We're working on making the onboarding simpler, including better documentation and a one-click local model option.
Why We Think It's Worth It
We built Typlx because we wanted a grammar checker we could actually trust — trust in the technical sense, not the marketing sense. One where the privacy guarantee comes from how the code works, not what a terms-of-service document says.
We also built it because we believe LLM-powered local tools are the right direction for privacy-sensitive software, and we wanted to prove the architecture works. It does. You can run useful grammar checking entirely on your own infrastructure.
If you care about where your text goes, Typlx is worth trying. If you're a developer who wants to understand exactly what your tools are doing, Typlx is worth reading. If you want to build on top of it, Typlx is worth forking.
Your words. Your privacy. Your tools.