Mustache is a simple, restricted, fast template language inspired by ctemplate. There is a great introduction to the language here on github. And a nice overview of the different tags at the ruby implementation.

Amulet began as a fork of the v2 branch of raycmorgan's Mu. I eventually changed so much of the API that I decided to rename it.
Amulet attempts/intends to implement all of the Mustache specification, except that it does not always honor the whitespace requirements, which, for the purposes of HTML, does not matter. (Obeying the white-space conventions is on the to-do list.)

The main function, amulet.render, can be called in a few variations. The basic signature is function(output, templates, context, asap, callback), but a number of the arguments are optional (output is the only required argument):

amulet.render always returns a Renderer object, which is useful if you want a way to add context or force it to end.

one.mu

<h3>{{first}} {{last}}</h3>
<p>{{description}}</p>

app.js (snippet):

renderer.extendContext({last: 'Brown'});

At this point, the renderer would output up to the <p>
and then pause, waiting for the description variable to be filled.
But if you decide you want it to skip over the missing variables,
as any basic Mustache spec would do:

renderer.force();

Which sets asap to false, and immediately streams through the rest of your template.

Mu is faster for certain benchmarks, because the template rendering itself is synchronous. Amulet does everything A.S.A.P. (as soon as possible), so it will start rendering your templates before any of your context variables are available, only halting when it encounters a missing variable. This functionality is optional -- if you want to render a template with one command, you still can.

PHP appears so fast (while sucking so much at everything else) because it renders as soon as possible, so that the top 90% of the page gets rendered before some cpu-intensive bit gets called to render the footer. That's what Amulet does, too, basically.

Like Mu, Amulet

Is very fast

Supports asynchronous parsing and compiling

Renders streamingly

Beyond Mu, Amulet

Supports template hierarchies

Renders as soon as possible, pausing only to wait for missing variables from the controller

Don't repeat yourself; namely, don't use XML-type redundancy. A Mustache template is a directed acyclic graph (DAG), i.e. a tree, meaning that a closing node is never ambiguous. You needn't tell the Amulet parser what you're closing. It already knows.

When rendering a template hierarchy, use a < in your master layout (the opposite of the partial symbol >):

layout.mu

<!DOCTYPE html>
{{<}}

index.mu

<p>Just the facts.</p>

Output of amulet.render(response, ['layout.mu', 'index.mu']):

<!DOCTYPE html>
<p>Just the facts.</p>

To make it easier to remember what < does, you can also write {{<yield}} or even {{<yield/>}} to make your syntax highlighter happy. As soon as the parser sees the < character, it will skip to the end of the mustache tag.