MiniJinja

MiniJinja is a template engine for Rust that reimplements the core of Jinja2 (the templating language used by Python’s Jinja/Django ecosystems) with minimal dependencies and no requirement on a Python runtime. It targets applications that need Jinja-style templates — variable substitution, filters, control flow, macros, template inheritance — embedded directly in a Rust binary, or shared across a polyglot codebase where Python, Rust, JavaScript, and Go components all need to render the same templates.

The project is a single Cargo workspace with the core minijinja crate at its center, plus a family of companion crates (a CLI, Python/Go/JS bindings, a C ABI, autoreloading, and framework helpers) that all build on the same compiler and virtual machine, giving it unusually broad interoperability for a Rust templating library.

What You Get

• A Jinja2-compatible template syntax (expressions, filters, tests, control flow, macros, template inheritance, loops) implemented as a lexer, parser, compiler, and bytecode VM
• An optional loader feature for loading templates from the filesystem, plus serde integration for rendering directly from Rust structs/enums
• A companion minijinja-cli binary for rendering templates from the command line without writing any Rust code
• Official bindings for Python (minijinja-py), JavaScript/WASM (minijinja-js), and Go (minijinja-go), plus a C ABI crate (minijinja-cabi) for embedding in other languages
• A minijinja-contrib crate with extra filters/functions (e.g. Pycompat-style helpers) not in Jinja2 core, and minijinja-autoreload for live template reloading during development

Common Use Cases

• Rendering HTML pages, emails, or config files from Jinja-style templates inside a Rust web service, without shelling out to Python
• Sharing a single set of Jinja templates between a Python backend and a Rust service via the matching syntax/semantics
• Embedding a lightweight templating layer in a CLI tool via minijinja-cli for generating text output from data files
• Using MiniJinja from Python via its own bindings as a faster or more restricted alternative to Jinja2 for specific workloads

Under The Hood

Architecture - The core minijinja crate (minijinja/src/lib.rs) implements a classic compiler pipeline under compiler/ — lexer, parser producing an AST, and a compiler emitting bytecode — executed by a stack-based virtual machine in vm/. Values are represented through a dedicated value module supporting dynamic typing compatible with Serde’s data model, and environment.rs/template.rs tie parsing, compilation, and rendering together behind an Environment/Template API. The repository is a Cargo workspace with sibling crates (minijinja-cli, minijinja-py, minijinja-js, minijinja-go, minijinja-cabi, minijinja-contrib, minijinja-autoreload, minijinja-embed) that all depend on the core crate, giving one compiler/VM implementation multiple language front ends.

Tech Stack - Rust 2021 edition, MSRV 1.70, with an extensive Cargo feature-flag system (builtins, debug, deserialization, macros, multi_template, preserve_order, unicode, custom_syntax, fuel) letting consumers opt in/out of functionality to control binary size and dependency footprint. Optional dependencies include serde for value conversion, indexmap for order-preserving maps, and aho-corasick/unicase/unicode-ident for custom syntax and Unicode-aware identifiers.

Code Quality - The core crate has an extensive tests/ directory with dedicated suites per subsystem (test_vm.rs, test_compiler.rs, test_lexer.rs, test_parser.rs, test_value.rs, test_deserialization.rs, test_macros.rs, test_loader.rs, test_fuel.rs, and more), plus a fuzz/ directory for fuzz testing the parser/compiler. COMPATIBILITY.md explicitly documents deviations from Jinja2, and a HUMAN_VS_MACHINE.md doc tracks AI-authored contributions, showing active maintenance discipline from maintainer Armin Ronacher (creator of Flask and Jinja2) across 79 contributors.

API Design - The primary API mirrors Jinja2’s Environment/Template model closely enough that developers coming from Python’s Jinja2 or Django templates can be productive immediately; add_template/get_template/render map directly onto familiar concepts. A fuel feature exposes execution-step limiting for safely rendering untrusted templates, and custom_syntax lets consumers redefine delimiters, showing attention to embedding use cases beyond simple templating.