A tool for formatting Clojure code
Branch: master
Clone or download
Pull request Compare This branch is 42 commits ahead, 65 commits behind weavejester:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.



CircleCI codecov

cljfmt is a tool for formatting Clojure code.

It can turn something like this:

( let [x 3
    y 4]
  (+ (* x x
  )(* y y)

Into nicely formatted Clojure code like this:

(let [x 3
      y 4]
  (+ (* x x) (* y y)))


Library releases are published on Clojars. To use the latest version with Leiningen, add the following plugin to your project definition:

Clojars Project


To check the formatting of your source files, use:

lein cljfmt check

If the formatting of any source file is incorrect, a diff will be supplied showing the problem, and what cljfmt thinks it should be.

If you want to check only a specific file, or several specific files, you can do that, too:

lein cljfmt check src/foo/core.clj

Once you've identified formatting issues, you can choose to ignore them, fix them manually, or let cljfmt fix them with:

lein cljfmt fix

As with the check task, you can choose to fix a specific file:

lein cljfmt fix src/foo/core.clj

Editor Support


You can configure lein-cljfmt by adding a :cljfmt map to your project:

:cljfmt {}

cljfmt has several different formatting rules, and these can be selectively enabled or disabled:

  • :indentation? - true if cljfmt should correct the indentation of your code. Defaults to true.

  • :remove-surrounding-whitespace? - true if cljfmt should remove whitespace surrounding inner forms. This will convert ( foo ) to (foo). Defaults to true.

  • :remove-trailing-whitespace? - true if cljfmt should remove trailing whitespace in lines. This will convert (foo) \n to (foo)\n. Defaults to true.

  • :insert-missing-whitespace? - true if cljfmt should insert whitespace missing from between elements. This will convert (foo(bar)) to (foo (bar)). Defaults to true.

  • :remove-consecutive-blank-lines? - true if cljfmt should collapse consecutive blank lines. Any runs of empty lines longer than :max-consecutive-blank-lines will be truncated to the configured limit. Defaults to enabled with limit 2. This will convert (foo)\n\n\n\n(bar) to (foo)\n\n\n(bar).

  • :insert-padding-lines? - Whether cljfmt should insert blank lines between certain top-level forms. Any multi-line form will be padded with at least :padding-lines empty lines between it and other non-comment forms. Defaults to enabled with 2 lines.

  • :rewrite-namespaces? - Whether cljfmt should rewrite namespace forms to standardize their layout. Defaults to true.

  • :single-import-break-width - Control the threshold for breaking a single class import into a package import group. If the combined package and class name would be longer than this limit, it is represented as a group, otherwise it is inlined into a qualified class symbol.

You can also configure the behavior of cljfmt:

  • :file-pattern - determines which files to scan, #”\.clj[sx]?$” by default.

  • :indents - a map of var symbols to indentation rules, i.e. {symbol [& rules]}. See the next section for a detailed explanation.

As with Leiningen profiles, you can add metadata hints. If you want to override all existing indents, instead of just supplying new indents that are merged with the defaults, you can use the :replace hint:

:cljfmt {:indents ^:replace {#".*" [[:inner 0]]}}

Indentation rules

There are a few types of indentation rules that can be applied to forms. Each rule is specified with either a symbol or a regular expression pattern. Rules are matched against forms in the following order:

  1. Check the qualified form symbol against the rule, including namespace.
  2. Check the name of the form symbol against the rule symbol.
  3. If the rule is a pattern, match it against the form symbol string.

This ordering allows you to provide specific rules for overlapping symbols from different namespaces, e.g. differentiating d/catch from catch.

Inner rules

An :inner rule will apply a constant indentation to all elements at a fixed depth. So an indent rule:

{foo [[:inner 0]]}

Will indent all elements inside a foo form by two spaces:

(foo bar

While an indent rule like:

{foo [[:inner 1]]}

Will indent all subforms one level in:

(foo bar

Sometimes it's useful to limit indentation to one argument of the surrounding form. For example, letfn uses inner indentation only in its binding vector:

(letfn [(double [x]
          (* x 2))]   ;; special indentation here
  (let [y (double 2)
        z (double 3)]
    (println y
             z)))     ;; but not here

To achieve this, an additional index argument may be used:

{letfn [[:inner 2 0]]}

This will limit the inner indent to depth 2 in argument 0.

Block rules

A :block rule is a little smarter. This will act like an inner indent only if there's a line break before a certain number of arguments, otherwise it acts like a normal list form.

For example, an indent rule:

{foo [[:block 0]]}

Indents like this, if there are more than 0 arguments on the same line as the symbol:

(foo bar

But indents at a constant two spaces otherwise:


Cond rules

A :cond rule is similar to :block, except that it tries to indent test/expression clauses as pairs. The expression forms will be given an extra level of indentation if they are on their own line:

{cond [[:cond 0]]}
  a? :a
  b? :b)


Ignoring Forms

By default, cljfmt will ignore forms which are wrapped in a (comment ...) form or preceeded by the discard macro #_. You can also optionally disable formatting rules from matching a form by tagging it with ^:cljfmt/ignore metadata.


Copyright © 2016 James Reeves

Distributed under the Eclipse Public License either version 1.0 or (at your option) any later version.