RELEASES.md

📝 Release notes

0.11.0

July 25th, 2026

• Replace Engine::with_syntax with Engine::set_syntax. Custom syntax is now configured on an existing engine via a setter method instead of a separate constructor, for example:

  let mut engine = Engine::new();
  engine.set_syntax(Syntax::builder().expr("<{", "}>").block("<[", "]>").build());

• Allow the value function passed to render_from_fn to be FnMut. Previously the closure had to implement Fn, this relaxes the bound so stateful value functions can be used.

0.10.0

June 27th, 2025

• Support &Value as second argument to functions. This allows you to register functions like upon::Value::eq.

• Support access and optional access from scope. This extends the syntax for variable access in expressions to support the dot (.) and optional dot (?.) prefixes for the first segment of paths.

  The following are equivalent:

  {{ user }}
  {{ .user }}
  

  But now you can also use the following, which will return Value::None if user is not defined:

  {{ ?.user }}
  

• Add support for in-place function calls. Previously, function calls only supported the "filter" syntax, which always required at least one argument to be "piped" into the call. This change adds an additional name and parenthesized argument syntax including those without arguments. For example code like the following is now valid:

  {{ now() }}
  

  {{ item.price | format: get_currency(user.id) }}
  

• Support parenthesized expressions. This allows you to use parentheses in inline expressions, such as:

  {{ content | replace: "John Smith", (user.name | title) }}
  

• Rename "filters" to "functions". "Filter" now refers to the way the function is used, i.e. the pipe syntax {{ value | function: arg1, arg2 }}. This change is in preparation for a new syntax for calling functions.

0.9.0

February 8th, 2025

• Support list and map literals. List and map literals can now be used in templates. List literals are created using square brackets and map literals are created using curly braces. For example, [1, 2, 3] is a list literal and { "key": "value" } is a map literal.

• Fix bug with filters expecting a borrowed argument would error. If a filter expected a borrowed argument, but the argument was owned, the filter code would error. This is now fixed.

0.8.1

February 23rd, 2024

• Fix bug with loop var access in nested template

0.8.0

October 28th, 2023

Features

• Add with_template_fn to Renderer This allows you to configure the way that included templates are resolved.

• Allow setting max_include_depth at renderer level This allows you to configure the maximum include depth on a per-renderer basis.

0.7.1

July 23rd, 2023

Features

• Add .template(name) function to engine This function is a shorthand for get_template that panics if the template does not exist.

Fixes

• Fix integer overflow when parsing index access

0.7.0

July 23rd, 2023

Features

• Redesign the render API This improvement allows us to add more configuration to the rendering process in the future. It also prevents the need for a proliferation of rendering functions. The new public Renderer struct is created using one of the three functions: render, render_from, or render_from_fn. And then the renderer can be consumed using .to_string() or .to_writer(..).

• Support ?. optional chaining operator

• Allow values to be fetched lazily This allows you to provide the global context from an outside source during rendering.

• Replace ValueCow::as_bool with truthiness function This change implements a truthiness function for evaluating conditionals. None, false, 0 integer and 0.0 float, empty string, list, and map as falsy. Everything else is truthy.

  Contributed by @lunabunn

0.6.0

November 20th, 2022

Features

• Expand supported filter argument types Adds the unit type, all integer primitive types, and f32.

Fixes

• Fix bug in value! macro
• Use index implementation for looking up spans This removes all the unsafe code in this library. I think the decrease in performance (about 5-10%) is worth not having any unsafe code.

0.5.0

November 14th, 2022

Features

• Add methods to remove templates and functions remove_template allows you to remove a template from the engine. remove_function allows you to remove a formatter or filter from the engine. add_formatter and add_filter now return the previous type of function if a function of the same name already existed in the engine.
• Add some From and FromIterator impls for Value
• Support and test on Rust 1.60
• Support Unicode identifiers

Fixes

• Parse list indices in lexer This fixes a bug where a path like lorem.123.ipsum would not parse correctly because the lexer would return a Token::Number for the span "123.ipsum". This requires adding an additional state to the lexer so that it knows when it is lexing a path versus a float literal.
• Refactor formatter and filter errors Move formatter types to new module, add fmt::Error type. Add filter error trait and kind.
• Add template name to error, update error format

0.4.0

October 3rd, 2022

Features

• Make various filter traits public This allows you to refer to them if you want to be generic over filters.
• Support else if This is simply desugared to a nested if statement in the parser.
• Support scientific notation for float literals
• Use Cow<str> for map keys and template sources This allows you to store template sources computed at runtime in the engine while preserving support for templates included in the binary.

Fixes

• Fix bug with include statement scopes
• Restrict maximum include depth. This prevents infinite recursion when including templates. This can be configured using the set_max_include_depth method on an Engine.
• Disallow configuring syntax using empty strings We now panic if you pass an empty string to SyntaxBuilder.