README.markdown

Mu - Mustache template compiler for Node.js

Mustache is a simply awesome template language inspired by ctemplate and et.

Mu is a Mustache based template engine for Node.js. Mu compiles mustache templates into an extremely fast executable function.

What makes Mu cool?

• It is very fast
• Supports async parsing/compiling
• Rendering is streamed

Benchmarks

Rendering examples/complex.html.mu 1 million times yields the following results:

Ruby Mustache - 112 secs  (benchmarks/rb/complex_view.rb)
           Mu -  40 secs  (benchmarks/million_complex.js)

Tested on a 2.4 GHz Intel Core 2 Duo MacBook Pro

Mu sync rendering was benchmarking in at 24 secs, but I felt it was much more important to stream the rendering. Streaming adds a pretty set overhead of about 14µs (microseconds) to each template render to setup the event emitter. It also adds a variable extra amount of time due to the additional function calls. The million_complex.js caused 2µs per render addition.

Usage (from demo.js)

var sys = require('sys');
var Mu = require('./lib/mu');

Mu.templateRoot = './examples';

var ctx = {
  name: "Chris",
  value: 10000,
  taxed_value: function() {
    return this.value - (this.value * 0.4);
  },
  in_ca: true
};

Mu.render('simple.html', ctx, {}, function (err, output) {
  if (err) {
    throw err;
  }
  
  var buffer = '';

  output.addListener('data', function (c) {buffer += c; })
        .addListener('end', function () { sys.puts(buffer); });
});

Which yields:

Hello Chris
You have just won $10000!
Well, $6000, after taxes.

Using Mu.compileText

var sys = require('sys');
var Mu = require('./lib/mu');

var tmpl = "Hello {{> part}}. Your name is: {{name}}!";
var partials = {part: "World"};
var compiled = Mu.compileText(tmpl, partials);

compiled({name: "Chris"})
  .addListener('data', function (c) { sys.puts(c) });

Mustache Documentation

See Tag Types section at http://github.com/defunkt/mustache/ for more information on supported tags.

Todo

• Better parse time errors. Currently they are decent when partials are not involved but break down once partials are involved.
• Implement some compile time optimizations. The big one is predetermining when a enumerable actually needs to inherit the full context. Cutting this out can be huge.
• Cleanup the Preprocessor methods. They are a bit unwieldy.