Merge commit '326cdc53aa67dc3e8d68eb24fcc08b3e4a7b9bde'

Update to ktlint 0.23.1

Test: None
tree: 8aa62a48ff99be9923c5f57521ba855b763eb8aa
  1. .mvn/
  2. gradle/
  3. ktlint/
  4. ktlint-core/
  5. ktlint-reporter-checkstyle/
  6. ktlint-reporter-json/
  7. ktlint-reporter-plain/
  8. ktlint-ruleset-standard/
  9. ktlint-ruleset-template/
  10. ktlint-test/
  11. .announce
  12. .appveyor.yml
  13. .deploy-to-homebrew
  14. .editorconfig
  15. .gitattributes
  16. .gitignore
  17. .jabbarc
  18. .travis.yml
  19. build.gradle
  22. gradlew
  23. gradlew.bat
  25. mvnw
  26. mvnw.bat
  27. pom.xml
  29. settings.gradle


  • No configuration. Which means no decisions to make, nothing to argue about and no special files to manage.
    While this might sound extreme, keep in mind that ktlint tries to capture (reflect) official code style from and Android Kotlin Style Guide
    (+ we respect you .editorconfig and support additional ruleset|s).
  • Built-in formatter. So that you wouldn't have to fix all style violations by hand.
  • Customizable output. plain (+ plain?group_by_file), json and checkstyle reporters are available out-of-the-box. It's also easy to create your own.
  • A single executable jar with all dependencies included.

Standard rules

  • 4 spaces for indentation
    (unless a different indent_size value is set in .editorconfig (see EditorConfig section for more));
  • No semicolons (unless used to separate multiple statements on the same line);
  • No wildcard / unused imports;
  • No consecutive blank lines;
  • No blank lines before };
  • No trailing whitespaces;
  • No Unit returns (fun fn {} instead of fun fn: Unit {});
  • No empty ({}) class bodies;
  • No spaces around range (..) operator;
  • No newline before (binary) + & -, *, /, %, &&, ||;
  • When wrapping chained calls ., ?. and ?: should be placed on the next line;
  • When a line is broken at an assignment (=) operator the break comes after the symbol;
  • When class/function signature doesn't fit on a single line, each parameter must be on a separate line;
  • Consistent string templates ($v instead of ${v}, ${p.v} instead of ${p.v.toString()});
  • Consistent order of modifiers;
  • Consistent spacing after keywords, commas; around colons, curly braces, infix operators, comments, etc;
  • Newline at the end of each file (not enabled by default, but recommended)
    (set insert_final_newline=true in .editorconfig to enable (see EditorConfig section for more)).


ktlint recognizes the following .editorconfig properties (provided they are specified under [*.{kt,kts}]):
(values shown below are the defaults and do not need to be specified explicitly)

# possible values: number (e.g. 2), "unset" (makes ktlint ignore indentation completely)  
# possible values: number (e.g. 2), "unset"
# true (recommended) / false
# possible values: number (e.g. 120) (package name, imports & comments are ignored), "off"
# it's automatically set to 100 on `ktlint --android ...` (per Android Kotlin Style Guide)


Skip all the way to the “Integration” section if you don't plan to use ktlint's command line interface.

curl -sSLO &&
  chmod a+x ktlint &&
  sudo mv ktlint /usr/local/bin/

... or just download ktlint from the releases page (ktlint.asc contains PGP signature which you can verify with curl -sS | gpg --import && gpg --verify ktlint.asc).

On macOS (or Linux) you can also use brew - brew install shyiko/ktlint/ktlint.

If you don't have curl installed - replace curl -sL with wget -qO-.

If you are behind a proxy see - curl / wget manpage. Usually simple http_proxy=http://proxy-server:port https_proxy=http://proxy-server:port curl -sL ... is enough.


# check the style of all Kotlin files inside the current dir (recursively)
# (hidden folders will be skipped)
$ ktlint --color
  src/main/kotlin/Main.kt:10:10: Unused import
# check only certain locations (prepend ! to negate the pattern) 
$ ktlint "src/**/*.kt" "!src/**/*Test.kt"

# auto-correct style violations
# (if some errors cannot be fixed automatically they will be printed to stderr) 
$ ktlint -F "src/**/*.kt"

# print style violations grouped by file
$ ktlint --reporter=plain?group_by_file
# print style violations as usual + create report in checkstyle format 
$ ktlint --reporter=plain --reporter=checkstyle,output=ktlint-report-in-checkstyle-format.xml

# install git hook to automatically check files for style violations on commit
$ ktlint --install-git-pre-commit-hook

on Windows you'll have to use java -jar ktlint ....

ktlint --help for more.


