Skip to content


Repository files navigation


Buy Me A Coffee

ci codecov Hits-of-Code Go Report Card


  1. What?
  2. Quickstart
  3. Installation
  4. Usage
  5. Configuration
  6. Excluding
    1. Excluding Lines
    2. Excluding Blocks
    3. Excluding Files
      1. Inline
      2. Default Excludes
      3. Manually Excluding
        1. via configuration
        2. via arguments
        3. Generally
  7. Docker
  8. Continuous Integration
  9. Support


Example Screenshot

This is a tool to check if your files consider your .editorconfig rules. Most tools—like linters, for example—only test one filetype and need an extra configuration. This tool only needs your .editorconfig to check all files.

If you don't know about editorconfig already you can read about it here:

Currently implemented editorconfig features are:

  • end_of_line
  • insert_final_newline
  • trim_trailing_whitespace
  • indent_style
  • indent_size
  • max_line_length

Unsupported features are:

  • charset


curl -O -L -C -$VERSION/ec-$OS-$ARCH.tar.gz && \
tar xzf ec-$OS-$ARCH.tar.gz && \


Grab a binary from the release page.

If you have go installed you can run go get and run make build inside the project folder. This will place a binary called ec into the bin directory.

If you are using Arch Linux, you can use pacman to install from extra repository:

pacman -S editorconfig-checker

Also, development (VCS) package is available in the AUR:

# <favourite-aur-helper> <install-command> editorconfig-checker-git

# i.e.
paru -S editorconfig-checker-git

If go 1.16 or greater is installed, you can also install it globally via go install:

go install


  -config string
        print debugging information
        disables the trailing whitespace check
        disables only the indent-size check
        disables the indentation check
        disables the final newline check
        disables the trailing whitespace check
        show which files would be checked
  -exclude string
        a regex which files should be excluded from checking - needs to be a valid regular expression
        specifies the output format, see "Formats" below for more information
  -h    print the help
        print the help
        ignore default excludes
        creates an initial configuration
        dont print colors
  -v    print debugging information
        print debugging information
        print the version number

If you run this tool from a repository root it will check all files which are added to the git repository and are text files. If the tool isn't able to determine a file type it will be added to be checked too.

If you run this tool from a normal directory it will check all files which are text files. If the tool isn't able to determine a file type it will be added to be checked too.


The following output formats are supported:

  • default: Plain text, human readable output.
  • gcc: GCC compatible output. Useful for editors that support compiling and showing syntax errors. ::: :


The configuration is done via arguments or an .ecrc file.

A sample .ecrc file can look like this and will be used from your current working directory if not specified via the --config argument:

  "Verbose": false,
  "Debug": false,
  "IgnoreDefaults": false,
  "SpacesAftertabs": false,
  "NoColor": false,
  "Exclude": [],
  "AllowedContentTypes": [],
  "PassedFiles": [],
  "Disable": {
    "EndOfLine": false,
    "Indentation": false,
    "IndentSize": false,
    "InsertFinalNewline": false,
    "TrimTrailingWhitespace": false,
    "MaxLineLength": false

You can set any of the options under the "Disable" section to true to disable those particular checks.

You could also specify command line arguments and they will get merged with the configuration file, the command line arguments have a higher precedence than the configuration.

You can create a configuration with the init-flag. If you specify an config-path it will be created there.

By default the allowed_content_types are:

  1. text/ (matches text/plain, text/html, etc.)
  2. application/ecmascript
  3. application/json
  4. application/x-ndjson
  5. application/xml
  6. +json (matches application/geo+json, etc.)
  7. +xml (matches application/rss+xml, etc.)
  8. application/octet-stream

application/octet-stream is needed as a fallback when no content type could be determined. You can add additional accepted content types with the allowed_content_types key. But the default ones don't get removed.


Excluding Lines

You can exclude single lines inline. To do that you need a comment on that line that says: editorconfig-checker-disable-line.

const myTemplateString = `
  first line
     wrongly indended line because it needs to be` // editorconfig-checker-disable-line

Excluding Blocks

To temporarily disable all checks, add a comment containing editorconfig-checker-disable. Re-enable with a comment containing editorconfig-checker-enable

// editorconfig-checker-disable
const myTemplateString = `
  first line
     wrongly indended line because it needs to be
// editorconfig-checker-enable

Excluding Files


If you want to exclude a file inline you need a comment on the first line of the file that contains: editorconfig-checker-disable-file

-- editorconfig-checker-disable-file
add :: Int -> Int -> Int
add x y =
  let result = x + y -- falsy indentation would not report
  in result -- falsy indentation would not report

Default Excludes

If you don't pass the ignore-defaults flag to the binary these files are excluded automatically:


Manually Excluding

via configuration

In your .ecrc file you can exclude files with the "exclude" key which takes an array of regular expressions. This will get merged with the default excludes (if not ignored). You should remember to escape your regular expressions correctly. ;)

An .ecrc which would ignore all test files and all markdown files can look like this:

  "Verbose": false,
  "IgnoreDefaults": false,
  "Exclude": ["testfiles", "\\.md$"],
  "SpacesAfterTabs": false,
  "Disable": {
    "EndOfLine": false,
    "Indentation": false,
    "IndentSize": false,
    "InsertFinalNewline": false,
    "TrimTrailingWhitespace": false,
    "MaxLineLength": false
via arguments

If you want to play around how the tool would behave you can also pass the --exclude argument to the binary. This will accept a regular expression as well. If you use this argument the default excludes as well as the excludes from the .ecrc file will merged together.

For example: ec --exclude node_modules


Every exclude option is merged together.

If you want to see which files the tool would check without checking them you can pass the --dry-run flag.

Note that while --dry-run outputs absolute paths, a regular expression matches on relative paths from where the ec command is used.


You are able to run this tool inside a Docker container. To do this you need to have Docker installed and run this command in your repository root which you want to check: docker run --rm --volume=$PWD:/check mstruebing/editorconfig-checker

Dockerhub: mstruebing/editorconfig-checker

Continuous Integration


Instead of installing and configuring editorconfig-checker and all other linters in your project CI workflows (GitHub Actions & others), you can use Mega-Linter which does all that for you with a single assisted installation.

Mega-Linter embeds editorconfig-checker by default in all its flavors, meaning that it will be run at each commit or Pull Request to detect any issue related to .editorconfig.

If you want to use only editorconfig-checker and not the 70+ other linters, you can use the following .mega-linter.yml configuration file:


GitLab CI

The ss-open/ci/recipes project offers a ready to use lint job integrating editorconfig-checker.


If you have any questions, suggestions, need a wrapper for a programming language or just want to chat join #editorconfig-checker on freenode(IRC). If you don't have an IRC-client set up you can use the freenode webchat.