The microstache package

[ Tags: bsd3, library, text ] [ Propose Tags ]

Mustache templates for Haskell.

Based on stache library, which uses megaparsec. This library uses parsec, thus the name: microstache.

[Skip to Readme]


Versions 1, 1.0.1,
Change log
Dependencies aeson (>=0.11 && <1.3), base (>=4.5 && <5.0), bytestring (>= && <0.11), containers (>= && <0.6), deepseq (>= && <1.5), directory (>= && <1.4), filepath (>= && <1.5), ghc-prim, parsec (>=3.1.11 && <6.0), semigroups (==0.18.*), text (==1.2.*), transformers (>= && <0.6), unordered-containers (>=0.2.5 && <0.3), vector (>=0.11 && <0.13) [details]
License BSD3
Author Mark Karpov <>, Oleg Grenrus <>
Maintainer Oleg Grenrus<>
Category Text
Home page
Bug tracker
Source repo head: git clone
Uploaded Thu Jul 20 19:26:30 UTC 2017 by phadej
Distributions Arch:, Fedora:, LTSHaskell:, NixOS:, Stackage:, openSUSE:
Downloads 5111 total (135 in the last 30 days)
Rating 2.25 (votes: 2) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2017-07-20 [all 1 reports]
Hackage Matrix CI




Maintainer's Corner

For package maintainers and hackage trustees

Readme for microstache-

[back to package description]


Based on stache library, which uses megaparsec. This library uses parsec, thus the name: microstache.

This is a Haskell implementation of Mustache templates. The implementation conforms to the version 1.1.3 of official [Mustache specification] ( It is extremely simple and straightforward to use with minimal but complete API — three functions to compile templates (from directory, from file, and from lazy text) and one to render them.

For rendering you only need to create Aeson's Value where you put the data to interpolate. Since the library re-uses Aeson's instances and most data types in Haskell ecosystem are instances of classes like Data.Aeson.ToJSON, the whole process is very simple for end user.

One feature that is not currently supported is lambdas. The feature is marked as optional in the spec and can be emulated via processing of parsed template representation. The decision to drop lambdas is intentional, for the sake of simplicity and better integration with Aeson.

Differences from stache

  • Instead of megaparsec, parsec is used. Error message quality is most likely degraded.
  • There are no TemplateHaskell used; yet there are no helpers provided.
  • Support for GHC-7.4.2 – GHC-8.2.1

Quick start

Here is an example of basic usage:

{-# LANGUAGE OverloadedStrings #-}

module Main (main) where

import Data.Aeson
import Data.Text
import Text.Microstache
import qualified Data.Text.Lazy.IO as TIO

main :: IO ()
main = do
  let res = compileMustacheText "foo"
        "Hi, {{name}}! You have:\n{{#things}}\n  * {{.}}\n{{/things}}\n"
  case res of
    Left err -> putStrLn (show err)
    Right template -> TIO.putStr $ renderMustache template $ object
      [ "name"   .= ("John" :: Text)
      , "things" .= ["pen" :: Text, "candle", "egg"]

If I run the program, it prints the following:

Hi, John! You have:
  * pen
  * candle
  * egg

For more information about Mustache templates the following links may be helpful:


Copyright © 2016–2017 Stack Builders, 2017 Oleg Grenrus

Distributed under BSD 3 clause license.