textlint

The pluggable linting tool for natural language.

textlint is similar to ESLint, but it's for use with natural language.

Website

Online demo
Searchable documents
Release blog

Visit https://textlint.org/.

Features

No bundled rules.
To use a rule, install a textlint rule via npm.
- npm install textlint-rule-xxx.
- See collection of textlint rules
Markdown and plain text are supported by default. Support is available for HTML and other file formats via plugins.
Supports the use of custom formatters and formatter bundles formatter(reporter)

Quick Tour

For a quick tour of textlint, checkout our Getting Started guide :squirrel:

Installation

You can install the textlint command using npm:

$ npm install textlint --save-dev

Requirements:

Node.js 20+

If you're not sure what version of Node you're running, you can run node -v in your console to find out.

⚠️ Warning:

If you have installed textlint globally you must install each reference rule globally as well.
If you have installed textlint locally you must install each rule locally as well.

We recommend installing textlint locally.

For Node.js beginners

If you've never used Node.js and npm, please see the following:

Installing Node.js and updating npm | npm Documentation

Usage

textlint has no default rules!!

You can run textlint with .textlintrc.json config file.

# Install textlint and rules into local directory
npm install --save-dev textlint textlint-rule-no-todo

npx textlint --init command creates .textlintrc.json file from installed rules.

npx textlint --init

.textlintrc.json will be created like this:

{
    "rules": {
        "no-todo": true
    }
}

Lint files via textlint:

npx textlint ./README.md

textlint load .textlintrc.json from current directory and lint README.md.

CLI

Run npx textlint -h for information on how to use the CLI.

$ textlint [options] file.md [file|dir|glob*]

Options:
  -h, --help                  Show help.
  -c, --config path::String   Use configuration from this file or sharable config.
  --ignore-path path::String  Specify path to a file containing patterns that describes files to ignore. - default: .textlintignore
  --init                      Create the config file if not existed. - default: false
  --fix                       Automatically fix problems
  --dry-run                   Enable dry-run mode for --fix. Only show result, don't change the file.
  --debug                     Outputs debugging information
  --print-config              Print the config object to stdout
  -v, --version               Outputs the version number.

Using stdin:
  --stdin                     Lint text provided on <STDIN>. - default: false
  --stdin-filename String     Specify filename to process STDIN as

Output:
  -o, --output-file path::String  Enable report to be written to a file.
  -f, --format String         Use a specific output format.

                              Available formatter          : checkstyle, compact, jslint-xml, json, junit, pretty-error, stylish, table, tap, unix

                              Available formatter for --fix: compats, diff, fixed-result, json, stylish - default: stylish
  --no-color                  Disable color in piped output.
  --quiet                     Report errors only. - default: false

Specifying rules and plugins:
  --no-textlintrc             Disable .textlintrc
  --plugin [String]           Set plugin package name
  --rule [String]             Set rule package name
  --preset [String]           Set preset package name and load rules from preset package.
  --rulesdir [path::String]   Use additional rules from this directory

Caching:
  --cache                     Only check changed files - default: false
  --cache-location path::String  Path to the cache file or directory - default: .textlintcache

Experimental:
  --experimental              Enable experimental flag.Some feature use on experimental.
  --rules-base-directory path::String  Set module base directory. textlint load modules(rules/presets/plugins) from the base directory.
  --mcp                       Start textlint as the Model Context Protocol (MCP) server.

When running textlint, you can target files to lint using the glob patterns. Make sure that you enclose any glob parameter you pass in quotes.

$ npx textlint "docs/**"

For more details, see CLI documentation.

Documentation: CLI

Example:

ℹ️ See examples/cli

.textlintrc

.textlintrc is config file that is loaded as JSON, YAML or JS via azu/rc-config-loader.

Running textlint with the following arguments

$ npx textlint --rule no-todo --rule very-nice-rule README.md

is equivalent to running textlint README.md in a directory with a .textlintrc.json containing the following json

{
  "rules": {
    "no-todo": true,
    "very-nice-rule": true
  }
}

You can also configure options for specific rules in your .textlintrc.json file.

