JavaScript Templating Engines: Which Ones Still Matter in 2026?

JavaScript Templating Engines in 2026: Which Ones Still Matter?

JavaScript templating engines have been around since the early days of Node.js, and their relevance in 2026 is a genuine question. React, Vue, and Svelte dominate client-side rendering. Server-side rendering frameworks like Next.js and Nuxt handle full-stack needs. So who still uses templating engines, and why?

The answer: millions of developers. EJS and Handlebars each pull roughly 40 million npm downloads per week. Shopify’s Liquid powers millions of storefronts. Pug remains the go-to for teams that despise writing HTML angle brackets. Templating engines thrive where you need server-rendered HTML without the overhead of a full frontend framework — email templates, static site generators, admin panels, CMS themes, and multi-page applications that do not need client-side interactivity.

For broader industry context, see our web development statistics report.

Templating Engine Comparison Table

Engine	Last Updated	npm Weekly Downloads	Syntax Style	Server / Client	Use Case
EJS	2026	~40M	Embedded JS (<%= %>)	Both	Express apps, quick server rendering
Pug	2026	~3.5M	Indentation-based (no HTML tags)	Both	Teams who prefer concise markup
Handlebars	2026	~40M	Mustache-compatible ({{ }})	Both	CMS themes, email templates
Nunjucks	2023	~3.4M	Jinja2-like ({% %})	Both	Static site generators (11ty)
Liquid	2026	~2M (LiquidJS)	Shopify-style ({{ }} / {% %})	Server	Shopify themes, Jekyll
Mustache	2021	~17M	Logic-less ({{ }})	Both	Simple token replacement, multi-language
doT.js	2019	~750K	Custom delimiters ({{ }})	Both	Performance-critical rendering
Eta	2026	~7M	EJS-compatible (<%= %>)	Both	Modern EJS replacement, TypeScript-native

EJS (Embedded JavaScript)

EJS is the most popular templating engine by download count and the default choice for Express.js applications. Its syntax embeds JavaScript directly in HTML using <%= %> for output and <% %> for logic. There is almost no learning curve if you know JavaScript and HTML — the template is just HTML with JavaScript sprinkled in.

EJS compiles templates to plain JavaScript functions, which means excellent runtime performance. It supports partials (<%- include('header') %>), layouts via community packages, and works identically on server and client. The downside: EJS templates can become messy because the syntax encourages mixing logic and presentation. There are no built-in layout or block inheritance features — you need workarounds or plugins for those.

Strength	Weakness
Zero learning curve for JS developers	No built-in layout inheritance
Huge ecosystem, tons of tutorials	Easy to write spaghetti templates
~40M weekly downloads	Three major versions in 2026 (v4 to v6), so read the release notes before upgrading
Works with any framework	No compile-time type checking

Pug (formerly Jade)

Pug replaces HTML’s angle bracket syntax with indentation-based markup. A div.container in Pug compiles to <div class="container"></div>. This brevity appeals to developers who find HTML verbose, and Pug templates are typically 30-40% shorter than equivalent HTML. Pug also includes built-in mixins, template inheritance, conditionals, and iteration — a complete templating toolkit.

The trade-off is readability for newcomers and designers. Anyone comfortable with HTML will find Pug’s syntax foreign. Whitespace sensitivity means indentation errors cause silent rendering bugs. And Pug’s compilation step is noticeably slower than EJS or Handlebars, though this only matters during development with large template sets.

Strength	Weakness
Dramatically less markup to write	Steep learning curve for non-developers
Built-in mixins, inheritance, filters	Whitespace-sensitive (indentation bugs)
Strong Express.js integration	Slower compilation than alternatives
Still patched (3.0.4 in 2026), ~3.5M weekly downloads	Designers cannot edit templates directly

1. Handlebars

Handlebars extends the Mustache templating language with helpers, partials, and block expressions while maintaining backward compatibility with Mustache templates. Its “logic-less” philosophy keeps templates clean by pushing complex logic into helper functions defined in JavaScript. This separation makes Handlebars templates the most readable option for content-focused rendering.

Handlebars shines in email templating (SendGrid’s dynamic templates use Handlebars syntax), CMS theming (Ghost uses Handlebars), and any context where non-developers need to edit templates safely. The precompilation feature converts templates to JavaScript functions at build time, eliminating runtime parsing overhead.

Strength	Weakness
Clean, readable templates	Limited built-in helpers (needs custom helpers for most logic)
Precompilation for performance	Verbose for complex conditionals
Safe for non-developer editing	No inline JavaScript expressions
Mustache-compatible	Ecosystem feels stagnant compared to newer options

2. Nunjucks

Nunjucks is Mozilla’s JavaScript port of Python’s Jinja2 templating engine. If you have worked with Django, Flask, or Ansible templates, Nunjucks will feel immediately familiar. It features template inheritance ({% extends %}), blocks, macros, filters, and auto-escaping — a complete feature set that rivals Pug without the custom syntax.

Nunjucks is one of the most widely used template languages in Eleventy (11ty), the popular static site generator, although Eleventy’s default engine for HTML and Markdown files is Liquid. This ecosystem connection keeps Nunjucks relevant, but note that its last npm release (3.2.4) shipped in 2023. Its macro system is particularly powerful — you can define reusable template components with arguments, similar to React components but in pure HTML.

