All notable changes to MiniJinja are documented here.

• Item or attribute lookup will no longer swallow all errors in Python. #814
• Added |zip filter. #818
• Fix break_on_hyphens for the |wordwrap filter. #823
• Prefer error message from unknown_method_callback. #824
• Ignore .jinja and .jinja2 as extensions in auto escape. #832

• Fixed incorrect joining of leading undefineds or empty strings in the |join filter. This was inconsistent with Jinja2 and the filter itself for undefineds in other positions. #794
• Allow negative arguments to range function and change range to isize. #799
• Allow isize as argument type. #799
• MiniJinja now correctly handles \x escape sequences in strings as well as octals. #805
• Added a new |chain filter. #807

• Fixed an issue with the function bounds that caused the next-generation trait resolver to fail. #787

• Re-release of 2.10.0 because of a broken release process.

• Fix incorrect permissions when --output is used in the CLI. #772
• Added mj_err_get_debug_info to the C-ABI. #775
• Modules now capture their output like they do in Jinja2. This means that if you do {% import 'template.j2' as x %} and you then render {{ x }} the output of template.j2 is rendered as if it was included. #778
• Improved compatibility with Jinja2 for slicing. Negative steps are now correctly handled. Additionally slicing on bytes now correctly handles steps other than 1. #781

• Do not panic if too large templates (too many lines or too many columns) are loaded. The error reporting will be wrong in those cases but the templates will load. #742
• Fixed a bug that caused unknown method callbacks to not get proper error reporting if they cannot find a method. #743
• Added merge_maps which is a dynamic version of the context! merge feature, and fixed enumeration behavior when non-map objects are attempted to be merged. #745
• Added mj_value_new_bytes to the C-ABI. #749
• Added mj_value_as_bytes to the C-ABI to borrow from strings or byte values. #750
• Fixed buggy mj_err_get_detail and mj_err_get_template_name. These did not work correctly. To fix them the return value now needs to be freed. #754
• Fix a compilation issue on 32bit systems when AtomicU64 is not available in minijinja-contrib. #755
• Correctly handle with context and without context for imports. #759
• The default filter is now also registered as d for Jinja2 compatibility. #763
• The default filter now accepts a second argument to enable lax defaulting. #764
• Added a striptags filter to the contrib module. #765
• Enable pycompat by default for the Python bindings and register the default contrib filters and tests. #767

• Added SemiStrict undefined mode that is like strict but allows to be checked for truthiness. Additionally an if expression without an else block will always produce a silent undefined object that never errors for compatibility with Jinja2. #687
• Make the trait bounds of ViaDeserialize stricter. Now the type can only be constructed if the type implements DeserializeOwned. This is not a new requirement for passing the function to add_function but bad code will now error earlier for better error reporting. #689
• Raise MSRV to 1.70.
• The contrib crate now uses a basic xorrand implementation instead of depending on all of the rand module. #696
• Added temps, a way to stash away temporary state during rendering. #697
• Fixed a bug that caused the random functions in the contrib crate to not advance the RNG between calls. #698
• Added Environment.undeclared_variables_in_template and Environnent.undeclared_variables_in_str to Python binding. #699
• Enable loop_controls for Python in-line with the CLI. #704
• Fixed a panic when comparing plain objects. #705
• Added Object::custom_cmp to allow objects to influence how they compare against themselves. This also fixes Python objects in the Python binding not to compare correctly. #707
• Fixed a bug where undeclared_variables would incorrectly handle variables referenced by macros. #714
• Fixed a deadlock in the Python binding when multiple threads were rendering from the same environment at once. #717
• The Python bindings handle __bool__ correctly now for custom objects in if-conditions and filters. #719
• Fixed a bug where }} caused a syntax error in expressions with open parentheses, braces or brackets. #723
• Added State::known_variables to return a list of known variables and Environment::globals. #724
• Fixed an issue with undeclared variables not handling caller. #725
• Removed unnecessary Filters and Tests traits. They remain as hidden aliases to Function. #726
• Fixed a bug that caused implicit string concatenation to not correctly handle escapes. #728
• Implemented constant folding in the code generator. #731
• Improved error reporting for bad loop recursion calls. #734
• The engine now uses smaller integers to represent columns, line numbers and addresses. This cuts down on the memory usage needed for debug information. #735
• Added load_from_path to python. #736
• Added JavaScript bindings. #737

