Why Free Online Grammar Checkers Fail (And What Actually Works)

What Free Grammar Checkers Actually Catch

If you open the JavaScript bundle of a free in-browser grammar checker, you will find the same recipe that has been recycled across the web for fifteen years: a hardcoded array of 20 to 50 regex patterns, each looking for a specific common error, paired with a hardcoded replacement. The tool is not "checking grammar" in any general sense. It is running string matching against a curated cheat sheet of frequently-confused word pairs.

The list is roughly the same everywhere. Homophones: your/you're, their/there/they're, its/it's, then/than, affect/effect, accept/except, lose/loose, principal/principle. Modal verb errors: could of/could have, should of/should have, would of/would have. Whitespace and punctuation: double spaces, missing space after period, missing space after comma, lowercase letter after period. Capitalisation: i instead of I, lowercase first word, day-of-week not capitalised. Doubled words: the the, of of, and and. That is essentially the entire ruleset.

You can verify this trivially. Type a sentence with a subtle error: "The data on the spreadsheets which I downloaded from the server were accidentally been overwritten last week." The sentence has tense agreement issues (were accidentally been is broken — should be were accidentally overwritten or had accidentally been overwritten), a relative pronoun choice issue (which versus that in restrictive clauses, depending on style guide), and arguable subject-verb tension (data as singular versus plural, depending on register). A free regex-based checker will flag none of this. It will tell you the sentence is fine, because none of its 30 patterns match.

Now type "i should of went their". The same tool will flash three errors and feel impressive. The difference is not that the second sentence is "more wrong". The difference is that the second sentence triggers four of the hardcoded patterns and the first sentence triggers zero. The tool has no idea what grammar is. It has a list.

What Free Grammar Checkers Miss

The errors that matter in professional writing — the ones that make text sound off, that confuse readers, that get flagged in code review or peer review — are almost all invisible to regex-based tools. Here are the categories of errors free checkers consistently fail on.

Subject-verb agreement at distance. "The collection of rare manuscripts that were donated by the family last spring are on display." The subject is collection (singular), so the verb should be is. But seven words separate them, with a plural noun (manuscripts) right next to the verb. A regex cannot resolve this. A statistical model trained on parsed sentences resolves it routinely.

Tense consistency across clauses. "When the engineer arrived at the data center, she notices the rack lights are blinking and immediately filed a ticket." Three tenses (past, present, past) in one sentence. Each clause is locally correct. The combination is wrong. Regex sees nothing.

Pronoun-antecedent agreement. "Each developer should commit their code by 5pm." The traditional rule says their disagrees with each (singular antecedent). Modern usage accepts singular they. A real grammar checker should flag this in formal contexts and accept it in casual ones, depending on the style profile. Regex flags it never or always — neither is right.

Misplaced modifiers. "Running through the field, the sunset was beautiful." This implies the sunset was running through the field. Parsing the sentence reveals that the participial phrase has no valid subject in the main clause. A statistical parser detects this. Regex cannot.

Register shifts. "Subsequently, the team's analysis reveals that the metric is, like, totally tanked." Mixing formal vocabulary (subsequently, reveals) with casual vocabulary (like, totally tanked) signals the writer lost track of register. A trained model flags this. Regex sees only individual words.

