Harper: The Open-Source, Privacy-First Grammar Checker That's Taking on Grammarly — 13,100+ GitHub Stars

If you're a developer, technical writer, or anyone who values privacy, you've probably wrestled with grammar checkers that feel either too aggressive, too expensive, or too invasive. Grammarly dominates the market, but at what cost? Every word you write gets shipped to their servers, potentially feeding large language models and creating privacy concerns that most users never consider.

Enter Harper — an open-source, privacy-first grammar checker that's been quietly revolutionizing how we think about writing assistance. Built in Rust by the team at Automattic (the company behind WordPress), Harper has amassed over 13,100 GitHub stars and gained 876 stars in a single day, proving that developers are hungry for a grammar tool that respects their privacy without sacrificing performance.

Why Harper Exists: The Grammar Checker Gap

Harper's creator built the tool after years of frustration with existing solutions. The problems were clear:

• Grammarly was too expensive, too overbearing, and its suggestions often lacked context or were simply wrong. Worse, it's a privacy nightmare — everything you write gets sent to their servers, and while their privacy policy claims they don't sell data, that doesn't prevent them from using it to train large language models.
• LanguageTool required gigabytes of RAM and a ~16GB n-gram dataset download. Besides the memory requirements, it was painfully slow, taking several seconds to lint even moderate-size documents.

Harper was designed to be "just right" — fast enough to keep up with your typing, private enough to never compromise your data, and intelligent enough to catch the mistakes that actually matter.

Privacy That Actually Means Something

In an era where every tool wants to phone home, Harper stands apart by being genuinely private. Every single grammar check happens locally on your device. No cloud round-trips. No telemetry. No LLM in the loop analyzing your writing patterns.

This isn't just marketing speak — it's architectural reality. Harper's core engine is written in Rust and compiled to WebAssembly, allowing it to run entirely in your browser, code editor, or terminal without ever connecting to external servers. Your writing stays yours, period.

For developers working on proprietary code, technical writers handling sensitive documentation, or anyone concerned about data sovereignty, this distinction matters enormously. You're not just getting a grammar checker — you're getting peace of mind.

Performance That Redefines Expectations

Harper's team considers long lint times to be bugs, not features. The result? Suggestions appear in under 10 milliseconds — fast enough to provide real-time feedback as you type, without the lag that plagues cloud-based alternatives.

Here's the performance comparison:

Tool	Lint Time	Memory Usage	Privacy
Harper	<10ms	~50MB	100% local
Grammarly	200-500ms	N/A (cloud)	Cloud-based
LanguageTool	2-5 seconds	~2.5GB	Local (with download)

Harper uses less than 1/50th of LanguageTool's memory footprint while delivering results orders of magnitude faster. This efficiency comes from Rust's zero-cost abstractions and Harper's rule-based architecture, which avoids the overhead of large language models entirely.

Integration Everywhere You Write

Harper's philosophy is simple: one grammar checker, every place you write. The project offers integrations across the entire development and writing ecosystem:

Code Editors via Language Server Protocol

Harper provides harper-ls, a Language Server Protocol implementation that works with virtually any modern editor:

# Install via Homebrew (macOS/Linux)
brew install harper

# Install via Cargo (Rust)
cargo install harper-ls --locked

# Install via Scoop (Windows)
scoop install harper

Once installed, Harper integrates seamlessly with:

• Visual Studio Code — Full extension support with inline suggestions
• Neovim — Native LSP integration for terminal enthusiasts
• Helix, Emacs, Zed, Sublime Text — All supported out of the box

For code comments and documentation, Harper understands most programming languages and provides intelligent linting without false positives on code syntax.

Browser Extensions and Web Apps

Harper offers browser extensions for Chrome and Firefox that work across Gmail, Google Docs, social media, and any text input field. The extensions run the same local WebAssembly engine, ensuring consistent performance and privacy regardless of where you're writing.

JavaScript/TypeScript Integration

For web developers building writing-focused applications, harper.js provides a clean API to integrate grammar checking into your own tools:

npm install --save harper.js

import { Linter } from 'harper.js';

const linter = new Linter();
const results = await linter.lint('Your text here');

results.forEach(suggestion => {
  console.log(suggestion.message);
  console.log(suggestion.replacement);
});

The library uses WebAssembly under the hood, making it trivial to add grammar checking to React apps, Electron applications, or any JavaScript environment.

Obsidian and WordPress Plugins

Content creators using Obsidian for note-taking or WordPress for publishing can install dedicated plugins that bring Harper's capabilities directly into their workflow. No configuration required — just install and start writing with confidence.

Intelligent Dictionaries for Every Context

One of Harper's most powerful features is its multi-layered dictionary system, which understands that different words are appropriate in different contexts:

• User Dictionary — Personal words that apply across all your projects (technical jargon, names, acronyms)
• Workspace Dictionary — Project-specific terminology shared with your team
• File-Local Dictionary — Words that only make sense in a specific document
• Static Dictionary — Built-in comprehensive English vocabulary

This hierarchy means you can add "Kubernetes" to your workspace dictionary once, and Harper won't flag it in any file within that project. But it won't clutter your personal dictionary with project-specific terms.

// Example: Adding to dictionaries via code actions
// When Harper flags a word, you get options:
// - Add to user dictionary (global)
// - Add to workspace dictionary (project)
// - Add to file dictionary (document-specific)
// - Ignore this instance

