A formatter for Haskell source code

Version on this page:
LTS Haskell 22.17:
Stackage Nightly 2023-12-26:
Latest on Hackage:

See all snapshots fourmolu appears in


License BSD3 Hackage

Fourmolu is a formatter for Haskell source code. It is a fork of Ormolu, with the intention to continue to merge upstream improvements.

We share all bar one of Ormolu’s goals:

  • Using GHC’s own parser to avoid parsing problems caused by haskell-src-exts.
  • Let some whitespace be programmable. The layout of the input influences the layout choices in the output. This means that the choices between single-line/multi-line layouts in each particular situation are made by the user, not by an algorithm. This makes the implementation simpler and leaves some control to the user while still guaranteeing that the formatted code is stylistically consistent.
  • Writing code in such a way so it’s easy to modify and maintain.
  • That formatting style aims to result in minimal diffs while still remaining very close to “conventional” Haskell formatting people use.
  • Choose a style compatible with modern dialects of Haskell. As new Haskell extensions enter broad use, we may change the style to accommodate them.
  • Idempotence: formatting already formatted code doesn’t change it.
  • Be well-tested and robust to the point that it can be used in large projects without exposing unfortunate, disappointing bugs here and there.
  • ~~Implementing one “true” formatting style which admits no configuration.~~ We allow configuration of various parameters, via CLI options or config files. We encourage any contributions which add further flexibility.


Fourmolu looks for a fourmolu.yaml file in all parents of the current directory, followed by the XDG config directory. A complete configuration file, corresponding to Fourmolu’s default options, looks like:

indentation: 4
comma-style: leading # for lists, tuples etc. - can also be 'trailing'
record-brace-space: false # rec {x = 1} vs. rec{x = 1}
indent-wheres: false # 'false' means save space by only half-indenting the 'where' keyword
diff-friendly-import-export: true # 'false' uses Ormolu-style lists
respectful: true # don't be too opinionated about newlines etc.
haddock-style: multi-line # '--' vs. '{-'
newlines-between-decls: 1 # number of newlines between top-level declarations

See here for a config to simulate the behaviour of Ormolu.

These options can also be set on the command line (which takes precedence over config files). Run fourmolu -h to see all options.


Simply run cabal v2-install fourmolu, to install the latest release from Hackage.

You can also clone this repository, then build with Cabal or Stack.


The following will print the formatted output to the standard output.

$ fourmolu Module.hs

Add -i (or --mode inplace) to replace the contents of the input file with the formatted output.

$ fourmolu -i Module.hs

Use find to format a tree recursively:

$ fourmolu -i $(find . -name '*.hs')

Fourmolu can be integrated with your editor via the Haskell Language Server.

Magic comments

Fourmolu understands two magic comments:




This allows us to disable formatting selectively for code between these markers or disable it for the entire file. To achieve the latter, just put {- FOURMOLU_DISABLE -} at the very top. Note that for Fourmolu to work the source code must still be parseable even when the disabled regions are omitted. Because of that the magic comments cannot be placed arbitrarily, but rather must enclose independent top-level definitions.

{- ORMOLU_DISABLE -} and {- ORMOLU_ENABLE -}, respectively, can be used to the same effect.

Current limitations

  • CPP support is experimental. CPP is virtually impossible to handle correctly, so we process them as a sort of unchangeable snippets. This works only in simple cases when CPP conditionals surround top-level declarations. See the CPP section in the design notes for a discussion of the dangers.
  • Input modules should be parsable by Haddock, which is a bit stricter criterion than just being valid Haskell modules.
  • Various minor idempotence issues, most of them are related to comments.
  • Fourmolu is in a fairly early stage of development. The implementation should be as stable as Ormolu, as it only makes minimal changes, and is extensively tested. But the default configuration style may change in some minor ways in the near future, as we make more options available. It will always be possible to replicate the old default behaviour with a suitable fourmolu.yaml.


If there are any options you’d like to see, let us know. If it’s not too complicated to implement (and especially if you implement it yourself!) then we’ll probably add it.

Run cabal test and ./ before submitting any pull requests.



Copyright © 2018–2020 Tweag I/O, 2020-present Matt Parsons


The vast majority of work here has been done by the Ormolu developers, and thus they deserve almost all of the credit. This project is simply intended as a haven for those of us who admire their work, but can’t quite get on board with some of their decisions when it comes down to the details.



  • New config option newlines-between-decls, to choose the number of blank lines between top-level declarations.
  • Minor CLI improvements. In particular, the set of valid values for each option is communicated more consistently.


  • More consistent indentation. Previously, with indentation set to n, some constructs such as nested lists and tuples would use an ugly mix of n-space and 2-space indentation.

  • New configuration options (see README or Hackage docs for details):

    • comma-style
    • record-brace-space
    • indent-wheres
    • diff-friendly-import-export
    • respectful
    • haddock-style

Upstream changes:


  • Ormolu no longer overwrites already formatted files. PR 649.

  • Now a space is guaranteed before ticked promoted types. Issue 631.

  • Made formatting of single-line explicitly bidirectional pattern synonyms idempotent. Issue 630.


  • Fixed the bug when comments in different styles got glued together after formatting. Issue 589.

  • Added -i as a shortcut for --mode inplace. Issue 467.

  • Improved grouping of top-level declarations. Issue 466.


