# Can You Fork Automattic/harper? License Terms and Complete Setup Guide

> Yes, you can fork Automattic/harper under the Apache-2.0 license. Learn the complete setup guide for modifying and redistributing this grammar-checking ecosystem.

- Repository: [Automattic/harper](https://github.com/Automattic/harper)
- Tags: how-to-guide
- Published: 2026-07-26

---

**Yes, you can freely fork Automattic/harper under the Apache-2.0 license, which explicitly grants rights to copy, modify, and redistribute the entire grammar-checking ecosystem provided you maintain the copyright notice and license file.**

Automattic/harper is an open-source grammar-checking engine built primarily in Rust with WebAssembly bindings for JavaScript environments. Because the repository is released under the permissive Apache-2.0 license found in the root `LICENSE` file, you can fork the project to customize linting rules, create private distributions, or integrate the engine into commercial applications.

## Understanding Your Rights Under the Apache-2.0 License

The `LICENSE` file at the repository root establishes the legal framework for forking. This permissive open-source license allows you to:

- **Copy and redistribute** the source code or compiled binaries
- **Modify** any component, including the core engine in `harper-core/` or the language server in `harper-ls/`
- **Sublicense** your modifications under the same Apache-2.0 terms
- **Use commercially** without releasing your proprietary source code

You must preserve the original copyright notice and include a copy of the Apache-2.0 license in any distribution. The license also provides an express grant of patent rights from contributors, which protects you from patent litigation regarding the codebase.

## Repository Architecture Overview

Before forking, understand the multi-crate structure that comprises the Harper ecosystem:

- **harper-core**: The Rust grammar engine containing rule definitions and dictionaries. Located in `harper-core/`, documented in [`harper-core/README.md`](https://github.com/Automattic/harper/blob/main/harper-core/README.md).
- **harper-ls**: Language Server Protocol implementation for IDE integration (Neovim, VS Code, etc.). Located in `harper-ls/`.
- **harper-js**: WebAssembly wrapper exposing the core engine to browsers and Node.js. Located in `packages/harper.js/`, documented in [`packages/harper.js/README.md`](https://github.com/Automattic/harper/blob/main/packages/harper.js/README.md).
- **harper-desktop**: Standalone Tauri-based application with overlay highlighter. Located in `harper-desktop/`, documented in [`harper-desktop/README.md`](https://github.com/Automattic/harper/blob/main/harper-desktop/README.md).
- **Integration plugins**: Browser extensions and editor plugins found in `packages/` (VS Code, Chrome, Firefox, Obsidian).

## How to Fork and Set Up Automattic/harper

### Creating Your Fork on GitHub

Click the **Fork** button on the GitHub repository page to create a personal copy under your account, or clone the repository directly:

```bash
git clone https://github.com/Automattic/harper.git
cd harper

```

Push this to your own remote to maintain a separate fork.

### Development Environment Setup

Install the required toolchains to build from source:

1. **Rust toolchain** via rustup (required for `harper-core`, `harper-ls`, and `harper-desktop`)
2. **Node.js and pnpm** for JavaScript packages and WebAssembly compilation
3. **just** task runner for standardized build commands

Refer to [`CONTRIBUTING.md`](https://github.com/Automattic/harper/blob/main/CONTRIBUTING.md) for exact version requirements and platform-specific setup instructions.

## Customization Examples for Your Fork

### Using harper.js in Node.js

After building the WebAssembly bindings from your fork, you can import the linter in Node.js applications:

```javascript
import { LocalLinter } from "harper.js";

const linter = new LocalLinter();
const text = "This are a typo.";
const result = await linter.lint(text);

console.log(result.lints.map(l => l.message));
// → [ '“are” should be “is”' ]

```

Source code for this API is documented in [`packages/harper.js/README.md`](https://github.com/Automattic/harper/blob/main/packages/harper.js/README.md).

### Adding a Custom Grammar Rule in harper-core

Extend the engine by implementing the `Rule` trait in your forked `harper-core/src/`:

```rust
use harper_core::linting::Rule;
use harper_core::document::Document;

pub struct MyRule;

impl Rule for MyRule {
    fn name(&self) -> &'static str { "my_rule" }
    
    fn check(&self, doc: &Document) -> Vec<Lint> {
        doc.tokens()
            .filter(|t| t.text == "foobar")
            .map(|t| Lint::new(t.range, "Avoid the word “foobar”."))
            .collect()
    }
}

```

The contributor documentation at `packages/web/src/routes/docs/contributors/author-a-rule/+page.md` explains the rule architecture and `Lint` construction patterns.

### Running the Desktop Highlighter

Test your modifications using the Tauri-based desktop application:

```bash
just dev-desktop

```

This command launches the overlay highlighter as defined in [`harper-desktop/README.md`](https://github.com/Automattic/harper/blob/main/harper-desktop/README.md), hot-reloading changes to the underlying Rust code.

## Essential Files to Review in Your Fork

After forking, examine these key files to understand the codebase:

- **`LICENSE`**: Apache-2.0 license text and copyright notice
- **[`CONTRIBUTING.md`](https://github.com/Automattic/harper/blob/main/CONTRIBUTING.md)**: Build instructions, testing commands (`just test-rust`), and PR guidelines
- **[`harper-core/README.md`](https://github.com/Automattic/harper/blob/main/harper-core/README.md)**: Core engine architecture and dictionary management
- **[`harper-ls/README.md`](https://github.com/Automattic/harper/blob/main/harper-ls/README.md)**: LSP implementation details and editor configuration
- **[`packages/harper.js/README.md`](https://github.com/Automattic/harper/blob/main/packages/harper.js/README.md)**: WebAssembly bindings and JavaScript API

## Summary

- Automattic/harper is licensed under **Apache-2.0**, permitting unrestricted forking for personal or commercial use
- The repository contains **Rust crates** and **JavaScript packages** requiring both Rust and Node.js toolchains to build
- You can **customize grammar rules** by implementing the `Rule` trait in `harper-core/src/linting/`
- All redistributions must **preserve copyright notices** and include the original `LICENSE` file
- Use **`just dev-desktop`** to test changes in the standalone Tauri application

## Frequently Asked Questions

### Can I fork Automattic/harper for commercial use?

Yes. The Apache-2.0 license explicitly permits commercial use, including incorporating the grammar engine into proprietary products or selling modified versions. You must include the original copyright notice and license file, but you are not required to open-source your proprietary modifications or pay royalties.

### What attribution is required when redistributing a fork?

You must retain all copyright notices, patent grants, and the disclaimer of warranty found in the root `LICENSE` file. Include a copy of the Apache-2.0 license in any source or binary distribution, and document any significant changes you make to the codebase in a `NOTICE` file or similar prominent location.

### How do I submit improvements back to the upstream repository?

After forking and making changes, push your branch to your GitHub remote and open a Pull Request against `Automattic/harper`. Follow the guidelines in [`CONTRIBUTING.md`](https://github.com/Automattic/harper/blob/main/CONTRIBUTING.md), which specifies the use of the `just` task runner for testing (e.g., `just test-rust`) and code formatting requirements using the project's standard Rustfmt configuration.

### Which components can I modify without breaking the ecosystem?

You can safely modify individual components if you maintain their public APIs. Custom rules in `harper-core/src/linting/` are safe to add without affecting downstream crates. UI changes in `harper-desktop/` and plugin packages (`packages/vscode-plugin/`, etc.) can be modified independently. However, breaking changes to `harper-core` public APIs will require corresponding updates in `harper-js` and `harper-ls` to maintain compatibility across the ecosystem.