3. Liquid

Liquid was created by Shopify and powers every Shopify storefront theme. It also drives Jekyll (GitHub Pages’ default static site generator) and is the default template engine in Eleventy, through the LiquidJS port. Liquid’s distinguishing feature is safety — it is designed to be run on servers with untrusted template code, so it sandboxes template execution and prevents file system access or arbitrary code execution.

For Shopify developers, Liquid is non-negotiable — it is the only way to build themes. Outside Shopify, Liquid competes with Nunjucks and Handlebars for general-purpose server rendering. Its filter-based syntax ({{ "hello" | upcase }}) is intuitive and reads left-to-right, making templates easy to follow even for non-programmers.

4. Mustache

Mustache is the original “logic-less” template engine. It has implementations in over 40 programming languages, making it the best choice when the same template needs to render in JavaScript, Ruby, Python, Go, and other languages. The spec is frozen — Mustache templates written in 2012 work identically today.

Mustache’s simplicity is both its strength and limitation. There are no if/else statements, no loops, no expressions — only sections ({{#list}}...{{/list}}) that iterate arrays or toggle on boolean values. Everything else must be pre-computed in the view model. This forces clean data preparation but frustrates developers who need even basic conditional logic.

5. doT.js

doT.js is the fastest JavaScript templating engine in benchmarks. It achieves this by compiling templates to raw JavaScript functions with minimal overhead — no virtual DOM, no safety wrappers, no helper resolution. If you need to render thousands of templates per second (real-time data dashboards, log viewers, high-frequency server responses), doT.js is measurably faster than alternatives.

The trade-off: doT.js has a minimal feature set and sparse documentation, its last stable release (1.1.3) dates to 2019, and the 2.0 beta never shipped as stable. It is a surgical tool for performance-critical rendering, not a general-purpose engine. Use it when benchmarks prove other engines are too slow — not as a default choice.

6. Eta

Eta is the modern successor to EJS. It uses the same <%= %> syntax but is written in TypeScript, supports async/await natively, handles layouts and partials without plugins, and weighs about 3.5 KB minzipped (the minified EJS browser build is roughly 8 KB gzipped). Eta 4 shipped in 2025, the project is actively maintained, and it adds features EJS lacks: automatic caching, file handling, custom delimiters, and a plugin system.

If you are starting a new project and leaning toward EJS, consider Eta instead. It covers every common EJS use case while adding TypeScript support and better error messages. The migration from EJS to Eta is straightforward but not zero-effort: the tags look the same, but template data is read from it and raw output uses <%~ %> instead of <%- %>.

When to Use a Templating Engine vs React/Vue

This is the question every developer faces in 2026. The answer depends on what your application needs from the browser.

Scenario	Best Choice	Why
Content site, blog, documentation	Templating engine (Nunjucks, EJS)	Server-rendered HTML is simpler and faster for read-heavy pages
E-commerce storefront	Liquid (Shopify) or templating + HTMX	Server rendering with minimal client JS for speed
Admin dashboard with real-time data	React/Vue/Svelte	Complex client-side state management needed
Email templates	Handlebars, MJML, EJS	Email clients do not run JavaScript
Static site generation	Liquid or Nunjucks (11ty), Liquid (Jekyll)	Build-time rendering, zero runtime JS
Multi-language backend	Mustache	Same templates work in any language
Node.js API returning HTML fragments	EJS or Eta	Lightweight, no framework overhead
Full SPA with complex interactions	React/Vue/Svelte	Component model, state management, routing
Server-rendered app with islands of interactivity	Templating + HTMX or Alpine.js	Server rendering for most pages, JS only where needed

The resurgence of server-side rendering frameworks like HTMX, Hotwire, and LiveView has actually increased the relevance of templating engines. These tools generate HTML on the server and swap it into the page — exactly what templating engines are built for. An Express + EJS + HTMX stack can build surprisingly interactive applications without a single React component.

Migration Paths

If you are maintaining an older project with one of these engines and considering migration, here is the practical reality of each path.

From	To	Difficulty	Notes
EJS	Eta	Easy	Same tag style; switch data to it and raw output to <%~ %>
Mustache	Handlebars	Easy	Handlebars is Mustache-compatible
Jade	Pug	Trivial	Rename, same syntax
Any engine	React/Vue	Full rewrite	Fundamentally different paradigm
Nunjucks	Liquid	Moderate	Similar syntax, different filter/tag names
Any engine	HTMX + same engine	Low	Add HTMX attributes, keep existing templates

The Bottom Line

Templating engines are not going away. They serve a different architectural niche than component frameworks, and that niche — server-rendered HTML with minimal client JavaScript — is actually growing thanks to the HTMX and “HTML over the wire” movement. For new projects, Eta is the best general-purpose choice (modern, fast, TypeScript-native). For static sites, Nunjucks with Eleventy is the strongest ecosystem. For Shopify, Liquid is the only option. And for email templates, Handlebars remains the industry standard.

The worst choice is picking a framework like React when a templating engine would suffice. If your page does not need client-side interactivity, server-rendering with a template engine will be faster to build, faster to load, and easier to maintain.