Tera Basics🔗

A Tera template is just a text file where variables and expressions get replaced with values when it is rendered. The syntax is based on Jinja2 and Django templates.

There are 3 kinds of delimiter and those cannot be changed:


Tera will consider all text inside the raw block as a string and won't try to render what's inside. Useful if you have text that contains Tera delimiters.

{% raw %}
  Hello {{ name }}
{% endraw %}

would be rendered as Hello {{ name }}.

Whitespace control🔗

Tera comes with easy to use whitespace control: use {%- if you want to remove all whitespace before a statement and -%} if you want to remove all whitespace after.

For example, let's look at the following template:

{% set my_var = 2 %}
{{ my_var }}

will have the following output:


If we want to get rid of the empty line, we can write the following:

{% set my_var = 2 -%}
{{ my_var }}


To comment out part of the template, wrap it in {# #}. Anything in between those tags will not be rendered.

{# A comment #}

Data structures🔗


Tera has a few literals that can be used:


Variables are defined by the context given when rendering a template. If you'd like to define your own variables, see the Assignments section.

You can render a variable by using the {{ name }}.

Trying to access or render a variable that doesn't exist will result in an error.

A magical variable is available in every template if you want to print the current context: __tera_context.

Dot notation:🔗

Construct and attributes can be accessed by using the dot (.) like {{ product.name }}. Specific members of an array or tuple are accessed by using the .i notation, where i is a zero-based index.

Square bracket notation:🔗

A more powerful alternative to (.) is to use square brackets ([ ]). Variables can be rendering using the notation {{product['name']}} or {{product["name"]}}.

If the item is not in quotes it will be treated as a variable. Assuming you have the following objects in your context product = Product{ name: "Fred" } and my_field = "name", calling {{product[my_field]}} will resolve to: {{product.name}}.

Only variables evaluating to String and Number can be used as index: anything else will be an error.


Tera allows expressions almost everywhere.


You can do some basic math in Tera but it shouldn't be abused other than the occasional + 1 or similar. Math operations are only allowed with numbers, using them on any other kind of values will result in an error. You can use the following operators:

The priority of operations is the following, from lowest to highest:



String concatenation🔗

You can concatenate several strings/idents using the ~ operator

{{ "hello " ~ 'world' ~ `!` }}

{{ an_ident ~ " and a string" ~ another_ident }}

{{ an_ident ~ another_ident }}

An ident resolving to something other than a string will raise an error.

Manipulating data🔗


You can assign values to variables during the rendering. Assignments in for loops and macros are scoped to their context but assignments outside of those will be set in the global context.

{% set my_var = "hello" %}
{% set my_var = 1 + 4 %}
{% set my_var = some_var %}
{% set my_var = macros::some_macro() %}
{% set my_var = global_fn() %}
{% set my_var = [1, true, some_var | round] %}

If you want to assign a value in the global context while in a for loop, you can use set_global:

{% set_global my_var = "hello" %}
{% set_global my_var = 1 + 4 %}
{% set_global my_var = some_var %}
{% set_global my_var = macros::some_macro() %}
{% set_global my_var = global_fn() %}
{% set_global my_var = [1, true, some_var | round] %}

Outside of a for loop, set_global is exactly the same as set.


You can modify variables using filters. Filters are separated from the variable by a pipe symbol (|) and may have named arguments in parentheses. Multiple filters can be chained: the output of one filter is applied to the next.

For example, {{ name | lower | replace(from="doctor", to="Dr.") }} will take a variable called name, make it lowercase and then replace instances of doctor by Dr.. It is equivalent to replace(lower(name), from="doctor", to="Dr.") if we were to look at it as functions.

Calling filters on a incorrect type like trying to capitalize an array or using invalid types for arguments will result in a error.

Filters are functions with the fn(Value, HashMap<String, Value>) -> Result<Value> definition and custom ones can be added like so:

tera.register_filter("upper", string::upper);

While filters can be used in math operations, they will have the lowest priority and therefore might not do what you expect:

{{ 1 + a | length }}
// is equal to
{{ (1 + a) | length } // this will probably error

// This will do what you wanted initially
{{ a | length + 1 }}

Tera has many built-in filters that you can use.

Filter sections🔗

Whole sections can also be processed by filters if they are encapsulated in {% filter name %} and {% endfilter %} tags where name is the name of the filter:

{% filter upper %}
{% endfilter %}

This example transforms the text Hello in all upper-case (HELLO).


Tests can be used against an expression to check some condition on it and are made in if blocks using the is keyword. For example, you would write the following to test if an expression is odd:

{% if my_number is odd %}
{% endif %}

Tests are functions with the fn(Option<Value>, Vec<Value>) -> Result<bool> definition and custom ones can be added like so:

tera.register_tester("odd", testers::odd);

Tera has many built-in tests that you can use.


Functions are Rust code that return a Result<Value> from the given params.

Quite often, functions will need to capture some external variables, such as a url_for global function needing the list of URLs for example. To make that work, the type of GlobalFn is a boxed closure: Box<Fn(HashMap<String, Value>) -> Result<Value> + Sync + Send>.

Here's an example on how to implement a very basic function:

fn make_url_for(urls: BTreeMap<String, String>) -> GlobalFn {
    Box::new(move |args| -> Result<Value> {
        match args.get("name") {
            Some(val) => match from_value::<String>(val.clone()) {
                Ok(v) =>  Ok(to_value(urls.get(&v).unwrap()).unwrap()),
                Err(_) => Err("oops".into()),
            None => Err("oops".into()),

You then need to add it to Tera:

tera.register_function("url_for", make_url_for(urls));

And you can now call it from a template:

{{ url_for(name="home") }}

Currently functions can be called in two places in templates:

Tera comes with some built-in functions.

Control structures🔗


Conditionals are fully supported and are identical to the ones in Python.

{% if price < 10 or always_show %}
   Price is {{ price }}.
{% elif price > 1000 and not rich %}
   That's expensive!
{% else %}
{% endif %}

Undefined variables are considered falsy. This means that you can test for the presence of a variable in the current context by writing:

{% if my_var %}
    {{ my_var }}
{% else %}
    Sorry, my_var isn't defined.
{% endif %}

Every if statement has to end with an endif tag.


Loop over items in a array:

{% for product in products %}
  {{loop.index}}. {{product.name}}
{% endfor %}

A few special variables are available inside for loops:

Every for statement has to end with an endfor tag.

You can also loop on maps and structs using the following syntax:

{% for key, value in products %}
  {{loop.index}}. {{product.name}}
{% endfor %}

key and value can be named however you want, they just need to be separated with a comma.

If you are iterating on an array, you can also apply filters to the container:

{% for product in products | reverse %}
  {{loop.index}}. {{product.name}}
{% endfor %}

Lastly, you can iterate on array literals:

{% for a in [1,2,3,] %}
{% endfor %}

Loop Controls🔗

Within a loop, break and continue may be used to control iteration.

To stop iterating when target_id is reached:

{% for product in products %}
  {% if product.id == target_id %}{% break %}{% endif %}
  {{loop.index}}. {{product.name}}
{% endfor %}

To skip even-numbered items:

{% for product in products %}
  {% if loop.index is even %}{% continue %}{% endif %}
  {{loop.index}}. {{product.name}}
{% endfor %}


You can include a template to be rendered using the current context with the include tag.

{% include "included.html" %}

Tera doesn't offer passing a custom context to the include tag. If you want to do that, use macros.

While you can set values in included templates, those values only exist while rendering them: the template calling include doesn't see them.


Think of macros as functions or components that you can call and return some text. Macros currently need to be defined in a separate file and imported to be useable.

They are defined as follows:

{% macro input(label, type="text") %}
        {{ label }}
        <input type="{{type}}" />
{% endmacro input %}

As shown in the example above, macro arguments can have a default literal value.

In order to use them, you need to import the file containing the macros:

{% import "macros.html" as macros %}

You can name that file namespace (macros in the example) anything you want. A macro is called like this:

// namespace::macro_name(**kwargs)
{{ macros::input(label="Name", type="text") }}

Do note that macros, like filters, require keyword arguments. If you are trying to call a macro defined in the same file or itself, you will need to use the self namespace. The self namespace can only be used in macros. Macros can be called recursively but there is no limit to recursion so make sure you macro ends.

Here's an example of a recursive macro:

{% macro factorial(n) %}
  {% if n > 1 %}{{ n }} - {{ self::factorial(n=n-1) }}{% else %}1{% endif %}
{% endmacro factorial %}

Macros body can contain all normal Tera syntax with the exception of macros definition, block and extends.


Tera uses the same kind of inheritance as Jinja2 and Django templates: you define a base template and extends it in child templates through blocks. There can be multiple levels of inheritance (i.e. A extends B that extends C).

Base template🔗

A base template typically contains the basic document structure as well as several blocks that can have content.

For example, here's a base.html almost copied from the Jinja2 documentation:

<!DOCTYPE html>
<html lang="en">
    {% block head %}
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}{% endblock title %} - My Webpage</title>
    {% endblock head %}
    <div id="content">{% block content %}{% endblock content %}</div>
    <div id="footer">
        {% block footer %}
        &copy; Copyright 2008 by <a href="http://domain.invalid/">you</a>.
        {% endblock footer %}

The only difference with Jinja2 being that the endblock tags have to be named.

This base.html template defines 4 block tag that child templates can override. The head and footer block have some content already which will be rendered if they are not overridden.

Child template🔗

Again, straight from Jinja2 docs:

{% extends "base.html" %}
{% block title %}Index{% endblock title %}
{% block head %}
    {{ super() }}
    <style type="text/css">
        .important { color: #336699; }
{% endblock head %}
{% block content %}
    <p class="important">
      Welcome to my awesome homepage.
{% endblock content %}

To indicate inheritance, you have use the extends tag as the first thing in the file followed by the name of the template you want to extend. The {{ super() }} variable call tells Tera to render the parent block there.

Nested blocks also work in Tera. Consider the following templates:

// grandparent
{% block hey %}hello{% endblock hey %}

// parent
{% extends "grandparent" %}
{% block hey %}hi and grandma says {{ super() }} {% block ending %}sincerely{% endblock ending %}{% endblock hey %}

// child
{% extends "parent" %}
{% block hey %}dad says {{ super() }}{% endblock hey %}
{% block ending %}{{ super() }} with love{% endblock ending %}

The block ending is nested in the hey block. Rendering the child template will do the following:

The end result of that rendering (not counting whitespace) will be: "dad says hi and grandma says hello sincerely with love".


Built-in filters🔗

Tera has the following filters built-in:


Lowercase a string


Returns number of words in a string


Returns the string with all its character lowercased apart from the first char which is uppercased.


Takes 2 mandatory string named arguments: from and to. It will return a string with all instances of the from string with the to string.

Example: {{ name | replace(from="Robert", to="Bob")}}


Adds slashes before quotes.

Example: {{ value | addslashes }}

If value is "I'm using Tera", the output will be "I\'m using Tera".


Transform a string into ASCII, lowercase it, trim it, converts spaces to hyphens and remove all characters that are not numbers, lowercase letters or hyphens.

Example: {{ value | slugify }}

If value is "-Hello world! ", the output will be "hello-world".


Capitalizes each word inside a sentence.

Example: {{ value | title }}

If value is "foo bar", the output will be "Foo Bar".


Remove leading and trailing whitespace if the variable is a string.


Truncates a string to the indicated length. If the string has a smaller length than the length argument, the string is returned as is.

Example: {{ value | truncate(length=10) }}

By default, the filter will add an ellipsis at the end if the text was truncated. You can change the string appended by setting the end argument. For example, {{ value | truncate(length=10, end="") }} will not append anything.


Tries to remove HTML tags from input. Does not guarantee well formed output if input is not valid HTML.

Example: {{ value | striptags}}

If value is "<b>Joel</b>", the output will be "Joel".

Note that if the template you using it in is automatically escaped, you will need to call the safe filter before striptags.


Returns the first element of an array. If the array is empty, returns empty string.


Returns the last element of an array. If the array is empty, returns empty string.


Joins an array with a string.

Example: {{ value| join(sep=" // ") }}

If value is the array ['a', 'b', 'c'], the output will be the string "a // b // c".


Returns the length of an array or a string, 0 if the value is not an array.


Returns a reversed string or array.


Sorts an array into ascending order.

The values in the array must be a sortable type:

If you need to sort a list of structs or tuples, use the attribute argument to specify which field to sort by.


Given people is an array of Person

struct Name(String, String);

struct Person {
    name: Name,
    age: u32,

The attribute argument can be used to sort by last name:

{{ people | sort(attribute="name.1") }}

or by age:

{{ people | sort(attribute="age") }}


Slice an array by the given start and end parameter. Both parameters are optional and omitting them will return the same array. Use the start argument to define where to start (inclusive, default to 0) and end argument to define where to stop (exclusive, default to the length of the array). start and end are 0-indexed.

{% for i in my_arr | slice(end=5) %}
{% for i in my_arr | slice(start=1) %}
{% for i in my_arr | slice(start=1, end=5) %}


Group an array using the required attribute argument. The filter takes an array and return a map where the keys are the values of the attribute stringified and the values are all elements of the initial array having that attribute. Values with missing attribute or where attribute is null will be discarded.


Given posts is an array of Post

struct Author {
    name: String,

struct Post {
    content: String,
    year: u32,
    author: Author,

The attribute argument can be used to group posts by year:

{{ posts | sort(attribute="year") }}

or by author name:

{{ posts | sort(attribute="author.name") }}


Filter the array values, returning only the values where the attribute is equal to the value. Values with missing attribute or where attribute is null will be discarded.

Both attribute and value are mandatory.


Given posts is an array of Post

struct Author {
    name: String,

struct Post {
    content: String,
    year: u32,
    author: Author,
    draft: bool,

The attribute argument can be used to filter posts by draft value:

{{ posts | filter(attribute="draft", value=true) }}

or by author name:

{{ posts | filter(attribute="author.name", value="Vincent") }}


Appends values to an array.

{{ posts | concat(with=drafts) }}

The filter takes an array and returns a new array with the value(s) from the with parameter added. If the with parameter is an array, all of its values will be appended one by one to the new array and not as an array.

This filter can also be used to append a single value to an array if the value passed to with is not an array:

{% set pages_id = pages_id | concat(with=id) %}

The with attribute is mandatory.


Percent-encodes a string.

Example: {{ value | urlencode }}

If value is /foo?a=b&c=d, the output will be /foo%3Fa%3Db%26c%3Dd.

Takes an optional argument of characters that shouldn't be percent-encoded (/ by default). So, to encode slashes as well, you can do {{ value | urlencode(safe="") }}.


Returns a suffix if the value is greater or equal than 2. Suffix defaults to s

Example: You have {{ num_messages }} message{{ num_messages|pluralize }}

If num_messages is 1, the output will be You have 1 message. If num_messages is 2 the output will be You have 2 messages. You can specify the suffix as an argument that way: {{ num_messages|pluralize(suffix="es") }}


Returns a number rounded following the method given. Default method is common which will round to the nearest integer. ceil and floor are available as alternative methods. Another optional argument, precision, is available to select the precision of the rounding. It defaults to 0, which will round to the nearest integer for the given method.

Example: {{ num | round }} {{ num | round(method="ceil", precision=2) }}


Returns a human-readable file size (i.e. '110 MB') from an integer.

Example: {{ num | filesizeformat }}


Parse a timestamp into a date(time) string. Defaults to YYYY-MM-DD format. Time formatting syntax is inspired from strftime and a full reference is available on chrono docs.

Example: {{ ts | date }} {{ ts | date(format="%Y-%m-%d %H:%M") }}


Escapes a string's HTML. Specifically, it makes these replacements:


Mark a variable as safe: HTML will not be escaped anymore. Currently the position of the safe filter does not matter, e.g. {{ content | safe | replace(from="Robert", to="Bob") }} and {{ content | replace(from="Robert", to="Bob") | safe }} will output the same thing.


Access a value from an object when the key is not a Tera identifier. Example: {{ sections | get(key="posts/content") }}


Split a string into an array of strings, separated by a pattern given. Example: {{ path | split(pat="/") }}


Transforms any value into a JSON representation. This filter is better used together with safe or when automatic escape is disabled.

Example: {{ value | safe | json_encode() }}

It accepts a parameter pretty (boolean) to print a formatted JSON instead of a one-liner.

Example: {{ value | safe | json_encode(pretty=true) }}


Returns a string representation of the given value.

Example: {{ value | as_str }}


Returns the default value given only if the variable evaluated is not present in the context and is therefore meant to be at the beginning of a filter chain if there are several filters.

Example: {{ value | default(value=1) }}

This is in most cases a shortcut for:

{% if value %}{{ value }}{% else %}1{% endif %}

However, only the existence of the value in the context is checked. With a value that if would evaluate to false (such as an empty string, or the number 0), the default filter will not attempt replace it with the alternate value provided. For example, the following will produce "I would like to read more !":

I would like to read more {{ "" | default (value="Louise Michel") }}!

If you intend to use the default filter to deal with optional values, you should make sure those values aren't set! Otherwise, use a full if block. This is especially relevant for dealing with optional arguments passed to a macro.

Built-in tests🔗

Here are the currently built-in tests:


Returns true if the given variable is defined.


Returns true if the given variable is undefined.


Returns true if the given variable is an odd number.


Returns true if the given variable is an even number.


Returns true if the given variable is a string.


Returns true if the given variable is a number.


Returns true if the given expression is divisible by the arg given.


{% if rating is divisibleby(2) %}
{% endif %}


Returns true if the given variable can be iterated over in Tera (ie is an array/tuple).


Returns true if the given variable is a string starts with the arg given.


{% if path is starting_with("x/") %}
    In section x
{% endif %}


Returns true if the given variable is a string ends with the arg given.


Returns true if the given variable contains the arg given.

The test works on:


{% if username is containing("xXx") %}
{% endif %}


Returns true if the given variable is a string and matches the regex in the argument.


{% if name is matching("^[Qq]ueen") %}
    Her Royal Highness, {{ name }}
{% elif name is matching("^[Kk]ing") %}
    His Royal Highness, {{ name }}
{% else %}
    {{ name }}
{% endif %}

A comprehensive syntax description can be found in the regex crate documentation.

Built-in functions🔗

Tera comes with some built-in global functions.


Returns an array of integers created using the arguments given. There are 3 arguments, all integers:


Returns the local datetime as string or the timestamp as integer if requested.

There are 2 arguments, both booleans:

Formatting is not built-in the global function but you can use the date filter like so now() | date(format="%Y") if you wanted to get the current year.


The template rendering will error with the given message when encountered.

There is only one string argument: