Skip to content


Folders and files

Last commit message
Last commit date

Latest commit


Repository files navigation

Awesome Linters

A community-driven list of awesome linters.

Code linters are programs that perform static analysis on your code. They check your code for common mistakes and bad coding style/practices thus helping you catch errors before compilation/interpretation and forcing you and your team to keep a consistent code style within a project.

Most of the linters in this list have plugins available for popular text editors and IDEs and are pretty easy to setup and automate (via a pre-commit hook or a CI service for example).

This project is not closed to actual static analyzers. With this repository we intend to have an information resource for all things related to static analysis of code. By this, we mean that articles, talks or any other resource related to this topic will be welcome as well as links related to actual linters.



Language Agnostic

  • coala - Language agnostic linter based on rules and standards. Written in Python.
  • commitlint - commitlint checks if your commit messages meet the conventional commit format.
  • MegaLinter - Linters aggregator of 49 languages, 22 formats, 21 tooling formats , copy-pastes and spell. Can automatically apply fixes with commit or Pull Request
  • Scanmycode CE (Community Edition) - Code Scanning/SAST/Static Analysis/Linting using many tools/Scanners with One Report.
  • tidyall - an all-in-one code tidier and validator with many available backends, caching, filtering-by-paths, and some other features.
  • violations-lib - a library for parsing reports from static code analyzers. Can be used with Jenkins, Gradle, Maven and command line tools.


  • ansible-lint - Checks playbooks for practices and behaviour that could potentially be improved

Awesome Lists

  • awesome-lint - Linter for Awesome lists. Helps to create and maintain Awesome lists. Written in JavaScript.


  • clang-format - Formats C/C++ code according to a coding style (Google, LLVM, Mozilla, Webkit, and Chromium available)
  • clang-tidy - A clang-based C/C++ linter tool to provide an extensible framework for diagnosing and fixing typical programming errors
  • cppcheck - Cppcheck is a static analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting undefined behaviour and dangerous coding constructs. The goal is to detect only real errors in the code (i.e. have very few false positives).
  • cpplint - Source code checker for C/C++ files following Google's internal C++ style guide.
  • oclint - Static analysis for C, C++ and Objective-C. Written in C++.
  • uncrustify - Source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA.


  • @coffelint/cli - Configurable linter written in CoffeScript to analyze CoffeScript.


  • ameba - Static code analysis tool for Crystal.


  • csslint - CSS static analysis written in JavaScript. Uses pluggable rules.
  • csscomb - CSS tool that beautifies CSS based on a configuration. Helps with keeping CSS consistent. Written in JavaScript.
  • ie8linter - Static analysis for Internet Explorer 8 compatibility. Written in JavaScript.
  • postcss-bem-linter - Plugin for PostCSS to lint CSS according to BEM-style. Written in JavaScript.
  • stylelint - CSS linter that is unopinionated, supports plugins and has a wide range of rules built-in. Written in JavaScript, it parses by default CSS-like syntaxes such as SCSS, Sass, Less and SugarSS.



  • linter - Linter for Dart mostly focused on style lints. It's configurable but comes with configured rules out of the box. Written in Dart.


  • dockerfile_lint - Rule based linter for Dockerfiles. The linter rules can be used to check file syntax as well as arbitrary semantic and best practice attributes determined by the rule file writer. The linter can also be used to check LABEL rules against docker images.
  • Dockerfilelint Dockerfilelint is a node module that analyzes a Dockerfile and looks for common traps, mistakes and helps enforce best practices
  • Dockerlint Linting tool for Dockerfiles based on recommendations from Dockerfile Reference and Best practices for writing Dockerfiles as of Docker 1.6.
  • hadolint - Linter for Dockerfiles. The linter is parsing the Dockerfile into an AST and performs rules on top of the AST. It is standing on the shoulders of ShellCheck to lint the Bash code inside RUN instructions.


  • credo - Static code analysis tool for the Elixir language with a focus on code consistency and teaching.


  • elm-review - Analyzes whole Elm projects, with a focus on shareable and custom rules written in Elm that add guarantees the Elm compiler doesn't give you.


  • alex - Linter to help catch insensitive writing in English. Written in JavaScript.
  • proselint - Linter for English that provides guidelines to make better writing. It has plugins for several editors and is configurable.
  • textlint - The pluggable linting tool for natural language texts.


  • dotenv-linter - ⚡️Lightning-fast linter for .env files. Written in Rust 🦀


  • EPUBCheck - a tool to validate the conformance of EPUB publications against the EPUB specifications. Can be run as a standalone command-line tool or used as a Java library.


  • elvis - Configurable Erlang linter written in Erlang.


  • golangci-lint - Linters Runner for Go. 5x faster than gometalinter. Nice colored output. Can report only new issues. Fewer false-positives. Yaml/toml config.
  • golint - Go style linter written in Go. Focus with coding styles more than with correctness.
  • gometalinter - Concurrently run Go lint tools and normalise their output.
  • go vet - Examines Go source code and reports suspicious constructs.



  • npm-groovy-lint - Validate, format and auto-fix Groovy, Jenkinsfile and Gradle files


  • hlint - Tool for suggesting possible improvements to Haskell code. These suggestions include ideas such as using alternative functions, simplifying code and spotting redundancies.


  • haxe-checkstyle - Haxe Checkstyle is a static analysis tool to help developers write Haxe code that adheres to a coding standard.


  • htmlhint - HTMLHint is a Static Code Analysis Tool for HTML, you can use it with IDE or in build system.
  • html-validate - Offline HTML5 validator. Validates either a full document or a smaller (incomplete) template.
  • bootlint - Bootlint is a tool that checks for several common HTML mistakes in webpages that are using Bootstrap.
  • jinjalint - A prototype linter which checks the indentation and the correctness of Jinja-like/HTML templates. Also supports Django Templates.
  • LintHTML - LintHTML is a fork of htmllint. It is extendable via plugins.
  • Nu Html Checker - An offline version of W3C's official validator for HTML, CSS, and SVG. Written in Java.


  • checkstyle - Checkstyle is a development tool to help programmers write Java code that adheres to a coding standard.
  • findbugs - Uses static analysis to look for bugs in Java code.
  • pmd - Static analyzer that finds common programming flaws. It supports Java, JavaScript, Apex, PLSQL, Apache Velocity, XML, XSL.
  • uncrustify - Source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA.


  • clinton - JavaScript project style linter.
  • eslint - Fully pluggable tool for identifying and reporting on patterns in JavaScript.
  • jshint - Community-driven tool that detects errors and potential problems in JavaScript code.
  • prettier - Opinionated JavaScript formatter inspired by refmt with advanced support for language features from ES2017, JSX, and Flow.
  • putout - Linter that fixes everything it can find, supports JS/TS/Flow and wrap ESLint (when eslintrc exists).
  • quick-lint-js - Finds bugs in JavaScript programs. Designed for editors.
  • standard - JavaScript style linter that allows no configuration.
  • xo - Opinionated but configurable ESLint wrapper with lots of goodies included. Enforces strict and readable code.


  • ktlint - An anti-bikeshedding Kotlin linter with built-in formatter


  • luacheck - A tool for linting and static analysis of Lua code.
  • lualint - lualint performs luac-based static analysis of global variable usage in Lua source code.


  • markdownlint - Node.js style checker and lint tool for Markdown/CommonMark files.
  • mdl - Check markdown files and flag style issues. Written in ruby and is distributed as a rubygem.
  • remark-lint - Written in JavaScript. remark-lint provides configurable Markdown style linting.


  • lockfile-lint - Lint an npm or yarn lockfile to analyze and detect security issues.
  • npm-package-json-lint - Configurable linter to enforce standards in npm package.json files.


  • oclint - Static source code analysis tool to improve quality and reduce defects for C, C++ and Objective-C. Written in C++.
  • uncrustify - Source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA.

OpenAPI (Swagger)

  • speccy - A handy toolkit for OpenAPI, with a linter to enforce quality rules.


  • perlcritic - The leading static analyzer for Perl. Configurable, extensible, powerful.
  • Perltidy - a Perl code autoformatter/beautifier.


  • phplint - Node wrapper around the native php linter that allows for parallel linting and integration with build systems like Grunt, Gulp and more.
  • PHP Mess Detector - PHPMD can be seen as a user friendly and easy to configure frontend for the raw metrics measured by PHP Depend.


  • polylint - Catch errors in your polymer project before even running your code. Written in TypeScript.


  • pug-lint — An unopinionated and configurable linter and style checker for Pug (formerly Jade)


  • puppet-lint - Test modules and manifests against the recommended Puppet style guidelines from the Puppet Labs style guide. Written in Ruby.


  • black - The uncompromising Python code formatter. Blackened code looks the same regardless of the project you're reading.
  • flake8 - Runs PyFlakes, pycodestyle and other tools from only one CLI. Written in Python.
  • pycodestyle (formerly called pep8) - Tool to check your Python code against some of the style conventions in PEP 8.
  • pylint - Source code analyzer which looks for programming errors, helps enforcing a coding standard and sniffs for some code smells.
  • ruff - An extremely fast Python linter, written in Rust which is orders of magnitude faster than alternative tools while integrating more functionality behind a single, common interface.
  • wemake-python-styleguide - The strictest and most opinionated python linter ever.
  • yala - YALA combines many linters to improve the quality of your code.


  • regal - Regal is a linter for the policy language Rego. Regal aims to catch bugs and mistakes in policy code, while at the same time helping people learn the language, best practices and idiomatic constructs.


  • doc8 - Doc8 is an opinionated style checker for rst (with basic support for plain text) styles of documentation. Notice, it does not support additional sphinx extensions. Project is also available on OpenStack or GitHub
  • reStructuredText Lint - Validate reST files either as a module or from a CLI utility. Written in Python.


  • rubocop - Ruby static code analyzer. Out of the box it will enforce many of the guidelines outlined in the community Ruby Style Guide.


  • rust-clippy - Collection of lints to catch common mistakes and improve your Rust code.


  • salt-lint - A command-line utility that checks for best practices in SaltStack.


  • sass-lint - Node-only Sass linter for both sass and scss syntax.
  • scss-lint - Tool to help keep your SCSS files clean and readable by running it against a collection of configurable linter rules.
  • stylelint - CSS linter that is unopinionated, supports plugins and has a wide range of rules built-in. Written in JavaScript, it parses by default CSS-like syntaxes such as SCSS, Sass, Less and SugarSS.


  • linter - Scala static analysis compiler plugin which adds compile-time checks for various possible bugs, inefficiencies, and style problems.
  • scalastyle - Examines your Scala code and indicates potential problems with it. Similar to Checkstyle for Java.
  • scapegoat - Another similar tool to Checkstyle for Java. Flags suspicious language usage in code.
  • wartRemover - Flexible and configurable Scala linter written in Scala.


  • shellcheck - Gives warnings and suggestions for bash/sh shell scripts.
  • shfmt - a shell (POSIX shell / bash / mksh) parser, formatter, and interpreter written in Go 1.13-and-above.


  • sqlfluff - SQLFluff is a dialect-flexible and configurable SQL linter.


  • swiftlint - Tool to enforce Swift style and conventions, loosely based on GitHub's Swift Style Guide.


  • tslint - Customizable TypeScript linter with automatic fixing of formating and style violations.


  • spectral - A flexible JSON/YAML linter, with out of the box support for OpenAPI v2/v3 and AsyncAPI v2.
  • yamllint - Linter for YAML files.


Contributions are very welcome! Create a new pull request, solve a bug or grab an issue that is currently unassigned!

The only rule is: keep it organized.


Thanks to everyone that helped!