• Removed string interning. #675
• loop.nextitem is now a lazy operation. This prevents issues when iterating over one-shot iterators combined with {% break %} and it now ensures that the iterator is not running "one item ahead". #677
• Fixed an issue that caused loop aliasing not to be supported for recursive loops. #678
• CLI moved from serde_yml to serde_yaml. #684
• Improved undefined error reporting. Undefined values will now in most cases point to exactly where the error happened. #686
• Allow newer notify dependency versions (up to 8.x) for the autoreload crate. #688

• Added sum filter. #648
• Added truncate filter to minijinja-contrib. #647
• Added wordcount filter to minijinja-contrib. #649
• Added wordwrap filter to minijinja-contrib. #651
• Some tests and filters now pass borrowed values for performance reasons and a bug was fixed that caused undefined values in strict undefined mode not to work with tests. #657
• Fixed an error reporting issue for some syntax errors. #655
• Removed an unsafe code block from the Kwargs type internally which was probably unsafe. #659
• Fix a regression with latest serde that caused internals to leak out when flattening on value handles is used. #664
• Added Value::make_object_map to create projections from object into maps, similar to how it was already possible to create iterators that were projected from objects. #663
• The |items filter will no longer allocate a list and instead return an iterator. #665
• Fixed a bug that caused lstrip_blocks to act too eager. #674

• minijinja-cli now supports preservation of order in maps. #611
• Fixed an issue where CBOR was not correctly deserialized in minijinja-cli. #611
• Added a lines filter to split a string into lines.
• Bytes are now better supported in MiniJinja. They can be created from Value::from_bytes without having to go via serde, and they are now producing a nicer looking debug output. #616
• Added the missing string filter from Jinja2. #617
• Reversing bytes and convergint them implicitly to strings will now work more consistently. #619
• Added type hints for the Python binding and relaxed maturin constraint. #590
• minijinja-cli now allows the template name to be set to an empty string when --template is used, to allow suppliying a data file. #624
• Added the missing sameas filter from Jinja2. #625
• Tests can now support one argument without parentheses like in Jinja2 (1 is sameas 1). #626
• Added error context for strict undefined errors during template rendering. #627
• Syntax errors caused by the lexer now include the correct position of the error. #630
• minijinja-cli now has all features enabled by default as documented (that means also shell completion and ini). #633
• minijinja-cli now does not convert INI files to lowercase anymore. This was an unintended behavior. #633
• Moved up MSRV to 1.63.0 due to indexmap. #635
• Added argument splatting support (*args for variable args and **kwargs for keyword arguments) and fixed a bug where sometimes maps and keyword arguments were created in inverse order. #642

• Updated version of minijinja-cli with support for better documentation, config file and environment variable support. #602
• minijinja-cli now supports template source passed by parameter for simple cases. #606
• minijinja-cli now has a --syntax-help argument that prints out the primer on the syntax. #607
• minijinja-cli now installs to ~/.local/bin by default. #608
• Made the c-bindings compatible with wasm compilation. #603
• String/Cow<str> argument types will no longer implicitly convert keyword arguments to string form. This was an unintended foot gun. #605

• Fixes a regression in PartialEq / Eq in Value caused by changes in 2.3.0. #584

• Fixes some compiler warnings in Rust 1.81. #575
• Fixes incorrect ordering of maps when the keys of those maps were not in consistent order. #569
• Implemented the missing groupby filter. #570
• The unique filter now is case insensitive by default like in Jinja2 and supports an optional flag to make it case sensitive. It also now lets one check individual attributes instead of values. #571
• Changed sort order of Ord to avoid accidentally non total order that could cause panics on Rust 1.81. #579
• Added a Value::is_integer method to allow a user to tell floats and true integers apart. #580

• Fixes a bug where some enums did not deserialize correctly when used with ViaDeserialize. #554
• Implemented IntoDeserializer for Value and &Value. #555
• Added filesizeformat to minijinja-contrib. #556
• Added support for the loop_controls feature which adds {% break %} and {% continue %}. #558
• Iterables can now be indexed into. It was already possible previously to slice them. This improves support for Jinja2 compatibility as Jinja2 is more likely to create temporary lists when slicing lists. #565

• Flush filter and test cache when processing extended template. This fixes a bug that caused the wrong filters to be used in some cases. #551

• Added indent parameter to tojson filter. #546
• Added randrange, lipsum, random, cycler and joiner to minijinja-contrib. #547
• Added the ability to use &T and Arc<T> as parameters to filters and functions if T is an Object. #548
• minijinja-cli now also enables the datetime, timezone and rand features. #549
• Aligned the behavior of the int filter closer to Jinja2. #549

