Eleventy

What Is Eleventy?

Eleventy, often written as 11ty, is a simpler, flexible JavaScript-based static-site generator. It takes a directory of templates and content, processes them, and outputs a fast, plain static website made of HTML, CSS, and JavaScript. Its guiding philosophy is minimalism and freedom: Eleventy does not impose a client-side framework, does not ship JavaScript to the browser by default, and lets you write content and templates in whichever of many supported languages you prefer.

Eleventy was created by Zach Leatherman and is released as open source under the MIT license. It is built on Node.js and is frequently described as a leaner, lower-overhead alternative to heavier generators, particularly those tied to a specific front-end framework. Its appeal grew alongside the broader interest in fast, lightweight websites and the "ship less JavaScript" movement, and it has become a well-regarded choice among developers who want full control over their output without framework lock-in.

Categorizing Eleventy precisely matters: it is a static-site generator and build tool, not a hosted platform, a content-management system, or a browser extension. You run Eleventy locally or in a build pipeline; it reads your source files and writes static output; and you deploy that output to any static host or CDN. Crucially, the websites Eleventy produces are just files, so at runtime there is no Eleventy code on the server or in the browser unless you explicitly add your own JavaScript.

That last point shapes how Eleventy is detected. Unlike framework-based generators that leave a recognizable runtime fingerprint in the browser, an Eleventy site can look like any other hand-built static site, because that is essentially what it is. As a result, detecting Eleventy specifically is harder and more probabilistic than detecting, say, a React-based generator, and it leans on subtler, more circumstantial signals rather than a definitive runtime marker. We will be candid about that throughout this profile rather than overstate the certainty of any single clue.

Understanding Eleventy's "zero-JavaScript by default" stance explains much of its character. Many popular site generators are built on a front-end framework and therefore ship that framework's runtime to every visitor, even for a page that is entirely static text. Eleventy inverts this: it does its work at build time and emits clean HTML, adding client-side JavaScript only where you choose to write it. For content sites, blogs, and documentation, where interactivity is limited, that produces exceptionally lean, fast pages, which is the core reason performance-minded developers reach for it.

How Eleventy Works

Eleventy runs at build time on Node.js. You point it at a source directory, and it scans for template and content files, processes each one through the appropriate template engine, and writes the rendered HTML to an output directory (by default _site). There is no long-running server in production; the result is a static bundle ready to upload to any host.

Eleventy's signature strength is its support for many template languages out of the box. It can process Nunjucks, Liquid, Handlebars, Markdown, plain HTML, EJS, Mustache, and JavaScript template literals, and you can even mix multiple languages in the same project, or pre-process Markdown with a templating engine. This flexibility means teams can use the syntax they already know rather than learning a new framework's conventions. Markdown is especially common for content, with a templating language handling layouts and reusable partials.

Content and configuration flow through a few clear mechanisms. Front-matter at the top of a file supplies per-page data such as title, layout, tags, and custom fields. Data files (JavaScript or JSON) provide global or directory-scoped data that templates can reference, and they can fetch from APIs at build time to pull in external content. Collections group content by tags, so you can, for example, list every post tagged "blog" on an index page. Layouts wrap content in shared page chrome, and they can be chained so a post layout nests inside a base layout. A configuration file (.eleventy.js) lets you register custom filters, shortcodes, plugins, and collections, and adjust input and output directories.

When you run the build, Eleventy resolves data, applies layouts, runs each template through its engine, and emits static files, optionally running plugins for tasks like image optimization, syntax highlighting, RSS feed generation, or navigation building. Because the output is plain static assets, deployment is trivial: teams publish to Netlify, Vercel, GitHub Pages, Cloudflare Pages, or any object storage behind a CDN, and the site loads quickly with no server-side processing per request.

A start-to-finish example makes the workflow tangible. A developer building a blog creates a posts/ folder of Markdown files, each with front-matter for its title and date and a tag of "post." They write a base layout in Nunjucks containing the site header and footer, and a post layout that nests inside it. An index template uses a collection to list every "post," newest first. A data file might pull the site's social links from a JSON file so they are defined once. Running Eleventy produces a _site directory of finished HTML pages, which the developer deploys to a static host. To add a newsletter signup or a bit of interactivity, they write a small amount of their own JavaScript, included only on the pages that need it. The end result is a fast, lean site whose every page is plain HTML, assembled exactly the way the developer specified, with no framework runtime along for the ride.

How to Tell if a Website Uses Eleventy

