Scala {{mustache}} template engine
Switch branches/tags
Nothing to show
Clone or download
vspy Merge pull request #5 from sdz-dalbrecht/master
update for scala 2.11.1
Latest commit 6750e8a Jun 16, 2014
Failed to load latest commit information.
project update for scala 2.11.1 Jun 16, 2014
src scala 2.10, specs2, awaitable support Jul 21, 2013 readme Apr 10, 2011
build.sbt update for scala 2.11.1 Jun 16, 2014


What is Mustache?

Mustache is a logic-free template engine inspired by ctemplate and et.

As ctemplates says, "It emphasizes separating logic from presentation: it is impossible to embed application logic in this template language".


To get the language-agnostic overview of Mustache's template syntax and examples of Mustache templates, see

Getting started with scala-mustache is easy:

import mustache._
val template = new Mustache("Hello, {{ name }}!")

Returns following:

Hello, world!

Following example shows how to use partials:

val userTemplate = new Mustache("<strong>{{name}}</strong>")
val baseTemplate = new Mustache(
  "<h2>Names</h2>\n{{#names}}\n  {{> user}}\n{{/names}}"
val ctx = Map("names"->List(
val partials = Map("user" -> userTemplate)
baseTemplate.render(ctx, partials)

Templates defined here can be thought of as a single, expanded template:


You can use {{.}} and {{{.}}} to reference current context value:

val template = new Mustache("{{#list}}{{.}} {{/list}}")
template.render(Map("list"->List("alpha", "bravo", "charlie")))


alpha bravo charlie

When the context value is a callable object, such as a function or lambda, the object will be invoked and passed the block of text. The text passed is the literal block, unrendered. {{tags}} will not have been expanded - the lambda should do that on its own. In this way you can implement filters or caching.

val template = new Mustache("{{#wrapped}}{{name}} is awesome.{{/wrapped}}")
    ,"wrapped"->((str:String, render:(String)=>String)=>{ "<b>"+render(str)+"</b>" })


<b>Willy is awesome.</b>

Alternatively you can pack your helpers directly into the Mustache subclass. Following example is effectively the same as previous:

class MyMustache(template:String) 
  extends Mustache(template) {

  def wrapped(str:String) = "<b>"+render(str)+"</b>"

val template = new MyMustache("{{#wrapped}}{{name}} is awesome.{{/wrapped}}") 

Sometimes it is nice to keep different kinds of helpers separate. To do so, you can define helper traits and then mix them up as needed:

trait MyHelper {
  this: MyHelper with MustacheHelperSupport =>

  def wrapped(str:String) = "<b>"+render(str)+"</b>"

class MyMustache(template:String) 
  extends Mustache(template) with MyHelper {}

MustacheHelperSupport trait defines following methods you can use in your helper methods:

protected def context:Any                   // returns current context
protected def render(template:String):Any   // renders template string

Dependencies / Build

This project has absolutely zero runtime dependencies and you can build it with Simple Build Tool.


This project is licensed under the MIT license.

I’m not a lawyer and this is not a legal advice, but it is free to use in any projects. Free as in “free beer”. Should you have any questions on licensing, consult your lawyer.

Enjoy !