node package manager
Share your code. npm Orgs help your team discover, share, and reuse code. Create a free org »



textlint logo

The pluggable linting tool for text and markdown.
It is similar to ESLint, but textlint for natural language.

Travis CI Build Status AppVeyor Build status

Online Demo

Visit and type text!


Quick Tour

Quick tour of textlint!

Read Getting Started :squirrel:


You can install textlint command using npm:

$ npm install textlint -g


  • Node.js 4.0.0 >=
  • npm 2.0.0 >=

Test: Run node -v in your console. The version should be higher than v4.0.0.

⚠️ Caution: Mixed location of installation.

  • If you have installed textlint as --global(-g), must install each rule as --global.
  • If you have installed textlint as --save-dev(-D), must install each rule as --save-dev.

Recommended way: Install textlint and rules as --save-dev per project.

For Node.js beginner

If you never use Node.js and npm(package manager for Node.js), please see following:


screenshot lint pretty-error

textlint has no default rule!!

Use textlint with --rule or --rulesdir, .textlintrc config file.

# Install textlint's rule 
npm install --global textlint-rule-no-todo

Use with textlint-rule-no-todo rule. (Allow to short textlint-rule-no-todo to no-todo)

textlint --rule no-todo

📝 We recommended to use .textlintrc insteadof --rule or --rulesdir. .textlintrc is suitable format for maintain rules.


See command help

$ textlint -h
textlint [options] [file|dir|glob*]
  -h, --help                 Show help.
  -c, --config path::String  Use configuration from this file or sharable config.
  --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
  -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
  -o, --output-file path::String  Enable report to be written to a file.
  -f, --format String        Use a specific output format.
  --no-color                 Disable color in piped output.
  --quiet                    Report errors only. - default: false
Specifying rules and plugins:
  --plugin [String]          Set plugin package name
  --rule [path::String]      Set rule package name
  --preset [path::String]    Set preset package name and load rules from preset package.
  --rulesdir [path::String]  Set rules from this directory and set all default rules to off.
  --cache                    Only check changed files - default: false
  --cache-location path::String  Path to the cache file or directory
  --experimental             Enable experimental flag.Some feature use on experimental.

Allow to use glob as a target.

Please note that have to quote your parameter as follows:

$ textlint "docs/**"



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

$ textlint --rule no-todo --rule very-nice-rule

is equal to create .textlintrc file

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

and run textlint command

$ textlint
# Automatically load `.textlintrc` in current directory 

.textlintrc can define rule's option.

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

Pass rule's options("key": "value") to very-nice-rule.

It mean that use the following format:

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

ℹ️ for more details


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

To enable plugin, put the "plugin-name" into .textlinrc.

// `.textlinrc` 
    "plugins": [
    // overwrite-plugins rules config 
    // <plugin>/<rule> 
    "rules": {
        "plugin-name/rule-name" : false

ℹ️ See docs/

Supported file formats

textlint support 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 plugin.

npm install textlint-plugin-html

Add "html" to .textlintrc

    "plugins": [

Run textlint on .html files:

textlint index.html

Optional supported file types:

See Processor Plugin List for details.

Rule list 💚

textlint has not built-in rules, but there are 100>= pluggable rules.

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

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


textlint rule

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

$ textlint --fix
# As a possible, textlint fix the content. 


Also, support dry run mode.

$ textlint --fix --dry-run --formatter diff
# show the difference between fixed content and original content.

You can copy and page to your README.

[![textlint fixable rule](]( 

Built-in formatters

Use following formatter.

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

e.g.) use pretty-error formatter

$ textlint -f pretty-error

More detail in textlint/textlint-formatter.

Use as node modules

You can use textlint as node modules.

$ npm install textlint --save-dev

Minimal usage:

import {TextLintEngine} from "textlint";
const engine = new TextLintEngine({
    rulePaths: ["path/to/rule-dir"]
engine.executeOnFiles([""]).then(results => {
    console.log(results[0].filePath);// => "" 
    // messages are `TextLintMessage` array. 
            id: "rule-name",
            message:"lint message",
            line: 1, // 1-based columns(TextLintMessage)
            column:1 // 1-based columns(TextLintMessage)
    if (engine.isErrorResults(results)) {
        const output = engine.formatResults(results);

Low level usage:

import {textlint} from "textlint";
    // rule-key : rule function(see docs/ 
    "rule-key": function(context){
        const exports = {};
        exports[context.Syntax.Str] = function (node) {
  , new context.RuleError("error message"));
        return exports;
textlint.lintMarkdown("# title").then(results => {
    console.log(results[0].filePath);// => "" 
    console.log(results[0].messages);// => [{message:"lint message"}] 

More detail on:


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 rules and a processor.


FAQ: How to create rules?

Please see docs/

FAQ: How to suppress error by comments like <!-- textlint-disable -->?

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

Please see docs/ for more details.


Build Systems




Who's using textlint?

The for japanese.


  1. Fork it!
  2. Create your feature branch: git checkout -b my-new-feature
  3. Commit your changes: git commit -am 'Add some feature'
  4. Push to the branch: git push origin my-new-feature
  5. Submit a pull request :D


MIT and

lib/load-rules.js, util/traverse.js, cli.js and timing.js are:

Copyright (c) 2013 Nicholas C. Zakas. All rights reserved.

Logos & Icons

Download from textlint/media.

Related Work

SCG: TextLint is similar project.

SCG: TextLint's place is equal to my textlint(Fortuitously, project's name is the same too!).


via Natural Language Checking with Program Checking Tools


Thanks to ESLint.