Using MiniJinja Templates for Dynamic Web Pages with Rust's Axum Server

July 2026

I use Axum^axum to power a local admin server for this site. It's provides reports on the site's current build state and various CRUD operations to manage content. These tools are Server Side Rendered^ssr using the MiniJinja^mj template engine.

MiniJinja sets up an initial environment before rendering templates. I use axum's `State` to load and store the environment for the admin server when it initializes. Without that, it would have to initialize on every page request.

Here's what the setup looks like:

Files

Cargo.toml

[package]
name = "minijinja_templates"
version = "0.1.0"
edition = "2024"

[dependencies]
anyhow = "1.0.103"
axum = "0.8.9"
chrono = "0.4.45"
minijinja = { version = "2.21.0", features = ["custom_syntax", "debug"] }
tokio = { version = "1.52.3", features = ["macros", "rt-multi-thread"] }

src/main.rs

use anyhow::Result;
use axum::extract::State;
use axum::http::StatusCode;
use axum::{Router, response::Html, routing::get};
use chrono::offset::Utc;
use minijinja::syntax::SyntaxConfig;
use minijinja::{Environment, Value, context, path_loader};
use std::sync::Arc;

struct AppState {
  env: Environment<'static>,
}

#[tokio::main]
async fn main() -> Result<()> {
  let env = get_env()?;
  let app_state = Arc::new(AppState { env });
  let app = Router::new()
    .route("/", get(handle_home))
    .with_state(app_state);
  let listener = tokio::net::TcpListener::bind("127.0.0.1:3737")
    .await
    .unwrap();
  println!("listening on {}", listener.local_addr().unwrap());
  axum::serve(listener, app).await?;
  Ok(())
}

fn date() -> Value {
  let d = Utc::now();
  Value::from_safe_string(format!("{}", d))
}

fn get_env() -> Result<Environment<'static>> {
  let mut env = Environment::new();
  env.set_syntax(
    SyntaxConfig::builder()
      .block_delimiters("[!", "!]")
      .variable_delimiters("[@", "@]")
      .comment_delimiters("[#", "#]")
      .build()
      .unwrap(),
  );
  env.set_loader(path_loader("templates"));
  env.add_function("date", date);
  Ok(env)
}

async fn handle_home(
  State(state): State<Arc<AppState>>
) -> Result<Html<String>, StatusCode> {
  let context = context!(id => "home page");
  render("index.html", context, State(state))
}

fn render(
  template: &str,
  context: Value,
  State(state): State<Arc<AppState>>,
) -> Result<Html<String>, StatusCode> {
  let template = match state.env.get_template(template) {
    Ok(t) => t,
    Err(e) => {
      println!("ERROR: {}", e);
      return Err(StatusCode::INTERNAL_SERVER_ERROR);
    }
  };
  match template.render(context) {
    Ok(r) => Ok(Html(r)),
    Err(e) => {
      println!("ERROR: {}", e);
      Err(StatusCode::INTERNAL_SERVER_ERROR)
    }
  }
}

templates/index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  </head>
  <body>
    <h1>[@ date() @]</h1>
  </body>
</html>

Notes

I'm using the anyhow crate to make error handling easier between MiniJinja and file system calls. It's not necessary for the Axum/MiniJinja functionality.
I split creation of the MiniJinja environment to its own function. The env.set_loader() line uses a target directory for template storage.

The env.set_syntax() call configures MiniJinja for my preferred setup (e.g. using [@ @] and the like instead of {{ }} for tokens since I find they make the page easier to read.
I also split rending to its own render function. Any number of handlers (e.g. handle_home) can use it by setting up a context and passing it along with a template name and the state to get the rendered content back.

The render() function throws an 500 Internal Server Error if there's a problem.
The date() function is defined in the Rust file and run every time the template renders so the value is updated for every page load.

Wrap-Up

I'm really happy with this approach. MiniJinja offers a ton of functionality out of the box. One of those features is creating custom functions. The ability to call those functions each time the page is requested is to populate the template covers every scenario I can think of.

-a

end of line

Footnotes

axum Rust's axum crate provides the HTTP routing and request handling needed to build a web server that hosts dynamic pages. It reminds me a lot of Python's Flask project.
ssr Server Side Rendering is when a server builds the response for each request dynamically when the request arrives. An alternate approach is Static Site Generation which pre-builds all the pages prior to any requests. When one comes in, the server responds with the pre-built payload. It's faster and uses fewer resources and the cost of not being able to customize the responses for each request. (There are, of course, hybrid approaches as well.)
mj MiniJinja is the Rust version of Python's Jinja2 template engine. It provides looping, conditionals, and functions to render pages. It's fantastic.