• minijinja-cli now supports .ini files. #532
• Fixed a bug that caused cycle detection to trigger incorrectly when an included template extended from another template. #538
• Bumped the minimum version of self_cell to 1.0.4. #540
• MiniJinja will now warn if the serde feature is disabled. This is in anticipation of removing the serde dependency in the future. #541
• Improved an edge case with State::resolve. It now can resolve the initial template context in macro calls even if no closure has been created. #542

• Added new methods to pycompat: str.endswith, str.rfind, str.isalnum, str.isalpha, str.isascii, str.isdigit, str.isnumeric, str.join, str.startswith. #522
• Added the missing tests boolean, divisibleby, lower and upper. #592
• minijinja-cli now supports YAML aliases and merge keys. #531

• Implemented sequence (+ some iterator) and string repeating with the * operator to match Jinja2 behavior. #519
• Added the new minijinja::pycompat module which allows one to register an unknown method callback that provides most built-in Python methods. This makes things such as dict.keys work. Also adds a new --py-compat flag to minijinja-cli that enables it. This improves the compatibility with Python based templates. #521
• Added a new |split filter that works like the .split method in Python. #517

• Fixed an issue that caused custom delimiters to not work in the Python binding. #506

This is a major update to MiniJinja that changes a lot of core internals and cleans up some APIs. In particular it resolves some limitations in the engine in relation to working with dynamic objects, unlocks potentials for future performance improvements and enhancements.

It's very likely that you will need to do changes to your code when upgrading, particular when implementing dynamic objects. In short:

• StructObject and SeqObject are gone. They have been replaced by improved APIs directly on Object. Please refer to the updated documentation to see how these objects behave now. For the most part code should become quite a bit clearer during the upgrade.
• ObjectKind has been replaced by ObjectRepr. Rather than holding a reference to a StructObject or SeqObject this now is a simple enum that just indicates how that object serializes, renders and behaves.
• Object no longer uses fmt::Display for rendering. Instead the new Object::render method is used which has a default implementation.
• The Object trait has been completely transformed and the new type-erased type DynObject has been added to work with unknown objects. This trait has an improved user experience and more flexibility. It's now possible to implement any non-primitive value type including maps with non string keys which was previously not possible.
• ValueKind is now non exhaustive and got a log of new value types. This resolves various issues in particular in relationship with iterators. As a result of this functions will no longer accidentally serialize into empty objects for example.
• Value::from_iterator has been replaced by the new Value::make_iterable, Value::make_object_iterable and Value::make_one_shot_iterator. The direct replacement is Value::make_one_shot_iterator but for most uses it's strongly recommended to use one of the other APIs instead. This results in a much improved user experience as it's possible to iterate over such values more than once.
• The Syntax type has been replaced by the SyntaxConfig type. It uses a builder pattern to reconfigure the delimiters.

For upgrade instructions read the UPDATING guide.

Other Changes:

• Added a new Environment::templates method that iterates over loaded templates. #471
• Reverse iteration and slicing now return iterables instead of real sequences.
• The engine no longer reports iterable as sequences.
• The value iterator returned by Value::try_iter now holds a reference to the Value internally via reference counting.
• DynObject now replaces Arc<Object>.
• The debug printing of some objects was simplified.
• Added the iterable test. #475
• The parser no longer panics when using dotted assignments in unexpected places. #479
• The CLI now enables unicode support by default.
• Value::from_serializable is now Value::from_serialize.
• Ranges are now iterables and no longer sequences and their maximum number of iterations was raised to 100000. #493
• Value::from is now implemented for Error as public API to create invalid values. Previously this behavior was hidden internally in the serde support. #495
• UndefinedBehavior::Strict now acts more delayed. This means that now value.key is defined will no longer fail.
• Added support for line statements and comments. #503
• The CLI now accepts --syntax to reconfigure syntax flags such as delimiters. #504

• Fixed an issue with the function bounds that caused the next-generation trait resolver to fail. #790

• Fixed an issue where lstrip_blocks unintentionally also applied to variable expression blocks. #502

• Added support for implicit string concatenation for Jinja2 compatibility. #489
• Added support for sequence concatenation with the plus operator for Jinja2 compatibility. #491

• Deprecated Value::from_iterator and introduced replacement Value::make_one_shot_iterator API which also exists in 2.x. #487

• Fixed an endless loop in undeclared_variables. #486

• Added support for Option<Into<Value>> as return value from functions. #452
• Deprecated Value::from_serializable for the improved replacement method Value::from_serialize. #482