Comma splices and run-ons. "I went to the store, I bought milk." Two independent clauses joined by a comma. A real checker either flags it as a comma splice (most style guides) or accepts it as deliberate (Cormac McCarthy's style). Free checkers ignore it because comma-splice detection requires sentence parsing, not regex.

Word choice in context. The word literally in "I am literally dying of laughter" is not a typo or homophone — it is a usage choice that some style guides flag and others do not. The word impactful is rejected by some editors and accepted by others. Free checkers do not engage with usage. They check spelling.

How Real Grammar Checkers Work

Serious grammar checkers combine three layers, each catching what the others miss.

Layer 1: Rule-based pattern matching. This is the regex layer that free tools use, but with a vastly larger ruleset. LanguageTool's open-source ruleset contains over 5,000 rules for English alone, hand-written by linguists, covering not just homophones but verb-particle phrasing, prepositional collocations, redundant pairs, and style guide preferences (Chicago, AP, Oxford). Each rule is annotated with a category and a confidence level. The ruleset is in XML, publicly auditable on GitHub, and updated continuously.

Layer 2: Statistical n-gram models. The checker builds frequency tables of word sequences from large corpora (Wikipedia, books, web text). When it encounters an unusual sequence, it ranks alternatives by frequency. "I went two the store" is flagged because went two the is rare in the corpus while went to the is common. This catches errors that no rule anticipated. Statistical layers were the state of the art from the early 2000s through about 2018, and they remain useful as a backstop today.

Layer 3: Neural sequence models. Modern checkers like Grammarly and ProWritingAid run transformer-based models trained on millions of human-corrected sentences. The training data is essentially: original sentence, corrected sentence, edit type. The model learns to suggest edits in context, including edits no rule writer ever explicitly encoded. This layer catches subject-verb agreement at distance, tense consistency, register shifts, and other deeply contextual errors. It is also where false positives originate — the model sometimes "corrects" sentences that were fine. Mature systems blend all three layers and weight rule-based suggestions higher when their confidence is high, neural suggestions higher when they are confident, and surface only suggestions where multiple layers agree.

This architecture is not a free-tier feature. Training transformer models for grammar correction requires datasets like the BEA-2019 shared task corpus (around 1M annotated sentences), the Lang-8 learner corpus, and proprietary user-corrected data accumulated over years. The compute cost to retrain on new data is non-trivial. This is why the serious players are paid products and the free in-browser tools are still running 30-pattern regexes. They cannot afford to be anything else.

Concrete Recommendations

Here is what to actually use, ranked by use case.

For everyday writing in the browser: Grammarly's free tier. Grammarly runs a real ML pipeline (rule + statistical + neural). Its free tier catches roughly 80% of what the paid tier catches — enough for emails, social posts, and casual blog drafts. The browser extension works in Gmail, Slack, and most text inputs. The data privacy story is acceptable for non-sensitive content; do not paste medical records or trade secrets into it. The paid tier ($12-30/mo) adds tone detection, plagiarism checking, and more aggressive style suggestions that some writers find annoying.

For privacy-conscious or self-hosted: LanguageTool open source. LanguageTool has a hosted free tier and a paid Premium tier, but the entire engine is open source under LGPL. You can run it locally with docker run -p 8010:8010 erikvl87/languagetool and never send your text to a third party. The browser extension can be configured to point at your local instance. The ruleset is exhaustive (5,000+ rules for English, similar coverage for German, French, Spanish, Portuguese, Russian, Polish, Dutch, and ~20 other languages). The neural layer is weaker than Grammarly's but the rule layer is stronger and more transparent. For technical writers, regulated industries, and anyone who does not want their drafts on someone else's server, this is the right answer.

For long-form fiction and book-length manuscripts: ProWritingAid. ProWritingAid ($30/mo or $399 lifetime) is built around 25+ analytical reports — overused words, sentence length variance, dialogue tags, pacing, sticky sentences, glue index. Its grammar engine is competitive with Grammarly's. Its real value is the editorial reports, which catch patterns invisible to other tools (you used just 47 times in chapter 3). Novelists and non-fiction authors use it more than journalists or marketers.

For French writers and serious bilingual editors: Antidote. Antidote by Druide ($129 one-time) is a desktop-only French and English grammar checker that has been the gold standard for francophone writers since the 1990s. It includes a 128,000-word dictionary, conjugation tables, and a guide to French grammar built into the interface. Its English module is competent but its French detection is unmatched — it catches accord du participe passé errors that LanguageTool and Grammarly routinely miss. If you write in French at any professional level, Antidote pays for itself within a month.

For academic English and ESL writers: Writefull. Writefull is built on a corpus of published academic papers and catches register issues specific to academic writing — this paper presents versus we present, hedging language, citation phrasing. It integrates with Overleaf and Word. Less broadly useful than Grammarly but more accurate inside its niche.

For important text: a real human editor still wins. No automated tool catches the things that matter most in serious writing — argument structure, logical flow, paragraph-level coherence, claims that need a citation, sections that should be cut. A copy editor at $40-80/hr will improve a 2,000-word business piece more than any tool, paid or free. For a book manuscript, a developmental editor and a line editor remain essential. The grammar checker is useful as a first pass before sending to the human, not as a replacement for one.

How to Spot a Fake Free Checker in 30 Seconds

Free in-browser grammar checkers all look professional now — they have nice UI, animated checkmarks, confident result counts. The 30-second test for whether it is a real tool or a 30-pattern regex is the same every time.

Open the network tab. Type a paragraph with a subtle error (subject-verb agreement at distance is the cleanest test — copy the example from this article). Click "Check". If you see no outbound requests, the entire checker is in your browser, which means it is rule-only and almost certainly the standard 30-pattern set. If you see one outbound request to an API, it is either a real backend (good — likely LanguageTool API or similar) or a free wrapper around someone else's API with a tiny daily quota (mediocre, but at least real).

Then test what it catches. Run the regex tripwires (your/you're, could of, doubled words, lowercase i) — every tool catches these. Now run the real tests: subject-verb at distance, tense across clauses, misplaced modifier. If it catches the tripwires and misses the real tests, you have a regex tool dressed up as AI. Pick one of the recommendations above instead.

The Practical Takeaway

Free in-browser grammar checkers are spell checkers in disguise. They run 20-50 hardcoded regex rules and present the results as if they had analysed your prose. They catch the same handful of common typos every other free tool catches, and they miss almost everything that distinguishes good prose from sloppy prose.

If grammar matters — for client work, for published writing, for anything someone else will read carefully — install Grammarly, run LanguageTool locally, or pay for ProWritingAid or Antidote depending on what you write. These tools cost between zero (LanguageTool self-hosted) and $30/mo (ProWritingAid), and the gap between them and the free regex tools is enormous. You will catch errors you did not know you were making.

And for anything truly important, hire a human editor. No model, free or paid, replaces a careful reader who understands what you are trying to say.