Upstream changes:


  • Imports in a import lists are now normalized: duplicate imports are combined/eliminated intelligently.

  • Import declarations that can be merged are now automatically merged. Issue 414.

  • The magic comments for disabling and enabling Ormolu now can encompass any fragment of code provided that the remaining code after exclusion of the disabled part is still syntactically correct. Issue 601.

  • Improved sorting of operators in imports. Issue 602.

  • Fixed a bug related to trailing space in multiline comments in certain cases. Issue 603.

  • Added support for formatting linked lists with (:) as line terminator. Issue 478.

  • Fixed rendering of function arguments in multiline layout. Issue 609.

  • Blank lines between definitions in let and while bindings are now preserved. Issue 554.

  • Fixed the bug when type applications stuck to the $ of TH splices that followed them. Issue 613.

  • Improved region formatting so that indented fragments—such as definitions inside of where clauses—can be formatted. Issue 572.

  • Fixed the bug related to the de-association of pragma comments. Issue 619.


  • Allow configuration of indentation size via fourmolu.yaml config files.

  • An operator on a new line is no longer indented when its left operand is a do-block. This prevents the AST from potentially changing when indenting by more than two spaces.

Upstream changes:


  • Fixed rendering of type signatures concerning several identifiers. Issue 566.

  • Fixed an idempotence issue with inline comments in tuples and parentheses. Issue 450.

  • Fixed an idempotence issue when certain comments were picked up as “continuation” of a series of comments Issue 449.

  • Fixed an idempotence issue related to different indentation levels in a comment series. Issue 512.

  • Fixed an idempotence issue related to comments which may happen to be separated from the elements they are attached to by the equality sign. Issue 340.

  • Fixed an idempotence issue with type synonym and data declarations where the type has a Haddock. Issue 578.

  • Fix the false positive about AST differences in presence of comments with multiple blank lines in a row. Issue 518.

  • Fixed rendering of comments around if expressions. Issue 458.

  • Unnamed fields of data constructors are now documented using the -- ^ syntax. Issue 445 and Issue 428.

  • Fixed non-idempotent transformation of partly documented data definition. Issue 590.

  • Fixed an idempotence issue related to operators. Issue 522.

  • Renamed the --check-idempotency flag to --check-idempotence. Apparently only the latter is correct.


  • The project was fourked to provide four space indent.


  • Grouping of statements in do-blocks is now preserved. Issue 74.

  • Grouping of TH splices is now preserved. Issue 507.

  • Comments on pragmas are now preserved. Issue 216.

  • Ormolu can now be enabled and disabled via special comments. Issue 435.

  • Added experimental support for simple CPP. Issue 415.

  • Added two new options --start-line and --end-line that allow us to select a region to format. Issue 516.

  • Fixed rendering of module headers in the presence of preceding comments or Haddocks. Issue 561.


  • When given several files to format, Ormolu does not stop on the first failure, but tries to format all the files. Issue 502.

  • Made rendering of pattern matches involving operators consistent with other cases of rendering of operators. Issue 500.

  • More compact rendering of type family injectivity constraints. Issue 482.

  • Improved rendering of the keyword where in class, data, and type family declarations. When headers of these declarations are multi-line where is now put on its own line. Issue 509.

  • Fixed the bug pertaining to rendering of arrow notation with multiline expressions. Issue 513.

  • Made rendering of data type definitions, value-level applications, and application of types use the same style. Moreover, existential now doesn’t cause the data constructor be unconditionally rendered in multiline layout. Issue 427.

  • Records with a single data constructor are now formatted more compactly. Issue 425.

  • Switched to ghc-lib-parser-8.10.1.

  • Implemented support for the new language extensions ImportQualifiedPost and StandaloneKindSignatures.


  • Fixed rendering of record updates with the record dot preprocessor syntax Issue 498.


  • Fixed an issue related to unnecessary use of curly braces. Issue 473.

  • Fixed the issue with formatting multi-way if when it happens to be a function applied to arguments Issue 488. This changed the way multi-line if is formatted in general.

  • Added support for record dot pre-processor when used via the plugin. Issue 486.

  • Stopped hanging record constructors and improved placing potentially-hanging consturctions in the presence of comments. Issue 447.

  • Fixed indentation in presence of type applications. Issue 493.

  • Class and instance declarations now do not have a blank line after where. Grouping of methods from the original input is also preserved with some normalizations. Issue 431.


  • Switched to ghc-lib-parser instead of depending on the ghc package directly. This should allow us to use newest features of GHC while not necessarily depending on the newest version of the compiler. In addition to that Ormolu is now GHCJS-compatible.

  • Now unrecognized GHC options passed with --ghc-opt cause Ormolu to fail (exit code 7).

  • Fixed formatting of result type in closed type families. See issue 420.

  • Fixed a minor inconsistency between formatting of normal and foreign type signatures. See issue 408.

  • Fixed a bug when comment before module header with Haddock was moved inside the export list. See issue 430.

  • Empty foralls are now correctly preserved. See issue 429.

  • Fixed issue 446, which involved braces and operators.

  • When there are comments between preceding Haddock (pipe-style) and its corresponding declaration they are preserved like this in the output instead of being shifted. To be clear, this is not a very good idea to have comments in that position because the Haddock will end up not being associated with the declarations. Issues 440 and 448.

  • Implemented correct handling of shebangs. Issue 377.

  • Implemented correct handling of stack headers. Issue 393.

  • Sorting language pragmas cannot not change meaning of the input program anymore. Issue 404.

  • Fixed formatting of applications where function is a complex expression. Issue 444.


  • Initial release.