For developers working across multiple codebases, this granular control prevents dictionary pollution and keeps suggestions relevant.

Real-World Example: Technical Documentation Workflow

Let's see how Harper transforms a typical documentation workflow. Imagine you're writing API documentation in Markdown:

# User Authentication API

The authentication endpoint accepts POST requests with user credentials. 
It returns a JWT token that should be included in subsequent requests 
via the Authorization header.

## Example Request

```json
{
  "email": "user@example.com",
  "password": "securepassword123"
}
```

Note: Tokens expire after 24 hours and must be refreshed.

Without Harper, you might miss subtle issues like:

• "accepts" vs "accept" (subject-verb agreement)
• Inconsistent capitalization of "JWT" vs "jwt"
• Missing Oxford commas in lists
• Long sentences that reduce readability

With Harper running in your editor, these issues get flagged instantly as you type, with suggestions that respect technical context. Harper knows "JWT" is a valid acronym, "API" doesn't need expansion, and code blocks should be ignored entirely.

The result? Documentation that reads professionally without requiring a separate editing pass or sending your proprietary API details to cloud services.

Key Benefits for Developers

• Zero Privacy Risk — Your code comments, documentation, and writing never leave your device. Critical for proprietary projects and compliance requirements.
• Instant Feedback — Sub-10ms suggestions mean grammar checking doesn't interrupt your flow. Write naturally and catch errors as they happen.
• Minimal Resource Usage — Harper's tiny memory footprint won't slow down your IDE or consume precious RAM on memory-constrained systems.
• Open Source Freedom — Apache-2.0 license means you can inspect the code, contribute improvements, or fork it for custom needs. No vendor lock-in.
• Universal Compatibility — From VS Code to Neovim, Chrome to Obsidian, Harper meets you where you already work.
• No Account Required — Start using Harper immediately without creating accounts, verifying emails, or managing subscriptions.
• Context-Aware Suggestions — Harper understands technical writing conventions and won't flag legitimate jargon, acronyms, or code-like syntax.
• Offline Reliability — Works perfectly without internet connection. No service outages, no rate limits, no dependency on external infrastructure.

Frequently Asked Questions

Is Harper really completely free?

Yes. Harper is free in every sense of the word. It's released under the Apache-2.0 open-source license, requires no credit card, no account creation, and no premium tiers. Every feature is available to every user without restriction.

How does Harper compare to Grammarly in terms of accuracy?

Harper focuses on catching the mistakes that matter most: improper capitalization, misspelled words, awkward phrasing, and broken grammar. While Grammarly offers more stylistic suggestions, Harper's rule-based approach avoids the false positives and overbearing corrections that frustrate many Grammarly users. Harper will never intentionally suggest an edit that changes your intended meaning.

Can I use Harper with languages other than English?

Currently, Harper only supports English and its dialects (American, British, Australian, Canadian, and Indian). The core architecture is extensible, and the team welcomes contributions for other languages, but they want English support to be truly excellent before diversifying.

Does Harper work offline?

Absolutely. Harper is designed to work entirely offline. Once installed, it requires no internet connection whatsoever. This makes it perfect for air-gapped environments, travel, or anywhere with unreliable connectivity.

What programming languages does Harper support for code comments?

Harper's language server supports most programming languages' comment syntax out of the box, including JavaScript, TypeScript, Python, Rust, Go, Java, C++, and many more. It also fully supports Markdown files. The project actively welcomes pull requests to add support for additional languages.

How do I add custom words to Harper's dictionary?

When Harper flags a word, you can use code actions to add it to your user dictionary (global), workspace dictionary (project-specific), or file-local dictionary (document-specific). You can also manually edit the dictionary files, which are simple line-separated word lists.

Will Harper slow down my editor or IDE?

No. Harper is engineered for performance, with lint times under 10 milliseconds and minimal memory usage. Most users report that Harper feels instant and doesn't impact editor responsiveness, even on large documents.

Can I use Harper in my own application?

Yes. Harper provides multiple integration paths: harper.js for JavaScript/TypeScript applications, harper-core for Rust programs, and harper-ls for any editor supporting the Language Server Protocol. All are open-source and freely available.

What about grammar rules for technical writing?

Harper is specifically designed to excel at technical writing. It understands common conventions like acronyms, code-like syntax, and technical jargon. You can configure which linters to enable (spelling, capitalization, long sentences, etc.) to match your documentation standards.

How often is Harper updated?

Harper is actively maintained by Automattic and the open-source community. Updates are released regularly with new rules, bug fixes, and performance improvements. The project has a public roadmap and welcomes community contributions.

Getting Started with Harper

Ready to try Harper? Here's the fastest path to better writing:

1. Install the language server: brew install harper (macOS/Linux) or scoop install harper (Windows)
2. Add to your editor: Install the Harper extension for VS Code, or configure your editor's LSP client to use harper-ls
3. Start writing: Open any Markdown file or code file with comments, and Harper will begin providing suggestions automatically

For browser-based writing, install the Chrome or Firefox extension and start using Harper immediately in Gmail, Google Docs, or any text field.

Harper represents a fundamental shift in how we think about writing assistance. It proves that privacy and performance aren't mutually exclusive, that open-source tools can compete with commercial giants, and that developers deserve tools that respect both their time and their data.

With over 13,100 GitHub stars and growing community support, Harper isn't just an alternative to Grammarly — it's the future of grammar checking for developers who value privacy, performance, and control over their tools.