# What Programming Languages Are Used in Automattic/​Harper? A Polyglot Codebase Breakdown

> Explore the polyglot codebase of Automattic/harper. Discover the primary languages like Rust, TypeScript, and JavaScript, along with supporting languages used in its development.

- Repository: [Automattic/harper](https://github.com/Automattic/harper)
- Tags: deep-dive
- Published: 2026-08-01

---

**Automattic/​Harper uses Rust as its core engine, TypeScript/JavaScript for web front-ends and extensions, plus Python, Swift, C, C++, and Go for bindings and test fixtures.**

Harper is an open-source grammar checker built as a language-server-powered linting engine. Understanding what programming languages are used in Automattic/​Harper helps contributors navigate its monorepo structure and developers integrate it into their own tools.

## Rust: The Core Grammar Engine

**Rust** powers Harper's heart: the grammar-checking engine, language server protocol (LSP) implementation, WebAssembly bindings, desktop backend, and CLI utilities.

The core library lives in [`harper-core/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-core/src/lib.rs). Here, the `Linter` struct provides the main API for analyzing text:

```rust
use harper_core::{Linter, LintConfig};

fn main() {
    let config = LintConfig::new_curated();
    let linter = Linter::new(config);
    let text = "Their are many errors.";
    let results = linter.lint(text);
    for lint in results {
        println!("{}: {}", lint.message, lint.range);
    }
}

```

Key Rust components span multiple crates:

- **`harper-core`** – grammar engine and rule definitions
- **`harper-cli`** – command-line interface
- **`harper-ls`** – LSP server for editor integration
- **`harper-wasm`** – browser-compatible WASM build
- **`harper-python`** – pyo3-based Python bindings

The workspace configuration in [`Cargo.toml`](https://github.com/Automattic/harper/blob/main/Cargo.toml) declares all crates:

```toml
[workspace]
members = [
    "harper-core",
    "harper-cli",
    "harper-ls",
    "harper-wasm",
    "harper-python",
    # ...

]

```

## TypeScript and JavaScript: The Front-End Ecosystem

**TypeScript** dominates Harper's user-facing layers: web extensions, desktop UIs, and the official web demo. **JavaScript** appears in build scripts, test harnesses, and legacy modules.

The `LocalLinter` class in [`packages/harper.js/src/main.ts`](https://github.com/Automattic/harper/blob/main/packages/harper.js/src/main.ts) wraps the WASM core for browser use:

```ts
import { LocalLinter } from '@harper-linter/harper.js';

async function lintDemo() {
  const linter = await LocalLinter.create();   // loads the WASM binary
  const text = document.querySelector('textarea')!.value;
  const diagnostics = await linter.lint(text);
  console.log(diagnostics);
}
lintDemo();

```

TypeScript surfaces include:

- **VS Code extension** ([`packages/vscode-plugin/src/extension.ts`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/extension.ts))
- **Obsidian plugin**
- **Chrome extension**
- **WordPress plugin** (uses TSX for UI components)
- **Web demo** (`packages/web/src/routes/editor/+page.ts`)

Configuration files like [`package.json`](https://github.com/Automattic/harper/blob/main/package.json) and [`tailwind.config.js`](https://github.com/Automattic/harper/blob/main/tailwind.config.js) anchor the JavaScript tooling.

## Python Bindings

**Python** support exists via a thin wrapper exposing Harper functionality through pyo3. The binding implementation resides in [`harper-python/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-python/src/lib.rs)—Rust code that uses the `pyo3` crate to generate Python-compatible modules.

This lets Python developers import and use Harper's linting capabilities natively:

```python

# After installing the harper-python package

from harper import Linter

linter = Linter()
results = linter.lint("This sentence have errors.")

```

## Test Fixture Languages

Harper includes additional **programming languages used in Automattic/​Harper** strictly for testing comment-parsing accuracy across editors. These appear as fixture files rather than production code:

- **Swift** – [`packages/vscode-plugin/src/tests/fixtures/languages/swift.swift`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/tests/fixtures/languages/swift.swift)
- **C** – [`harper-comments/tests/language_support_sources/ignore_comments.c`](https://github.com/Automattic/harper/blob/main/harper-comments/tests/language_support_sources/ignore_comments.c)
- **C++** – [`harper-comments/tests/language_support_sources/multiline_comments.cpp`](https://github.com/Automattic/harper/blob/main/harper-comments/tests/language_support_sources/multiline_comments.cpp)
- **Go** – [`packages/vscode-plugin/src/tests/fixtures/languages/go.go`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/tests/fixtures/languages/go.go)

These fixtures ensure Harper correctly extracts and lints prose embedded in source code comments regardless of the host language.

## Markup and Templating

UI components in the WordPress plugin and web packages use **HTML**, **JSX**, and **TSX** for component structure. Example: [`packages/wordpress-plugin/src/harper/index.tsx`](https://github.com/Automattic/harper/blob/main/packages/wordpress-plugin/src/harper/index.tsx) defines the WordPress admin interface in TypeScript with React-style JSX.

## Summary

Harper's polyglot architecture separates concerns by language strength:

- **Rust** delivers performance-critical parsing and cross-platform compilation (native + WASM)
- **TypeScript/JavaScript** enables rapid UI development and deep editor ecosystem integration
- **Python** extends reach to data science and automation workflows
- **C, C++, Swift, Go** fixtures validate multi-language comment parsing

Key files to explore:
- [`Cargo.toml`](https://github.com/Automattic/harper/blob/main/Cargo.toml) – Rust workspace structure
- [`package.json`](https://github.com/Automattic/harper/blob/main/package.json) – npm package graph
- [`harper-core/src/lib.rs`](https://github.com/Automattic/harper/blob/main/harper-core/src/lib.rs) – core engine entry point
- [`packages/vscode-plugin/src/extension.ts`](https://github.com/Automattic/harper/blob/main/packages/vscode-plugin/src/extension.ts) – TypeScript/Rust bridge example

## Frequently Asked Questions

### Is Harper written entirely in Rust?

No. While the grammar engine and performance-critical components are Rust, Harper uses TypeScript for all web extensions and UIs, JavaScript for build tooling, and Python for language bindings. Test fixtures include C, C++, Swift, and Go code.

### Can I use Harper as a Python library?

Yes. The `harper-python` crate exposes Harper's `Linter` through pyo3. Install the built wheel, then import `from harper import Linter` in your Python scripts.

### Why does Harper include Swift, C, and Go files?

These are test fixtures in `packages/vscode-plugin/src/tests/fixtures/` and `harper-comments/tests/`. They verify that Harper's comment parser correctly handles documentation strings and inline comments across many source languages.

### What is the relationship between the Rust core and TypeScript extensions?

The Rust core compiles to WebAssembly for browser contexts and native binaries for desktop. TypeScript extensions load this WASM module or communicate via the language server protocol, providing UI layers without duplicating grammar logic.