This is the section where honesty matters most. Because Eleventy outputs plain static files and ships no runtime by default, it leaves no definitive client-side fingerprint the way a framework-based generator does. Detecting Eleventy specifically is therefore probabilistic and relies on circumstantial signals rather than a single reliable marker. StackOptic weighs these server-side clues together, and you can look for the same ones by hand, but treat a positive result as "likely" rather than "certain" unless a generator tag is present.

Generator meta tag (when present). The most reliable signal exists only when the site author opts in: a <meta name="generator" content="Eleventy ..."> tag, sometimes including a version, which Eleventy can emit via its data cascade. When you find it, detection is essentially confirmed. Many Eleventy sites, however, omit it.

Absence of a framework runtime. An Eleventy site typically loads no React, Vue, Angular, or similar framework bundle, and may ship little or no JavaScript at all. Clean, framework-free static HTML is consistent with Eleventy, though it equally fits other minimalist generators and hand-coded sites, so this is supporting evidence, not proof.

Build and deploy hints. Eleventy sites are very commonly deployed to static hosts and CDNs (Netlify, Vercel, Cloudflare Pages, GitHub Pages). Server and CDN headers indicating static hosting, combined with framework-free HTML, raise the probability, but again do not confirm Eleventy specifically.

Project conventions and source hints. On rare occasions a site exposes its source or build artifacts (for example a public repository, a sourcemap, or comments) that reference Eleventy, _site, .eleventy.js, or Eleventy plugins. These are strong when present but unusual on a finished production site.

Method	What to do	What it can reveal about Eleventy
View Source	"View Page Source" and search for "Eleventy"	A generator meta tag if the author included one; otherwise clean static HTML
curl -s	curl -s https://example.com | grep -i eleventy	The generator tag when present; confirms framework-free markup
Browser DevTools	Check the Network tab for framework bundles	Absence of React/Vue/Angular runtimes (supporting, not conclusive)
Wappalyzer	Run the extension on the live page	May identify "Eleventy" when a generator tag or known pattern is present
BuiltWith	Look up the domain	Lists Eleventy when detectable, plus hosting and CDN context

A practical first step is curl -s https://example.com | grep -i 'content="Eleventy'. A match is a confident yes; no match simply means the strongest signal is unavailable and you must reason from weaker, circumstantial clues. For the broader methodology, see our guides on how to find out what technology a website uses and how to find out where a website is hosted. Confirming the hosting and CDN profile via how to read a website's HTTP headers often adds useful context.

It is worth restating the limitation plainly, because it is a feature of Eleventy rather than a gap in any tool. The whole point of Eleventy is to disappear at runtime and leave behind a site indistinguishable from one a developer wrote by hand. That makes Eleventy genuinely harder to fingerprint than framework-coupled generators, and any responsible detection should reflect that uncertainty instead of inventing a signal. Where a generator tag exists, identification is straightforward; where it does not, the honest conclusion is a probability based on the convergence of framework-free output, static-host headers, and any incidental source references, rather than a false claim of certainty. Server-side analysis that reads the raw HTML is well suited to catching the generator tag and characterizing the output, while remaining appropriately cautious when the definitive marker is absent.

Key Features

• Many template languages. Nunjucks, Liquid, Handlebars, Markdown, EJS, Mustache, HTML, and JavaScript, mixable in one project.
• Zero client-side JavaScript by default. Ships clean HTML and adds JS only where you explicitly write it.
• Flexible data cascade. Front-matter, directory data, and global data files (including build-time API fetches) feed templates.
• Collections and tags. Group and list content easily for blogs, portfolios, and documentation.
• Plugin ecosystem. Official and community plugins for image optimization, RSS, syntax highlighting, navigation, and more.
• No framework lock-in. Output is plain static files, with full control over markup and structure.
• Fast builds and lean output. Minimal overhead at build time and exceptionally light pages at runtime.

Pros and Cons

Pros

• Produces extremely fast, lightweight sites with little or no JavaScript by default.
• Unmatched template-language flexibility; use the syntax you already know.
• No front-end framework lock-in, with complete control over the output.
• Simple mental model and deployment, output is just static files for any CDN.

Cons

• Less batteries-included than opinionated generators; you assemble more yourself.
• No built-in interactive UI layer, you add client-side JavaScript by hand when needed.
• A smaller ecosystem than the largest framework-based generators.
• Harder to detect and to reason about from the outside, which can matter for some workflows.

Eleventy vs Alternatives

Eleventy competes with other static-site generators across the JavaScript and broader web ecosystem. The table below shows where it fits.