{
  "rules": {
    "no-todo": false, // disable
    "very-nice-rule": {
        "key": "value"
    }
  }
}

For example here we pass the options ("key": "value") to very-nice-rule.

Options can be specified in your .textlintrc.json file as follows:

{
  // Allow to comment in JSON
  "rules": {
    "<rule-name>": true | false | object
  }
}

ℹ️ for more details see

Plugin

A textlint plugin is a set of rules and rulesConfig or customize parser.

To enable plugin, put the "plugin-name" into .textlintrc.json.

// `.textlintrc.json`
{
    "plugins": [
        "plugin-name"
    ],
    // overwrite-plugins rules config
    // <plugin>/<rule>
    "rules": {
        "plugin-name/rule-name" : false
    }
}

ℹ️ See docs/plugin.md

Supported file formats

textlint supports Markdown and plain text by default.

Install Processor Plugin and add new file format support.

For example, if you want to lint HTML, use textlint-plugin-html as a plugin.

npm install textlint-plugin-html --save-dev

Add "html" to .textlintrc.json

{
    "plugins": [
        "html"
    ]
}

Run textlint on .html files:

textlint index.html

Example: examples/html-plugin
Documentation: docs/plugin.md

Optional supported file types:

HTML: textlint-plugin-html
reStructuredText: textlint-plugin-rst
- Fork: shiguredo/textlint-plugin-rst
AsciiDoc/Asciidoctor: textlint-plugin-asciidoc-loose
Re:VIEW: textlint-plugin-review
Org-mode: textlint-plugin-org

See Processor Plugin List for details.

Rules list 💚

Check it: A Collection of textlint rule · textlint/textlint Wiki

textlint has no built-in rules, but there are 100+ pluggable rules:

See A Collection of textlint rule · textlint/textlint Wiki for more details.

If you create a new rule, please add it to the wiki :)

Fixable

Some rules are fixable using the --fix command line flag.

$ npx textlint --fix README.md
# If possible, textlint will fix the content.

Also, support dry run mode.

$ npx textlint --fix --dry-run --format diff README.md
# show the difference between fixed content and original content.

You can copy and paste to your README.

