# Main Components of Automattic Harper: Rust Core, Language Server, and Plugin Ecosystem

> Explore the Automattic Harper components: a fast Rust core, a language server, and a flexible plugin ecosystem. Enhance your writing with this grammar-checking solution.

- Repository: [Automattic/harper](https://github.com/Automattic/harper)
- Tags: architecture
- Published: 2026-07-27

---

**Automattic/harper is a monorepo grammar-checking ecosystem composed of Rust crates that implement the core engine and JavaScript packages that expose it to editors, browsers, and desktop applications.**

The main components of Automattic Harper are organized into a Cargo workspace of Rust crates and a PNPM workspace of TypeScript packages. This architecture enables offline English grammar checking across platforms, from the foundational `harper-core` engine to the Tauri-based `harper-desktop` application. Every integration ultimately depends on the curated dictionaries and linting rules defined in the Rust core.

## Core Rust Engine and Language Parsers

### harper-core: The Grammar-Checking Foundation

`harper-core` is the fundamental engine responsible for lexing, parsing, rule evaluation, spell-checking, and dictionary handling. As implemented in Automattic/harper, all other crates build on top of this library. The primary entry point is [`harper-core/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-core/src/lib.rs), which exposes the `Document`, `Linter`, and dialect handling APIs.

The crate also consumes specialized format parsers and the Brill-style tagger to produce a unified `Document` representation. You can use the engine directly in Rust:

```rust
use harper_core::{Dialect, Document};
use harper_core::parsers::PlainEnglish;
use harper_core::linting::{LintGroup, Linter};
use harper_core::spell::FstDictionary;

let text = "This is an test.";
let parser = PlainEnglish;
let document = Document::new_curated(text, &parser);
let dict = FstDictionary::curated();
let mut linter = LintGroup::new_curated(dict, Dialect::American);

for lint in linter.lint(&document) {
    println!("{:?}", lint);
}

```

### harper-brill: Part-of-Speech Tagging

`harper-brill` implements a Brill-style tagger used for part-of-speech tagging in the core pipeline. Its implementation lives in [`harper-brill/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-brill/src/lib.rs).

### Format-Specific Parsers

Small dedicated crates turn markup languages into the core `Document` representation. These include:

- `harper-html` – [`harper-html/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-html/src/lib.rs)
- `harper-asciidoc` – [`harper-asciidoc/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-asciidoc/src/lib.rs)
- `harper-typst` – [`harper-typst/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-typst/src/lib.rs)

### harper-comments: Linting Inside Source Code

`harper-comments` provides language-specific comment parsers for Rust, Python, JavaScript, and other languages. This allows the engine to lint prose embedded in source-code comments. The implementation resides in [`harper-comments/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-comments/src/lib.rs).

## Language Server and CLI Tooling

### harper-ls: LSP Implementation for Editors

`harper-ls` is the Language Server Protocol implementation that powers the VS Code, Neovim, Helix, Emacs, and Zed integrations. The server entry point is [`harper-ls/src/main.rs`](https://github.com/Automattic/harper/blob/main/harper-ls/src/main.rs). It consumes `harper-core` diagnostics and translates them into LSP-compatible messages for real-time highlighting and suggestions.

### harper-cli: Stand-Alone Debugging and Linting

`harper-cli` offers a command-line interface for debugging the core engine, testing parsers, and running lint jobs manually. Its front-end code is located in [`harper-cli/src/main.rs`](https://github.com/Automattic/harper/blob/main/harper-cli/src/main.rs).

## WebAssembly and JavaScript Bindings

### harper-wasm: Core Engine Compiled to WASM

`harper-wasm` is the low-level WebAssembly build of the core engine. According to the Automattic/harper source code, [`harper-wasm/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-wasm/src/lib.rs) builds the `.wasm` artifact that powers browser and Node.js usage.

### harper-js: Browser and Node.js API

`harper-js` wraps `harper-wasm` with a thin JavaScript API, making the engine accessible in browsers or Node.js applications. The following example demonstrates linting a string with [`harper.js`](https://github.com/Automattic/harper/blob/main/harper.js):

```js
import { Linter, Document, PlainEnglish, FstDictionary, Dialect } from "harper.js";

const text = "She don't like it.";
const doc = new Document(text, new PlainEnglish());
const dict = await FstDictionary.curated();
const linter = new Linter(dict, Dialect.American);

const lints = await linter.lint(doc);
console.log(lints);

```

## Desktop Application and Web Interface

### harper-desktop: Native Tauri Application

`harper-desktop` is a native desktop app built with Tauri v2 and SvelteKit. It provides an offline editor, a system-wide overlay highlighter, and a settings UI. The SvelteKit-based editor view lives at [`harper-desktop/src/lib/EditorView.svelte`](https://github.com/Automattic/harper/blob/main/harper-desktop/src/lib/EditorView.svelte).

### packages/web: Documentation Site and Live Demo

`packages/web` hosts the public documentation site at `writewithharper.com`, built with Vite and SvelteKit. It also hosts the live demo. See [`packages/web/README.md`](https://github.com/Automattic/harper/blob/main/packages/web/README.md) for build details.

## Editor Integrations and Shared UI

### VS Code, Chrome, Firefox, and Obsidian Plugins

The repository contains integration glue for popular editors and platforms, including VS Code, Chrome, Firefox, Obsidian, and WordPress:

- **VS Code** – [`packages/vscode-plugin/src/extension.ts`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/extension.ts) interfaces with `harper-ls`.
- **Chrome/Firefox** – [`packages/chrome-plugin/src/background.ts`](https://github.com/Automattic/harper/blob/main/packages/chrome-plugin/src/background.ts) handles browser-level linting.
- **Obsidian** – [`packages/obsidian-plugin/src/main.ts`](https://github.com/Automattic/harper/blob/main/packages/obsidian-plugin/src/main.ts) connects the core engine to the Obsidian note-taking app.

VS Code users can configure the language server through settings:

```json
{
  "harper.lintOnSave": true,
  "harper.enabledRules": ["spelling", "comma-style"]
}

```

### lint-framework: Shared Web UI Components

`lint-framework` contains shared web UI components—such as spans, highlights, and suggestion pop-ups—used by both the website demo and the desktop overlay. Its source is tracked in [`packages/lint-framework/README.md`](https://github.com/Automattic/harper/blob/main/packages/lint-framework/README.md).

## Workspace Coordination

The entire ecosystem is coordinated through a Cargo workspace defined by [`Cargo.toml`](https://github.com/Automattic/harper/blob/main/Cargo.toml) at the repository root and a PNPM workspace declared in [`pnpm-workspace.yaml`](https://github.com/Automattic/harper/blob/main/pnpm-workspace.yaml). This setup makes it possible to share core engine code, dictionary data, and build artifacts across Rust binaries, WebAssembly targets, and JavaScript packages.

## Summary

- **`harper-core`** is the Rust foundation that handles lexing, parsing, linting, and spell-checking.
- **`harper-ls`** exposes grammar diagnostics to editors via the Language Server Protocol.
- **`harper-wasm`** and **`harper-js`** make the engine portable to browsers and Node.js.
- **`harper-desktop`** delivers an offline, native editing experience with Tauri.
- **Integration plugins** for VS Code, Obsidian, Chrome, and Firefox connect the engine to user workflows.
- **Format-specific parsers**—including `harper-html`, `harper-asciidoc`, and `harper-typst`—extend linting to markup languages.
- The **Cargo** and **PNPM** workspaces unify the Rust and JavaScript build graphs.

## Frequently Asked Questions

### What is the core grammar engine in Automattic Harper?

The core engine is `harper-core`, implemented in [`harper-core/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-core/src/lib.rs). It manages lexing, parsing, rule evaluation, spell-checking, and dictionary handling, and it exposes the `Document` and `Linter` APIs that all other components consume.

### How does Harper integrate with code editors?

Harper integrates through `harper-ls`, a Language Server Protocol implementation whose entry point is [`harper-ls/src/main.rs`](https://github.com/Automattic/harper/blob/main/harper-ls/src/main.rs). Editor-specific plugins—such as the VS Code extension at [`packages/vscode-plugin/src/extension.ts`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/extension.ts)—communicate with this server to provide real-time diagnostics.

### Can Harper run inside a web browser?

Yes. The `harper-wasm` crate compiles the core engine to WebAssembly via [`harper-wasm/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-wasm/src/lib.rs), and the `harper-js` package wraps it for use in browsers or Node.js. The public site at `writewithharper.com` also hosts a live browser demo.

### What desktop application does Harper provide?

Harper provides `harper-desktop`, a native application built with Tauri v2 and SvelteKit. It includes an offline editor, a system-wide overlay highlighter, and a settings UI, with the primary view implemented in [`harper-desktop/src/lib/EditorView.svelte`](https://github.com/Automattic/harper/blob/main/harper-desktop/src/lib/EditorView.svelte).