Generator	Built on	Ships framework JS?	Best for
Eleventy (11ty)	Node.js	No (by default)	Lean content sites with flexible templating
Next.js	React	Yes	React apps and content sites needing interactivity
Gatsby	React	Yes	React content sites with a rich plugin ecosystem
Hugo	Go	No	Very fast builds with a single binary
Astro	Astro/JS	Minimal (islands)	Content sites mixing static HTML with selective interactivity

Eleventy and Astro both champion shipping minimal JavaScript, but Astro provides a component model with selective "islands" of interactivity, while Eleventy stays purely template-driven and framework-free. If a site turns out to be built with a framework-based generator instead, the runtime fingerprint will make that clear; our profiles on Gatsby and other React generators are useful comparisons. To distinguish the underlying language and tooling, the techniques in how to find out what programming language a website uses help.

Use Cases

Eleventy is ideal for content-focused sites where speed, simplicity, and clean output matter and heavy interactivity does not. Personal blogs, developer portfolios, and marketing sites are common, as are documentation sites and project pages that are essentially text and images with light enhancement.

It also suits performance-critical landing pages, sites that must score well on Core Web Vitals, and projects led by developers who want full control over their markup without adopting a front-end framework. Because it can fetch from APIs at build time, Eleventy works well for sites that pull content from a headless CMS or external data source and then bake it into static pages. Teams that value minimal dependencies and long-term maintainability also gravitate to it.

A few concrete scenarios illustrate the fit. An engineer might build their personal blog and portfolio in Eleventy with Markdown posts and a Nunjucks layout, deploying free to a CDN and enjoying near-instant page loads. A small company might use Eleventy for a fast marketing site, pulling case-study content from a headless CMS at build time so editors work in a familiar interface while visitors get static pages. An open-source project might publish a lightweight documentation site in Eleventy when it wants more control than a turnkey docs tool but no framework runtime. The recurring theme is a deliberate preference for lean, framework-free static output.

From a technology-research perspective, identifying Eleventy, when it can be identified, signals a performance-conscious, developer-led approach that favors minimalism and static delivery. That profile is useful context for vendors selling developer tools, hosting, or performance services, and for analysts characterizing how a site is built. The honest caveat applies here too: because Eleventy hides at runtime, confident identification often depends on a generator tag, so technology-detection results for Eleventy should be read with appropriate nuance. For how stack signals feed lead qualification, see what is technographics, and for tuning static-site performance, see how to make your website load faster.

Frequently Asked Questions

Is Eleventy a JavaScript framework?

Not in the front-end sense. Eleventy is a static-site generator and build tool that runs on Node.js at build time. It uses JavaScript for configuration and data, and it can process JavaScript-based templates, but it does not provide a client-side UI framework and ships no framework runtime to the browser by default. The sites it produces are plain HTML, CSS, and whatever JavaScript you choose to add yourself.

How can I tell if a website was built with Eleventy?

The only definitive signal is a <meta name="generator" content="Eleventy ..."> tag in the page source, which the author may or may not include. Check with View Source or curl -s URL | grep -i 'content="Eleventy'. Absent that tag, you can only reason from circumstantial clues, framework-free static HTML and static-host headers, which are consistent with Eleventy but also with other minimalist generators and hand-coded sites, so the result is a probability rather than a certainty.

Why is Eleventy harder to detect than other generators?

Because Eleventy does all its work at build time and ships no runtime by default, the resulting site looks like an ordinary hand-built static site. Framework-based generators leave a recognizable runtime fingerprint in the browser, but Eleventy intentionally does not. That minimalism is a core feature for performance, and it is precisely what makes specific detection difficult unless the author opted to include a generator tag.

What template languages does Eleventy support?

Eleventy supports a wide range out of the box, including Nunjucks, Liquid, Handlebars, Markdown, plain HTML, EJS, Mustache, and JavaScript template literals. You can mix multiple languages within a single project and even pre-process Markdown with a templating engine. This breadth is one of Eleventy's defining advantages, since teams can use syntax they already know instead of adopting a framework's conventions.

Is Eleventy good for SEO?

Yes. Eleventy outputs clean, pre-rendered static HTML with full control over titles, meta tags, headings, and structured data, and because pages are lightweight and typically served from a CDN, they tend to perform very well on Core Web Vitals, which supports search visibility. As always, content quality and information architecture matter more than the generator, but Eleventy's lean output is a strong technical foundation.

Want to detect Eleventy when it is detectable, identify the hosting, and map the rest of a site's stack? Run any URL through StackOptic at https://stackoptic.com.