[![textlint fixable rule](https://img.shields.io/badge/textlint-fixable-green.svg?style=social)](https://textlint.org/)

Built-in formatters

Use the following formatters:

stylish (defaults)
compact
checkstyle
jslint-xml
junit
tap
table
pretty-error
json
unix

e.g. use pretty-error formatter:

$ npx textlint -f pretty-error file.md

More details in @textlint/linter-formatter.

Use as node module

You can use textlint as node module.

$ npm install textlint --save-dev

Minimal usage:

import { createLinter, loadTextlintrc, loadLinterFormatter } from "textlint";
const descriptor = await loadTextlintrc();
const linter = createLinter({ descriptor });
const results = await linter.lintFiles(["*.md"]);
// textlint has two types formatter sets for linter and fixer
const formatter = await loadLinterFormatter({ formatterName: "stylish" });
const output = formatter.format(results);
console.log(output);

For more details, please read the following documents:

See docs/use-as-modules.md

@textlint/kernel is a low level API for textlint. It is useful for the browser or non-Node.js environments.

import { TextlintKernel } from "@textlint/kernel";
const kernel = new TextlintKernel();
const options = {
    filePath: "/path/to/file.md",
    ext: ".md",
    plugins: [
        {
            pluginId: "markdown",
            plugin: require("@textlint/textlint-plugin-markdown")
        }
    ],
    rules: [
        {
            ruleId: "no-todo",
            rule: require("textlint-rule-no-todo").default
        }
    ]
};
kernel.lintText("TODO: text", options).then(result => {
    assert.ok(typeof result.filePath === "string");
    assert.ok(result.messages.length === 1);
});

Conclusion

textlint has four extensible points:

rule
- rule is a rule for linting.
filter rule
- filter rule is a rule for filtering result of errors.
rule-preset
- rule-preset contains rules.
plugin
- plugin contains a processor.

FAQ: How to create rules?

Please see docs/

docs/txtnode.md
- What is TxtNode?
docs/rule.md
- How to create rules?
- Tutorial: creating no-todo rule.
docs/rule-advanced.md
- Advanced tutorial for creating rule.

FAQ: How to suppress error by comments like ``?

You can use filter rule like textlint-filter-rule-comments.

Please see Ignoring Text · textlint for more details.

Integrations

For more details, see integrations document.

AI Assistants (MCP)

textlint can be used as a Model Context Protocol (MCP) server, enabling AI assistants to interact with textlint directly:

npx textlint --mcp

Supported editors:

VS Code with GitHub Copilot
Cursor
Windsurf
etc.

For setup instructions, see MCP Setup Guide.

App

textlint-app
- Standalone cross platform app. No need Node.js environment.

Build Systems

gulp plugin
- gulp-textlint
Grunt plugin
- grunt-textlint

Editors

Atom Editor
- 1000ch/linter-textlint
SublimeText
- joeybaker/sublimelinter-textlint
Vim
- vim-textlint
- scrooloose/syntastic
  - See Markdown, Text and HTML of scrooloose/syntastic Wiki
VS Code
- textlint/vscode-textlint
micro
- hidaruma/micro-textlint-plugin
NetBeans
- netbeans-textlint-plugin

Browser

Chrome Extension
- Chrome: textlint-proofreader
- io-monad/textlint-chrome-extension: textlint Chrome Extension

Other

Who's using textlint?

Packages

This repository is a monorepo that we manage using Lerna. That means that we actually publish several packages to npm from the same codebase, including:

Core

These modules are parts of textlint.

Package	Version	Description
`textlint`		textlint command line tool itself
`@textlint/kernel`		textlint main logic module. It is universal JavaScript.
`@textlint/linter-formatter`		textlint output formatter
`@textlint/fixer-formatter`		textlint output formatter for fixer
`@textlint/textlint-plugin-markdown`		markdown support for textlint
`@textlint/textlint-plugin-text`		plain text support for textlint
`@textlint/ast-tester`		Compliance tests for textlint's AST
`@textlint/markdown-to-ast`		markdown parser
`@textlint/ast-traverse`		TxtNode traverse library
`@textlint/text-to-ast`		plain text parser
`@textlint/config-loader`		Load .textlintrc config file

Rule/Plugin helper

These modules are useful for textlint rule/plugin author.

Package	Version	Description
`@textlint/ast-node-types`		textlint AST(Abstract Syntax Tree) type definition
`textlint-tester`		textlint rule testing tools
`textlint-scripts`		textlint rule npm run-scripts
`create-textlint-rule`		create textlint rule with no build configuration

Integrations

These modules are useful integration with textlint.

Package	Version	Description
`gulp-textlint`		gulp plugin for textlint

Internal

These modules are internal usage in the monorepo.

Package	Version	Description
`@textlint/feature-flag`		feature flag manager

Semantic Versioning Policy

textlint project follow Semantic Versioning. However, textlint is not different from most semver project.

Patch release (intended to not break your lint build)
- A bug fix to the CLI or core (including formatters).
- Improvements to documentation.
- Non-user-facing changes such as refactoring.
- Re-releasing after a failed release (i.e., publishing a release that doesn't work for anyone).
Minor release (might break your lint build)
- A new option.
- An existing rule is deprecated.
- A new CLI capability is created.
- New public API are added (new classes, new methods, new arguments to existing methods, etc.).
  - It might break type interface(.d.ts)
- A new formatter is created.
Major release (break your lint build)
- A new option to an existing rule that results in textlint reporting more errors by default.
- An existing formatter is removed.
- Part of the public API is removed or changed in an incompatible way.

Contributing

For bugs and feature requests, please create an issue.

Pull requests are always welcome.

For more details, see Contributing Guide.

License

MIT © azu

Copy some code from ESLint.

ESLint
Copyright (c) 2013 Nicholas C. Zakas. All rights reserved.
https://github.com/eslint/eslint/blob/master/LICENSE

Logos & Icons

Download from textlint/media.

Related Work

SCG: TextLint

Acknowledgements

Thanks to ESLint.