• Tolerate underscores in number literals. #443
• Added support for trim_blocks and lstrip_blocks for Jinja2 compatibility. #447
• Changed API of unstable_machinery. The tokenize function got an extra argument for the WhitespaceConfig. It's however recommended to use the new Tokenizer struct instead. parse_expr was added, the parse function now takes a SyntaxConfig and WhitespaceConfig. #447

• Resolved a compiler warning for Rust 1.77. #440
• Fixed an incorrect error case in call_method. Now UnknownMethod is returned instead of InvalidOperation correctly. #439
• Added Environment::set_unknown_method_callback which allows a user to intercept method calls on primitives. The motivation here is that this can be used to implement python like methods to improve the compatibility with Jinja2 Python templates. #441

• Fixed a bug with broken closure handling when working with nested {% macro %} or {% call %} blocks. #435

• minijinja-cli now supports an -o or --output parameter to write into a target file. #405
• minijinja-cli now accepts the --safe-path parameter to disallow includes or extends from paths not explicitly allowlisted. #432
• Added support for Error::display_debug_info which displays just the debug info, same way as alternative display on the error does. #420
• Added the namespace() function from Jinja2 and the ability to assign to it via {% set %}. #422
• minijinja-autoreload now supports on_should_reload_callback which lets one register a callback to be called just before an auto reload should be performed. #424
• Added support for Value::from_iterator, IteratorObject and ObjectKind::Iterator. #426
• Added support for 0b/0o/0x prefixed integer literals for binary, octal and hexadecimal notation. #433

• The urlencode filter now correctly skips over none and undefined. #394
• The dict function now supports merging in of extra arguments. #395
• Added support for primitive datetimes in the contrib module. #398

• Added Environment::compile_expression_owned to allow compiled expressions to be held without requiring a reference. #383
• Added minijinja-embed crate which provides a simple way to embed templates directly in the binary. #392

• Added int and float filters. #372
• Added integer and float tests. #373
• Fixed an issue that caused the CLI not to run when the repl feature was disabled. #374
• Added -n / --no-newline option to CLI. #375

• Fixed a memory leak involving macros. Previously using macros was leaking memory due to an undetected cycle. #359
• The debug function in templates can now also be used to print out the debug output of a variable. #356
• Added a new stacker feature which allows raising of the recursion limits. It enables monitoring of the call stack via stacker and automatically acquires additional memory when the call stack runs out of space. #354

• Large integer literals in templates are now correctly handled. #353
• Relax the trait bounds of Value::downcast_object_ref / Object::downcast_ref / Object::is and added support for downcasting of types that were directly created with Value::from_seq_object and Value::from_struct_object. #349
• Overflowing additions on very large integers now fails rather than silently wrapping around. #350
• Fixed a few overflow panics: dividing integers with an overflow and
• Exposed missing new functionality for the Python binding. #339

• Added support for keep_trailing_newlines which allows you to disable the automatic trimming of trailing newlines. #334
• Added minijinja-cli which lets you render and debug templates from the command line. #331
• Macros called with the wrong state will no longer panic. #330
• Debug output of Value::UNDEFINED and Value::from(()) is now undefined and none rather than Undefined and None. This was an accidental inconsistency.
• Fixed a potential panic in debug error printing.
• Added Environment::set_path_join_callback and State::get_template to support path joining. This is for greater compatibility with Jinja2 where path joining was overridable. With this you can configure the engine so that paths used by include or extends can be relative to the current template. #328
• The default auto-escape detection now accepts .html.j2 as alias for .html as well as for all other choices. In general .j2 as an extension is now generally supported.

• Fixed iso datetime formatting not handling negative offsets correctly. #327
• Re-report Value directly from the crate root for convenience.
• It's now possible to deserialize from a Value. Additionally the ViaDeserialize<T> argument type was added to support value conversions via serde as argument type. #325

