Readability scoring has a problem. Most writing tools check your text against a single formula—usually Flesch-Kincaid—and give you one number. That number is a guess. Different formulas measure different things (syllable count, word familiarity, sentence length), and they routinely disagree on the same text by 2–4 grade levels.
I wanted a tool that used multiple formulas, ran in the browser without uploading text to a server, and gave me more than one metric. I couldn't find one, so I built it. Full disclosure: I'm the creator of ProseScore and the textlens npm package that powers it.
The single-formula problem
Hemingway Editor is the most popular readability tool for writers. It highlights complex sentences and gives you a grade level. Under the hood, it uses one readability formula.
Here's why one formula isn't enough.
Consider this sentence: "The oncologist discussed the prognosis with the patient." Flesch-Kincaid gives it a low grade level because the sentence is short (8 words, one clause). But Dale-Chall—which checks words against a list of 3,000 common English words—flags "oncologist" and "prognosis" as unfamiliar vocabulary. The sentence is structurally clear but requires domain knowledge to understand.
A single formula can't catch both structural complexity and vocabulary difficulty. Each of the 8 major readability formulas uses different inputs:
| Formula | What it measures |
|---|---|
| Flesch-Kincaid | Syllables per word, words per sentence |
| Gunning Fog | Percentage of 3+ syllable words |
| SMOG | Polysyllabic word count (predicts 100% comprehension) |
| Coleman-Liau | Characters per word (no syllable counting) |
| ARI | Characters per word, words per sentence |
| Dale-Chall | Word familiarity against a 3,000-word list |
| Linsear Write | Easy vs. hard word ratio |
| Flesch Reading Ease | Same inputs as FK, different scale (0–100) |
When you run all 8 and average the 7 that output grade levels, you get a consensus grade. The consensus smooths out individual formula quirks. If six formulas say grade 8 and one says grade 13, the outlier is probably measuring something atypical about the text, and the average reflects that.
What else is missing from current tools
Privacy. Most readability tools send your text to a server for processing. If you're checking a draft blog post, that's fine. If you're checking a legal contract, internal memo, or patient health record, that's a problem. Text should stay on your machine.
More than readability. Grade level tells you how hard the text is to read. It doesn't tell you whether the tone is appropriate, which keywords dominate, or whether the text is structured well for search engines. Writers and editors need these signals together, not in separate tools.
Pricing. Hemingway Editor charges $8–$170/month depending on the plan. Grammarly starts at $12/month. These tools bundle grammar checking with readability, which makes sense for some users. But if you want readability analysis without the grammar layer, you're overpaying.
How ProseScore works
ProseScore is a web app. You paste text (or upload a file), and it returns:
- 8 readability scores with a consensus grade level
- Sentiment analysis (positive/negative/neutral with confidence)
- Keyword extraction (top terms by frequency and relevance)
- SEO scoring (keyword density, heading structure, meta assessment)
- Basic stats (word count, sentence count, paragraph count, reading time)
The free tier includes Flesch-Kincaid, word/sentence/paragraph counts, and reading time. The Pro tier ($3.99/month or $19.99 lifetime) unlocks all 8 formulas, consensus grade, sentiment, keywords, SEO, and more.
Everything runs in your browser. No text leaves the page. There's no backend that processes your content. The analysis engine is a JavaScript bundle loaded at page open.
The technical stack
ProseScore is built on textlens, an open-source npm package I wrote for text analysis. textlens has zero dependencies and implements all 8 readability formulas, sentiment analysis, keyword extraction, and SEO scoring in TypeScript.
For the web app, textlens is bundled as an IIFE (Immediately Invoked Function Expression) that attaches to window.textlens. The page itself is ~46KB. The textlens engine bundle is ~145KB. Total page weight under 200KB—no framework, no build step at runtime.
The architecture looks like this:
User pastes text
→ JavaScript calls textlens.readability(text)
→ textlens.sentiment(text)
→ textlens.keywords(text)
→ textlens.seo(text, { keyword })
→ Results rendered to DOM
→ Nothing leaves the browserAll analysis happens synchronously in the main thread. For typical blog posts and articles (under 10,000 words), the analysis completes in under 50ms. No Web Workers needed.
Why IIFE instead of ESM
textlens publishes ESM and CommonJS builds for Node.js and bundler users. For a standalone web app with no build step, IIFE is the pragmatic choice. One <script> tag, one global, no module resolution overhead. The browser caches it after the first load.
Consensus scoring implementation
The consensus grade averages 7 formula outputs (excluding Flesch Reading Ease, which uses a 0–100 scale instead of grade levels). Each formula returns a grade, and the consensus is their arithmetic mean, rounded to one decimal.
import { readability } from 'textlens';
const result = readability(sampleText);
console.log(result.consensusGrade);
// e.g., 8.3 (average of FK, Fog, SMOG, CLI, ARI, DC, LW)This is the same approach used in academic readability research. No single formula is "right." The consensus is more stable across different text types than any individual score.
Privacy architecture
ProseScore collects zero user data. There are no analytics scripts, no tracking pixels, no cookies (beyond a Pro license token stored in localStorage). The text you paste never touches a network request.
The Pro license verification works via a signed JWT. After purchasing through Stripe, users receive a license key. The app validates the key structure locally. A one-time verification call to a Cloudflare Worker confirms the key is valid. After that, the token is stored in localStorage and the app operates fully offline.
This isn't a privacy policy claim. It's an architectural constraint. The app has no endpoint that accepts text input. There is no place for your text to go.
Dark mode
Hemingway Editor has no dark mode. This sounds minor, but writers who work at night or prefer dark interfaces have been asking for it since at least 2019. ProseScore supports both light and dark themes, toggled with a button. The preference persists in localStorage.
Who this is for
ProseScore is for anyone who writes and wants to understand the readability of their text without subscribing to a grammar tool.
- Technical writers checking documentation against a target grade level
- Content marketers optimizing blog posts for readability and SEO
- Healthcare communicators verifying patient materials meet literacy guidelines (SMOG is the standard here)
- Developers who want the raw numbers without the grammar suggestions
If you need grammar checking, ProseScore isn't the right tool. It does one thing—text analysis—and does it with more depth than the alternatives.
Try it
ProseScore is live at prosescore.ckmtools.dev. The free tier gives you Flesch-Kincaid, word counts, and reading time. The source code for the underlying engine is on GitHub.
If you want to integrate readability scoring into your own projects, textlens is available on npm with zero dependencies.