Help language development. Donate to The Perl Foundation

Template::Mustache cpan:SOFTMOTH last updated on 2021-03-19
[![Build Status](]( [![Windows Status](](

Raku implementation of Mustache templates, [](


use Template::Mustache;

# Call .render as a class method
Template::Mustache.render('Hello, {{planet}}!', { planet => 'world' }).say;

# Or instantiate an instance
my $stache = :from<./views>;

# Subroutines are called
say $stache.render('The time is {{time}}', {
    time => { }

my @people =
    { :name('James T. Kirk'), :title<Captain> },
    { :name('Wesley'), :title('Dread Pirate'), :emcee },
    { :name('Dana Scully'), :title('Special Agent') },

# See this template in ./t/views/roster.mustache
$stache.render('roster', { :@people }).say;

my %context =
    event => 'Masters of the Universe Convention',
my %partials =
    welcome =>
        qq:b{Welcome to the {{event}}! We’re pleased to have you here.\n\n},

# See this result in ./t/50-readme.t
        {{> welcome}}
        {{> roster}}

            Dinner at 7PM in the Grand Ballroom. Bring a chair!
    :from([%partials, './views'])



### Log levels

Messages are logged with varying severity levels (from most to least severe): `Fatal`, `Error`, `Warn`, `Info`, `Verbose`, `Audit`, `Debug`, `Trace`, `Trace2`

By default, only messages of `Error` or worse are logged. That default can be changed with the `TEMPLATE_MUSTACHE_LOGLEVEL` environment variable.


The default is overridden with the `:log-level` option to ``, or a `Template::Mustache::Logger` object can be passed via the `:logger` option.

my $stache = :log-level<Trace>;

my $logger = :level<Debug>;
my $stache = :$logger;

Either method can be used with the `.render` method, as well.

my %data = hello => 'world';

Template::Mustache.render: 'Hello, {{hello}}!', %data, :log-level<Trace>;

my $logger = :level<Debug>;
Template::Mustache.render: 'Hello, {{hello}}!', %data, :$logger;

### Log routine

By default, any messages at level `Warn` or worse are logged with the `warn` routine. A `CONTROL` block can handle such warnings if needed; see [Language/phasers]( for details. Less severe messages (`Info` and up) are logged with the `note` routine.

The routine can be set per log level, in the `Template::Mustache::Logger.routines` hash.

# Use say instead of note for Info and up; the more severe
# levels (C<Warn> down to C<Fatal>) still use the warn routine
my $stache = :log-routine(&say);

# But even those can be set explicitly
$stache.logger.routines{$_} = &die for <Warn Error Fatal>;

$stache.render: '{{missing}}', {};  # dies

### method log

  * `multi method log(Exception $exception, LogLevel :$level)`

  * `multi method log(LogLevel :$level, *@msgs)`

Emit a message at `$level` (`Info` by default).

Extra features

Template inheritence

Support for `hogan.js`-style [template inheritence]( is available.


Specify `:pragma<KEEP-UNUSED-VARIABLES>` to either `` or `.render`, and any variables which are not defined in the data context will be kept in the rendered text. See `t/13-pragmas.t` for examples.

More Examples and Tests

The Mustache spec provides a wealth of examples to demonstrate exactly how the format behaves.


All of the official Mustache spec tests pass. An updated copy of the tests is distributed in `t/specs`.

To check against the official specs repository, clone it into `../mustache-spec`:

    git clone ../mustache-spec
    prove -v -e 'raku -Ilib' t/

Extra Specifications

The test file `t/specs/inheritable_partials.json` is taken from [groue/GRMustache](https:/

Other Mustache Implementations

There are many, many Mustache implementations in various languages. Some of note are:

  * The original Ruby version [](

  * Twitter's hogan.js [](

  * [](

  * GRMustache (Objective C) [](

  * mustache.php [](


  * full object support (with method calls; currently the object is just stringified)

  * global helpers (context items that float at the top of the stack)

  * database loader

  * pragmas (FILTERS?)


[Artistic License 2.0](