• Added the ability to merge multiple values with the context! macro. (#317)
• Option<T> now accepts none in filters. Previously only undefined values were accepted. This bugfix might have a minor impact on code that relied in this behavior. (#320)
• Fix a compilation error for minijinja-contrib if the timezone feature is not enabled.

• Added the args! macro which can be used to create an argument slice on the stack. (#311)
• Improved error reporting for missing keyword arguments.
• Added chrono support to the time filters in the minijinja-contrib crate.

• Republished 1.0.2 with fixed docs.

• Added TryFrom and ArgType for Arc<str>.
• Added datetimeformat, dateformat, timeformat and now() to the contrib crate. (#309)

• Fixed a bug that caused {% raw %} blocks to accidentally not skip the surrounding tags, causing {% raw %} and {% endraw %} to show up in output. (#307)

• Support unicode sorting for filters when the unicode feature is enabled. This also fixes confusing behavior when mixed types were sorted. (#299)

• Added json5 as file extension for JSON formatter.

• The autoreload crate now supports fast reloading by just clearing the already templates. This is enabled via set_fast_reload on the Notifier.

Note: This also includes all the changes in the different 1.0.0 alphas.

1.0 includes a lot of changes that are breaking. However they should with some minor exceptions be rather trivial changes.

• Environment::source, Environment::set_source and the Source type together with the source feature were removed. The replacement is the new loader feature which adds the add_template_owned and set_loader APIs. The functionality previously provided by Source::from_path is now available via path_loader.

  Old:

  let mut source = Source::with_loader(|name| ...);
  source.add_template("foo", "...").unwrap();
  let mut env = Environment::new();
  env.set_source(source);

  New:

  let mut env = Environment::new();
  env.set_loader(|name| ...);
  env.add_template_owned("foo", "...").unwrap();

  Old:

  let mut env = Environment::new();
  env.set_source(Source::from_path("templates"));

  New:

  let mut env = Environment::new();
  env.set_loader(path_loader("templates"));

• Template::render_block and Template::render_block_to_write were replaced with APIs of the same name on the State returned by Template::eval_to_state or Template::render_and_return_state:

  Old:

  let rv = tmpl.render_block("name", ctx)?;

  New:

  let rv = tmpl.eval_to_state(ctx)?.render_block("name")?;

• Kwargs::from_args was removed as API as it's no longer necessary since the from_args function now provides the same functionality:

  Before:

  // just split
  let (args, kwargs) = Kwargs::from_args(values);
  
  // split and parse
  let (args, kwargs) = Kwargs::from_args(values);
  let (a, b): (i32, i32) = from_args(args)?;

  After:

  // just split
  let (args, kwargs): (&[Value], Kwargs) = from_args(values)?;
  
  // split and parse
  let (a, b, kwargs): (i32, i32, Kwargs) = from_args(values)?;

• The testutils feature and testutils module were removed. Instead you can now directly create an empty State and use the methods provided to invoke filters.

  Before:

  let env = Environment::new();
  let rv = apply_filter(&env, "upper", &["hello world".into()]).unwrap();

  After:

  let env = Environment::new();
  let rv = env.empty_state().apply_filter("upper", &["hello world".into()]).unwrap();

  Before:

  let env = Environment::new();
  let rv = perform_test(&env, "even", &[42.into()]).unwrap();

  After:

  let env = Environment::new();
  let rv = env.empty_state().perform_test("even", &[42.into()]).unwrap();

  Before:

  let env = Environment::new();
  let rv = format(&env, 42.into()).unwrap();

  After:

  let env = Environment::new();
  let rv = env.empty_state().format(42.into()).unwrap();

• intern and some APIs that use Arc<String> now use Arc<str>. This means that for instance StructObject::fields returns Arc<str> instead of Arc<String>. All the type conversions that previously accepted Arc<String> now only support Arc<str>.

• State::current_call was removed without replacement. This information was unreliably maintained in the engine and caused issues with recursive calls. If you have a need for this API please reach out on the issue tracker.

• Output::is_discarding was removed without replacement. This is an implementation detail and was unintentionally exposed. You should not write code that depends on the internal state of the Output.

• Value now implements Ord. This also improves the ability of the engine to sort more complex values in filters. (#295)

• Arc<String> was replaced with Arc<str> in some of the public APIs where this shined through. Support for more complex key types in maps was added. You can now have tuple keys for instance. (#297)

• Removed char as a value type. Characters are now represented as strings instead. This solves a bunch of Jinja2 incompatibilities that resulted by indexing into strings. (#292)

• Marked ErrorKind as #[non_exhaustive].

• Correctly handle coercing of characters and strings. "w" == "w"[0] is now evaluating to true as one would expect.

• The include block now supports with context and without context modifiers but they are ignored. This is mostly helpful to render some Jinja2 templates that depend on this functionality. (#288)

• Added tests true, false, filter, test and filters pprint and unique. (#287)

• Added support for indexing into strings. (#149)

• Added Error::detail which returns the detail help string. (#289)

• Added Error::template_source and Error::range to better support rendering of errors outside of the built-in debug printing. (#286)

• Removed testutils feature. New replacement APIs are directly available on the State.

• Added Template::render_and_return_state to render a template and return the resulting State to permit introspection. Template::render_to_write now also returns the State.

• Added State::fuel_levels to introspect fuel consumption when the fuel feature is in use.

• Removed Source and the source feature. The replacement is the new loader feature and the functionality of the source is moved directly into the Environment. This also adds Environment::clear_templates to unload all already loaded templates. (#275)

• Added Environment::template_from_str and Environment::template_from_named_str to compile templates for temporary use. (#274)

• Removed Kwargs::from_args as this can now be expressed with just from_args. (#273)

• Output no longer reveals if it's discarding in the public API.

• Added Value::call, Value::call_method and Template::new_state. The combination of these APIs makes it possible to call values which was previously not possible. (#272)

• Added Template::eval_to_state. This replaces the functionality of the previous Template::render_block which is now available via State. It also adds support for accessing globals and macros from a template via the State. (#271)

• Removed support for State::current_call. This property wasn't too useful and unreliable. Supporting it properly for nested invocations would require calls to take a mutable state or use interior mutability which did not seem reasonable for this. (#269)

• Updated self_cell and percent-encoding dependencies. (#264)

• Added Template::render_block and Template::render_block_to_write which allows rendering a single block in isolation. (#262)

• Hide accidentally exposed Syntax::compile method.
• Added undeclared_variables methods to Template and Expression. (#250)

• Fixed an issue with autoreload not working properly on windows. (#249)

• Added Value::is_number. (#240)
• TryFrom for Value now converts integers to f32 and f64.
• Added the new custom_syntax feature which allows custom delimiters to be configured. (#245)
• Added Kwargs abstraction to easier handle keyword arguments.
• Fixed an issue that Option<T> was incorrectly picking up none for undefined values.
• The sort filter now accepts reverse, attribute and case_sensitive by keyword argument and sorts case insensitive by default.
• The dictsort filter now supports reversing, by value sorting, and is sorting case insensitive by default.

• The in operator now does not fail if the value is undefined and the undefined behavior is not strict. (#235)
• The Python binding now supports finalizers. (#238)

• Changed the closure behavior of macros to match the one of Jinja2. (#233)
• Value::from_serializable will no longer panic on invalid values. Instead the error is deferred to runtime which makes working with objects possible that are only partially valid for the runtime environment. (#234)

• Added testutils module. (#221)
• Make it more obvious that serde flatten sometimes does not work. (#223)
• Added configurable "undefined" value behavior. (#227)
• Make render!() reuse the hidden environment.

• Resolve bad closure being generated for do blocks. (#219)
• Add support for float number values in scientific notation. (#220)

• Small performance improvements for when preserve_order is used by passing known capacities to the constructor.
• Minor performance improvements to the VM by giving the stack an initial capacity.
• Change the internal representation of spans to use u32 rather than usize for line and column offsets as a small speed improvement during compilation.
• Performance improvements for the key interning.
• Disabled key_interning by default.
• Renamed features multi-template to multi_template and adjacent-loop-items to adjacent_loop_items. The old feature names will hang around until 1.x as legacy aliases.

• Restore compilation on 32bit targets. (#207)

• Added the Jinja2 tests ==, !=, <, <=, >, >= and in for the use with select and reject. (#205)
• String rendering now uses fewer reallocations by setting an initial capacity based on the complexity of the template. (#206)

• Fixed Python bindings not allowing to access dict keys prefixed with an underscore. (#197)
• Added min, max and sort filters. (#199)

• Changed add_global to perform Into<Value> implicitly.
• Added source_mut to retrieve a mutable reference to the source.
• Improved Python bindings by adding support for template reloading, better documentation, error reporting.
• Added pass_state to the Python binding.

• Expose debug flag from environment.
• Added experimental Python bindings.

• Resolve a runtime panic if {% extends %} appears in the template but never is executed.
• Fixed recursion detection for macros.
• Enforce a maximum size of 10000 items on the range output.
• Added fuel tracking support.
• Added none test. (#185)
• Improved various issues with whitespace trimming. (#187)
• Value::default now returns Undefined rather than None.
• Added support for loop.previtem and loop.nextitem. (#188)

• Added capitalize filter. (#163)
• Added support for {% call %}. (#164)
• Added support for {% do %}. (#167)
• Improved testsuite to execute on wasm32-wasi.

• Filters, tests and other functions can now be registered with a dynamically allocated name. (#146)
• Added State::current_call which exposes the name of the currently called item. (#150)
• Introduced revamped object model with SeqObject and StructObject. (#148)
• Object now directly exposes downcast_ref and is.
• Removed Value::as_slice
• Introduced Value::as_seq and Value::as_struct.
• Introduced Value::from_seq_object and Value::from_struct_object.
• Added the ability for function arguments to be of type &dyn SeqObject.
• Renamed Iter to ValueIter.
• Added Environment::render_named_str. (#149)
• Exposed string interning via the intern function.
• Improved support for structs in built-in filters.
• Added indent filter. (#151)
• Added the map, select / selectattr and reject / rejectattr filters.
• Added safe / escaped test.
• Strings now have the same iteration behavior as in Jinja2. (#152)

• The Object model changed significantly in this release. It's now possible for objects to have different shapes (structs or sequences today). As a result SeqObject and StructObject were added to the API. For changing your objects over have a look at the new documentation for Object.
• The Iter type is now called ValueIter.

• Changed Object::attributes to being an iterator. (#138)
• Arc<T: Object> now implements Object. (#139)
• Aligned semantics of top-level template code after extends with Jinja2. (#140)
• Exposed value creation from Arcs. (#141)
• Performance improvements for value conversions and object creation. (#142)
• Align iteration behavior of dynamic objects with maps.

• The attributes method on objects now returns iterators. To make the transition easy change [..] to Box::new([..].into_iter()).

• Added support for recursive macro invocations. (#133)
• Added optional unicode identifier support. (#134)

• Catch divisions by zero.
• Correctly render inf floats.
• Enforce a maximum recursion depth during parsing.
• Added Value::try_iter to iterate over maps and sequences. (#132)

• Added Value::from_function. (#121)
• Fixed incorrect location information with blocks.
• Fixed broken nested super() calls.
• Improve error reporting for failures in blocks and trying to super() when there is no parent block.
• Performance improvements.
• Added support for {% import %} / {% from .. import .. %} and {% macro %}. (#123)
• Added Value::is_kwargs which disambiguates if an object passed to a function or filter is a normal object or if it represents keyword arguments.
• Added the ability to call functions stored on objects.
• Added macros and multi_template features to disable some of the heavier pieces of MiniJinja.
• Fixed an issue that caused trailing commas not to work in lists.

• Fixed an incorrect manifest for minijinja-autoreload.

• Add defined and undefined tests to always be included.
• Removed Source::load_from_path.
• Added Source::from_path.

• Removed Source::load_from_path. Use Source::with_loader instead.

• Added custom autoescape settings.
• Added custom formatters.
• Restructured engine internals for greater clarity.
• Added support for rendering to io::Write. (#111)
• Make it impossible to implement Filter, Test or Function from outside the crate by sealed the traits. (#113)
• Added support for remaining arguments with Rest. (#114)
• Filters, tests and functions can now borrow arguments. (#115)
• Added Value::as_slice and Value::get_get_item_by_index.
• Added support for span error reporting. (#118)
• Greatly improved handling of nested errors. (#119)
• ImpossibleOperation is now InvalidOperation.
• Added support for slice syntax. (#120)

• Filter, Test and Function are now sealed traits.
• ErrorKind::ImpossibleOperation is now ErrorKind::InvalidOperation.
• Moved up MSRV to 1.61.0 due to bugs on older rust versions related to HRTBs.

• Remove internal refcounts from environment.
• Changed Object and FunctionArgs interface to take arguments by reference. (#101)
• sync mode is now always enabled. (#104)
• Removed meta API. (#105)
• Error no longer implements PartialEq.
• Simplified the function interface. Filters, tests and global functions can now directly return values instead of results. (#107)
• MiniJinja no longer silently iterates over non iterable values.

• The meta API is gone without replacement.
• Object::call_method and Object::call now take the arguments as &[Value] instead of Vec<Value>.
• Object::call_method, Object::call and FunctionArgs::from_values now take the arguments as &[Value] instead of Vec<Value>.
• The error object used to implement PartialEq but this was implemented by comparing the error kind instead. Explicitly use the .kind() method of the error if you want the same behavior.
• DebugInfo is no longer exposed. This might come back if a better API can be found.

• Fixed binary subtraction operator requiring a space. (#94)
• Fixed trailing commas not working in function calls. (#95)

• Small internal improvements to context creation. (#79)
• Add support for JSON/YAML/JavaScript Escaping. (#82)
• Add missing escape support for single quotes ('). (#81)
• Added support for newlines in string literals. (#85)
• Added support for block assignment syntax. (#86)
• Added string concatenation with + for Jinja compat. (#87)
• Enable debug mode by default in debug builds. (#88)
• Added render! macro and render_str. (#89)
• Fixed an issue where trailing whitespace removal did not work on blocks. (#90)
• Added loop.changed() method. (#91)

• Fixed a bad dependency declaration.

• Improved debug printing of context.
• Added -, _ and . to set of unescaped characters in urlencode. (#72)
• Bumped v_htmlescape dependency. (#74)

• Added support for {% raw %}. (#67)
• Minimum Rust version moved up to 1.45.
• Added support for {% set %}. (#70)

• Added support for unpacking in with blocks. (#65)

• Bumped minimum version requirement to 1.43.
• Internal refactorings.
• Added support for fully dynamic loading via Source::with_loader.
• Renamed get_source to source.

• Fixed or expressions not working properly.

• Added bool filter.
• Added meta API. (#55)
• Added support for ignore missing in include tags. (#56)
• Added support for choices in include tags. (#57)

• Removed deprecated functionality.
• Fix an panic in debug error printing. (#49)

• Deprecated Primitive and as_primitive.
• Deprecated as_f64.
• Truthiness of values is now checking container length. Previously containers were always true, now they are only true if they are not empty.
• Strings and safe strings no longer compare the same.
• Changed list and map string output to have delimiters and debug printing.
• Added batch and slice filter.
• Added the new items filter.
• Removed value internal distinction between maps and structs.
• Added list filter.
• Added first and last filters.
• Added round and abs filters.
• Implemented integer division operator (//) and changed division to always return floats like documented and to match the Jinja2 implementation. To make this more convenient whole integer floats are now handled like integers in some situations.
• Added recursive support to for loops.
• Merged builtin_filters, builtin_tests and builtin_functions features into builtins.
• Added value::serializing_for_value to check if serialization is taking place for MiniJinja.
• The Value type now supports deserialization. This feature can be disabled by removing the default deserialization feature.
• Removed optional memchr dependency as it does not appear to be useful.

Yanked — this was a release from the wrong branch

• Restructured the value type internally to be simpler and not use unsafe at the cost of slightly larger memory footprint. (#30)
• Added debug support. If the debug mode is enabled, errors now carry a lot of useful debug information and an alternative representation when formatted into strings that show the context of the template where it went all wrong. (#31)
• Added automatic string interning of object/map keys in values. This feature can be disabled by removing the default key_interning feature. (#35)
• Removed deprecated Single type.

• Remove one trailing newline to be consistent with Jinja2.
• Resolved a bug where borrowed keys on dynamic objects could not be looked up. (#29)

• Restored unconditional compatibility with 1.42.

• Turned on all features for the docs on docs.rs

• Added context! and deprecate Single.
• Correctly report template file names in errors.
• Added the source method on templates.
• Introduced State type and changed parameter to functions from &Environment to &State.
• Added debug global.
• Added tojson filter.
• Added urlencode filter.

• Made the source method on error be bound to Send and Sync.

• Added default filter.
• Added startingwith and endingwith tests.
• Added global variables and function support.
• Added range function.
• Added dict function.
• Fixed panic caused by super() calls outside of blocks.
• Added Error::with_source method.
• Added object abstraction.
• Added keyword arguments to function and filter invocations.
• Added Jinja2 filter aliases e, d and count.

• Added support for rustc 1.41.0
• Added v_htmlescape feature to turn on a faster HTML escaping.
• Export HtmlEscape helper.
• Also escape / in HTML escaping like v_htmlescape does.
• Changed return value type of get_template to be a result rather than an option.
• Added Source behind the source feature to support loading of templates at runtime without lifetime complications.
• Initial auto escaping decision is now made when the template is loaded from the environment and not when they are added.
• The environment can now be cloned.
• Added sync feature that can be disabled to disable the ability to send objects to other threads where that comes at a cost.
• safe and escape are now always provided as filters.
• Added support for self.block_name().
• Fixed incorrect behavior where super() did not allow filters.
• Added {% filter %} blocks.
• Added value::Single type to render simple templates with a single value passed.

• Added the ability to roundtrip arbitrary values via the serialize interface.
• Added support for tuple unpacking in lists.
• Added dictsort filter.
• Introduced a new trait ArgType to handle argument conversions for filters and tests so optional arguments can exist.
• Renamed ValueArgs trait to FunctionArgs.
• Added reverse filter.
• Added trim filter.
• Added join filter.
• Added number test.
• Added string test.
• Added sequence test.
• Added mapping test.
• Added builtin_filters and builtin_tests features to disable the built-in filter and test functions.
• Added is not syntax for negated tests.
• Added else block to for loops.
• Added if condition expression to for loops.
• Fixed a bug that caused or/and not to evaluate correctly in certain situations.
• Added in and not in expressions.
• Added inline if expressions.

• Added support for {% include %}
• Resolved a bug that caused with blocks to fully shadow the outer scope.
• Improved documentation in the crate.

• Added support for rustc versions down to 1.42.0

• Initial release of the library