... with Maven


            <target name="ktlint">
                <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
                    classpathref="maven.plugin.classpath" classname="com.github.shyiko.ktlint.Main">
                    <arg value="src/**/*.kt"/>
                    <!-- to generate report in checkstyle format prepend following args: -->
                    <arg value="--reporter=plain"/>
                    <arg value="--reporter=checkstyle,output=${}/ktlint.xml"/>
                    <!-- see for more -->                    
            <target name="ktlint">
                <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
                    classpathref="maven.plugin.classpath" classname="com.github.shyiko.ktlint.Main">
                    <arg value="-F"/>
                    <arg value="src/**/*.kt"/>
        <!-- additional 3rd party ruleset(s) can be specified here -->

To check code style - mvn antrun:run@ktlint (it's also bound to mvn verify).
To run formatter - mvn antrun:run@ktlint-format.

... with Gradle

(without a plugin)


// kotlin-gradle-plugin must be applied for configuration below to work
// (see

repositories {

configurations {

dependencies {
    ktlint "com.github.shyiko:ktlint:0.23.0"
    // additional 3rd party ruleset(s) can be specified here
    // just add them to the classpath (e.g. ktlint 'groupId:artifactId:version') and 
    // ktlint will pick them up

task ktlint(type: JavaExec, group: "verification") {
    description = "Check Kotlin code style."
    classpath = configurations.ktlint
    main = "com.github.shyiko.ktlint.Main"
    args "src/**/*.kt"
    // to generate report in checkstyle format prepend following args:
    // "--reporter=plain", "--reporter=checkstyle,output=${buildDir}/ktlint.xml"
    // see for more
check.dependsOn ktlint

task ktlintFormat(type: JavaExec, group: "formatting") {
    description = "Fix Kotlin code style deviations."
    classpath = configurations.ktlint
    main = "com.github.shyiko.ktlint.Main"
    args "-F", "src/**/*.kt"

To check code style - gradle ktlint (it's also bound to gradle check).
To run formatter - gradle ktlintFormat.

See Making your Gradle tasks incremental by Niklas Baudy on how to make tasks above incremental.

(with a plugin)

Gradle plugins (in order of appearance):

You might also want to take a look at diffplug/spotless which has a built-in support for ktlint. In addition to linting/formatting kotlin code it allows you to keep license headers, markdown documentation, etc. in check.

... with IntelliJ IDEA

While this is not strictly necessary it makes Intellij IDEA's built-in formatter produce 100% ktlint-compatible code.

Option #1 (recommended)

(inside project's root directory)

ktlint --apply-to-idea-project
# or if you want to be compliant with Android Kotlin Style Guide
ktlint --apply-to-idea-project --android 
Option #2

Go to File -> Settings... -> Editor

  • General -> Auto Import
    • check Optimize imports on the fly (for current project).
  • Code Style -> Kotlin
    • Set from... -> Predefined style -> Kotlin style guide (Kotlin plugin 1.2.20+).
    • open Imports tab
      • select Use single name import (all of them);
      • remove import java.util.* from Packages to Use Import with '*'.
    • open Blank Lines tab
      • change Keep Maximum Blank Lines / In declarations & In code to 1 and Before '}' to 0.
    • (optional but recommended) open Wrapping and Braces tab
      • uncheck Method declaration parameters / Align when multiline.
    • (optional but recommended) open Tabs and Indents tab
      • change Continuation indent to the same value as Indent (4 by default).
  • Inspections
    • change Severity level of Unused import directive and Redundant semicolon to ERROR.

... with GNU Emacs

See whirm/flycheck-kotlin.

Integrated with something else? Send a PR.

Creating a ruleset

In a nutshell: “ruleset” is a JAR containing one or more Rules gathered together in a RuleSet. ktlint is relying on ServiceLoader to discover all available “RuleSet”s on the classpath (as a ruleset author, all you need to do is to include a META-INF/services/com.github.shyiko.ktlint.core.RuleSetProvider file containing a fully qualified name of your RuleSetProvider implementation).

Once packaged in a JAR you can load it with

# enable additional 3rd party ruleset by pointing ktlint to its location on the file system
$ ktlint -R /path/to/custom/rulseset.jar "src/test/**/*.kt"

# you can also use <groupId>:<artifactId>:<version> triple in which case artifact is
# downloaded from Maven Central, JCenter or JitPack (depending on where it's located and 
# whether or not it's already present in local Maven cache)
$ ktlint -R com.github.username:rulseset:master-SNAPSHOT

A complete sample project (with tests and build files) is included in this repo under the ktlint-ruleset-template directory (make sure to check NoVarRuleTest as it contains some useful information).


While writing/debugging Rules it's often helpful to have an AST printed out to see the structure rules have to work with. ktlint >= 0.15.0 has --print-ast flag specifically for this purpose (usage: ktlint --color --print-ast <file>).
An example of the output is shown below.

$ printf "fun main() {}" | ktlint --color --print-ast --stdin

1: ~.psi.KtFile (~.psi.stubs.elements.KtFileElementType.kotlin.FILE)
1:   ~.psi.KtPackageDirective (~.psi.stubs.elements.KtPlaceHolderStubElementType.PACKAGE_DIRECTIVE) ""
1:   ~.psi.KtImportList (~.psi.stubs.elements.KtPlaceHolderStubElementType.IMPORT_LIST) ""
1:   ~.psi.KtScript (~.psi.stubs.elements.KtScriptElementType.SCRIPT)
1:     ~.psi.KtBlockExpression (~.KtNodeType.BLOCK)
1:       ~.psi.KtNamedFunction (~.psi.stubs.elements.KtFunctionElementType.FUN)
1:         ~.c.i.p.impl.source.tree.LeafPsiElement ( "fun"
1:         ~.c.i.p.impl.source.tree.PsiWhiteSpaceImpl (~.c.i.p.tree.IElementType.WHITE_SPACE) " "
1:         ~.c.i.p.impl.source.tree.LeafPsiElement (~.lexer.KtToken.IDENTIFIER) "main"
1:         ~.psi.KtParameterList 
1:           ~.c.i.p.impl.source.tree.LeafPsiElement (~.lexer.KtSingleValueToken.LPAR) "("
1:           ~.c.i.p.impl.source.tree.LeafPsiElement (~.lexer.KtSingleValueToken.RPAR) ")"
1:         ~.c.i.p.impl.source.tree.PsiWhiteSpaceImpl (~.c.i.p.tree.IElementType.WHITE_SPACE) " "
1:         ~.psi.KtBlockExpression (~.KtNodeType.BLOCK)
1:           ~.c.i.p.impl.source.tree.LeafPsiElement (~.lexer.KtSingleValueToken.LBRACE) "{"
1:           ~.c.i.p.impl.source.tree.LeafPsiElement (~.lexer.KtSingleValueToken.RBRACE) "}"

   format: <line_number:> <node.psi::class> (<node.elementType>) "<node.text>"
   legend: ~ = org.jetbrains.kotlin, c.i.p = com.intellij.psi

Creating a reporter

Take a look at ktlint-reporter-plain.

In short, all you need to do is to implement a Reporter and make it available by registering a custom ReporterProvider using META-INF/services/com.github.shyiko.ktlint.core.ReporterProvider. Pack all of that into a JAR and you're done.

To load a custom (3rd party) reporter use ktlint --reporter=name,artifact=groupId:artifactId:version / ktlint --reporter=name,artifact=/path/to/custom-ktlint-reporter.jar (see ktlint --help for more).





Why should I use ktlint?


Spending time on configuration (& maintenance down the road) of hundred-line long style config file(s) is counter-productive. Instead of wasting your energy on something that has no business value - focus on what really matters (not debating whether to use tabs or spaces).

By using ktlint you put the importance of code clarity and community conventions over personal preferences. This makes things easier for people reading your code as well as frees you from having to document & explain what style potential contributor(s) have to follow.

ktlint is a single binary with both linter & formatter included. All you need is to drop it in (no need to get overwhelmed while choosing among dozens of code style options).

Can I have my own rules on top of ktlint?

Absolutely, “no configuration” doesn't mean “no extensibility”. You can add your own ruleset(s) to discover potential bugs, check for anti-patterns, etc.

See Creating A Ruleset.

How do I suppress an error?

This is meant primarily as an escape latch for the rare cases when ktlint is not able to produce the correct result (please report any such instances using GitHub Issues).

To disable a specific rule you‘ll need to turn on the verbose mode (ktlint --verbose ...). At the end of each line you’ll see an error code. Use it as an argument for ktlint-disable directive (shown below).

import package.* // ktlint-disable no-wildcard-imports

/* ktlint-disable no-wildcard-imports */
import package.a.*
import package.b.*
/* ktlint-enable no-wildcard-imports */

To disable all checks:

import package.* // ktlint-disable


Make sure to read

git clone && cd ktlint
./mvnw # shows how to build, test, etc. project

Access to the latest master snapshot

Whenever a commit is added to the master branch 0.0.0-SNAPSHOT is automatically uploaded to Sonatype's snapshots repository. If you are eager to try upcoming changes (that might or might not be included in the next stable release) you can do so by changing version of ktlint to 0.0.0-SNAPSHOT + adding a repo:

repositories {
  maven {
    url ""


This project is not affiliated with or endorsed by the Jetbrains.
All code, unless specified otherwise, is licensed under the MIT license.
Copyright (c) 2016 Stanley Shyiko.