Benchmarks

We render the same pages with Kiln and 7 other JavaScript template engines, and time how long each engine takes to render each page. Each page is something a real site renders, from a blog post to an admin table. Together they cover the template features sites use most. We didn't pick them because Kiln does well on them.

Longer bars are faster, and the fastest engine is listed first. The last run was on 17 October 2026, with Node 24.22.0 on Apple M4 Pro. Read how the benchmark works before you compare engines.

Blog post

A full article page: a layout with blocks, header and footer partials, trusted body HTML, related posts and twenty escaped comments.

Uses: Layouts, Partials, Loops, Conditionals, Escaping, Dates

CMS landing page

A page built from ten content sections, where each section's type picks the partial that renders it.

Uses: Dynamic partials, Nested loops, Conditionals, Prices

Product grid

A shop category page that renders a product card component 48 times, with sale prices, badges and star ratings.

Uses: Components, Slots, Loops, Prices

Data table

An admin table with 500 rows and 6 columns. Mostly loop and output speed.

Uses: Large loops, Loop variables, Escaping

Search results

25 search results that run text through filters: truncate, join, sort, case changes, defaults, URL encoding and number formatting.

Uses: Filters, Defaults, URL encoding

Async data

A blog index that loads its own posts, categories and each post's author by calling async functions from the template.

Uses: Async functions, Loops

CMS data

A blog post from a headless CMS. The page loads its post and the latest posts, and the layout loads the header and footer menus. Each call waits 2 ms, as a database query would.

Uses: Async functions, Layouts, Partials

First render

The blog post page from a cold start: create the environment, compile every template and render once. This is what a serverless cold start or a template edit in a CMS costs.

Uses: Parsing, Compiling

How the benchmark works

• Same HTML. Before timing anything, every engine renders every page and the benchmark checks the HTML matches Kiln's. Only whitespace and the way quotes are escaped may differ. An engine can't win by doing less work.
• Idiomatic templates. Each engine's templates use its own way of doing things: its layouts, partials, components or macros, and its built-in filters. Where an engine has no built-in for something, such as formatting a price, it gets a small helper with the same output, as its users would add.
• Production set-up. Templates are compiled once and cached, output is HTML-escaped, and templates load from memory, so no time goes on reading files. Engines with a synchronous API use it, except in the async data page.
• Separate processes. Each engine runs in its own Node process, so one engine can't slow another down. Each page is rendered for 250 ms to warm up, then timed for 1,000 ms with tinybench. Time per render is the mean of every timed render. Renders per second is 1,000 divided by that time in milliseconds.
• Async data. Handlebars and Pug have no way for a template to wait for a promise, so they sit out the async data and CMS data pages. On the async data page, the async functions resolve straight away, so it measures the cost of waiting, not of fetching data.
• CMS data. Each data function waits 2 ms before it returns, about as long as a query to a database near the server takes. Kiln runs calls that don't depend on each other at the same time, so the page's two documents and the layout's two menus all load at the same time. Eta templates are JavaScript, so its templates start calls together with Promise.all. The other engines wait for each call to finish before they start the next. On a real site, the difference depends on where the data comes from, how long each call takes and how many calls a page makes.
• Precompiled Kiln. Kiln renders precompiled templates, as its docs recommend for the templates in your codebase. The benchmark precompiles them before timing starts, as a site's build would.
• First render. This page times creating an environment, compiling every template and rendering once. A serverless cold start, or editing a template in a CMS, costs about this much. Kiln compiles from source here, as it does for a template edited in a CMS.

The templates for every engine are in packages/benchmarks/templates. If you know a faster way to write one of them in its engine, please open a pull request.

Reading the results

• Numbers depend on the machine. Compare engines within one run, not with numbers from another computer.
• Nunjucks, Handlebars, EJS, Eta and Pug turn templates into JavaScript and run it with new Function. That makes compiled templates fast. But Cloudflare Workers blocks new Function, so on Workers those engines need a build step that compiles templates ahead of time. Kiln generates JavaScript only when you precompile at build time, so the same templates run on Workers. LiquidJS and Twing don't generate code.
• Kiln runs with its defaults, including strict mode, which checks every variable and property a template reads.

Run it yourself

From the root of the repository:

npm install
npm run bench

This builds Kiln, checks every engine's output, runs the benchmark and writes packages/benchmarks/results.json, which this page reads. A full run takes about two minutes.