GuideBuild performance

Benchmarks

Build times of Douze, Hugo, Eleventy, Astro and Jekyll on Zach Leatherman's Markdown benchmark and on a docs-heavy scenario, and the internal benchmarks of large Douze sites.

This page compares the build time of Douze with other generators on a public benchmark, then summarizes the internal benchmarks that track Douze on large sites. Every number comes from scripts in the repository, so you can run them again.

The Markdown build benchmarkLink to this heading

In 2022 Zach Leatherman published Which generator builds Markdown the fastest?, with its scripts in zachleat/bench-framework-markdown. Each generator builds a blog from 250, 500, 1000, 2000 and 4000 Markdown files, borrowed from Sean C Davis's SSG build performance comparison. The output folder and the generator's caches are deleted before each run, each size runs 3 times, and the fastest run is kept.

The rerun here uses the same Markdown files, at commit fbda1c1 of the benchmark repository, with the current versions of Hugo, Eleventy, Astro and Jekyll, and with Douze. The original also tested Gatsby, Next.js and Remix, which are not part of this rerun. Jekyll was not in the original.

Each Markdown file has a title in its front matter and three paragraphs of lorem ipsum, about 1 KB. There are no headings, lists, code blocks or images.

What each generator buildsLink to this heading

Each generator starts from the starter the original article used, at its current version, and the benchmark copies the Markdown files where that starter keeps its posts.

Generator Version Starter Pages for N posts Other outputs
Douze preview, commit 001838c A blog written for this benchmark as the equivalent of eleventy-base-blog (below) N posts, home, archive, about, tags, 404 Atom feed, sitemap
Hugo 0.168.0 extended The benchmark repository's quickstart: no theme, one template for posts N posts RSS, sitemap (Hugo's built-in templates)
Eleventy 3.1.7 eleventy-base-blog v9, sample posts removed N posts, home, archive, about, tags, 404 Atom feed with the post contents, sitemap
Astro 7.4.0 The blog example of the Astro repository, sample posts removed N posts, home, about, blog index RSS feed, sitemap, one optimized image
Jekyll 4.4.1 jekyll new with minima 2.5.2, the welcome post removed N posts, home (lists every post), about, 404 Atom feed, minima's Sass compiled

Notes on the setup:

  • Astro's blog example requires a description and a pubDate on every post, which the Markdown files do not have. The collection schema gives them defaults; the files are not changed.
  • Jekyll only reads posts named YYYY-MM-DD-title.md, so the files are copied as 2022-07-29-<name>.md.
  • Hugo writes only the post pages: the quickstart of the benchmark has no template for the home page or the lists. This is the setup of the original article, and it gives Hugo less to do than the other blogs.

The Douze blog follows eleventy-base-blog page by page, with the default workflow:

  • A base layout with eleventy-base-blog's stylesheet inlined, the site metadata and a navigation menu from a data file.
  • A post layout with the title, date, tags, content, and links to the previous and next posts, found with the previous_item and next_item filters.
  • A data file in the posts folder that gives every post the posts tag and the post layout.
  • A home page with the 3 latest posts, an archive of every post, an about page, a tags page, a 404 page, an Atom feed of the 10 latest posts and a sitemap.

It leaves out what the Markdown files do not use: image processing, heading anchors and syntax highlighting. Its feed has the titles and links of the posts, not their contents, and the stylesheets are not bundled per page.

How it is measuredLink to this heading

  • Each generator runs in its own Docker image, built from pinned versions. Douze is built from the repository sources inside Docker, the same way as the binary that the releases publish.
  • The site lives in the container's file system, not in a folder shared with the host.
  • Before each run, the script deletes the output folder, the caches and the posts, then copies the N posts in.
  • The time is the wall clock of the build command only, measured inside the container. Starting the container, cleaning and copying are not timed.
  • Each size runs 3 times. The tables show the fastest run, as the original did, and the median.
  • Each run counts the HTML pages written. Every run of every generator wrote one page per post plus its other pages (for 4000 posts: Douze and Eleventy 4005 pages, Astro and Jekyll 4003, Hugo 4000), and no build failed.
Generator Build command Deleted before each run
Douze douze --no-cache -q _site, .douze
Hugo hugo --quiet public, resources/_gen, Hugo's cache folder
Eleventy npx @11ty/eleventy --quiet _site, .cache, node_modules/.cache
Astro npx astro build --silent dist, .astro, node_modules/.astro, node_modules/.vite
Jekyll JEKYLL_ENV=production bundle exec jekyll build --quiet _site, .jekyll-cache, .sass-cache

EnvironmentLink to this heading

Machine Apple M4 Pro, 14 cores, 48 GB, macOS 15.8.1
Docker Docker Desktop 28.0.4, Linux 6.10.14 arm64 VM with 14 CPUs and 7.7 GB of memory
Douze Commit 001838c, built from source like a release binary
Hugo 0.168.0 extended, release binary on debian:trixie-slim
Eleventy, Astro Node.js 24.22.1 (node:24.22.1-trixie-slim)
Jekyll Ruby 3.4.11 (ruby:3.4.11-slim-trixie), sass-embedded 1.106.1
Date 2026-10-27

Every container gets all the CPUs and memory of the Docker VM.

ResultsLink to this heading

Seconds, lower is better. Fastest of 3 runs.

Generator 250 500 1000 2000 4000
Douze 0.035 0.060 0.109 0.207 0.387
Hugo 0.051 0.073 0.118 0.216 0.412
Jekyll 0.345 0.470 0.666 1.020 1.793
Eleventy 0.635 0.894 1.468 2.639 6.363
Astro 1.123 1.364 1.613 2.346 3.295

Median of 3 runs:

Generator 250 500 1000 2000 4000
Douze 0.037 0.061 0.109 0.211 0.403
Hugo 0.058 0.074 0.119 0.220 0.414
Jekyll 0.358 0.472 0.673 1.038 1.857
Eleventy 0.657 0.912 1.501 2.680 6.420
Astro 1.137 1.422 1.648 2.388 3.302

1,000 filesLink to this heading

Douze0.109 s
Hugo0.118 s
Jekyll0.666 s
Eleventy1.468 s
Astro1.613 s

4,000 filesLink to this heading

Douze0.387 s
Hugo0.412 s
Jekyll1.793 s
Eleventy6.363 s
Astro3.295 s

Douze is the fastest at every size, narrowly ahead of Hugo from 1000 files up. At 4000 files it builds the blog in 0.387 s, against 0.412 s for Hugo, 1.793 s for Jekyll, 3.295 s for Astro and 6.363 s for Eleventy. Hugo writes only the post pages, so it does less work for the same number of files.

Rebuilds from the disk cacheLink to this heading

The runs above use --no-cache, so that every Douze build is a clean build like the others. A plain douze build also writes its disk cache (.douze/), and the next build reuses every result whose inputs did not change. Rebuilding the same site with that cache and no change, fastest of 3 runs:

250 500 1000 2000 4000
Douze, rebuild with the cache 0.018 0.025 0.039 0.069 0.125

A rebuild of 4000 posts takes about a third of the clean build. The other generators were not measured this way: their caches were deleted before each run, as the benchmark requires.

CaveatsLink to this heading

  • The sites do not do the same work. Hugo writes only the post pages. Eleventy's base blog runs HTML transforms (image optimization, heading ids) over every page and puts the post contents in its feed. Astro optimizes an image and bundles its assets. Jekyll compiles minima's Sass. The Douze blog is close to eleventy-base-blog, but it is written by the Douze project, and it leaves out what the list above says.
  • Startup is part of the time. Douze and Hugo are native executables that start in milliseconds. Eleventy and Astro start Node.js and npx, and Jekyll starts Ruby and Bundler, which accounts for much of their time at 250 files.
  • Douze and Hugo use every core of the VM. Eleventy and Jekyll do most of their work on one thread.
  • Docker Desktop on macOS runs a Linux VM. The sites are in the container's file system to keep the macOS file sharing out of the measure, but the numbers are those of that VM, not of macOS or of a Linux machine.
  • Douze has no stable release yet: this is a build of the repository at commit 001838c.
  • 3 runs per size is few, and the Markdown files are small and plain. On a real site, templates, images and code highlighting take most of the build time.

Run it againLink to this heading

bench/ssg-comparison/run.sh                    # every generator, 250 to 4000 files, 3 runs
bench/ssg-comparison/run.sh douze hugo         # some generators
SIZES="250 1000" RUNS=1 bench/ssg-comparison/run.sh

It needs Docker and git. It builds the images, runs every size, then writes results.json (every run) and results.md next to the script. The versions are pinned in versions.env, and bench/ssg-comparison/README.md describes each scenario.

Docs-heavyLink to this heading

The Markdown benchmark has almost no work per page. The docs-heavy scenario gives each generator documentation pages that need real work: highlighting code at build time and giving headings ids. It is part of this repository, not of a public benchmark.

A seeded script writes N pages of about 8 KB (6 to 10 KB for 90% of them), each with a title and a description in front matter, 3 or 4 h2 sections with h3 subsections, lists, a table, inline code and 3 to 6 code fences in js, ts, csharp, yaml, bash, json and html. Every generator highlights the fences and adds heading ids with its usual tooling, and renders the pages in one layout with a sidebar of the 50 first pages, read from the same data file.

Generator Highlighting Heading ids Table of contents
Douze highlight step, github-dark headings step Yes, nested
Hugo Chroma, github-dark, inline styles Built in Yes, nested (.TableOfContents)
Eleventy @11ty/eleventy-plugin-syntaxhighlight 5.0.2 (Prism) markdown-it-anchor 10.0.0 No
Astro Shiki, github-dark (its default) Built in Yes, a flat list
Jekyll Rouge 4.7.0 kramdown auto_ids No

The measure is the same as above: wall clock of the build command in the container, output and caches deleted before each run, 3 runs, on the same machine and Docker VM (14 CPUs, 7.7 GB). A run counts only if every page is written, has highlighted tokens and has h2 ids. Builds were capped at 15 minutes; none reached it.

Seconds, lower is better. Fastest of 3 runs:

Generator 1,000 4,000 16,000
Douze 0.284 0.963 4.138
Hugo 0.476 1.639 6.105
Eleventy 1.565 5.947 38.122
Astro 4.844 16.244 failed
Jekyll 5.192 20.051 81.746

Median of 3 runs:

Generator 1,000 4,000 16,000
Douze 0.287 0.973 4.632
Hugo 0.477 1.706 6.265
Eleventy 1.594 5.986 39.139
Astro 5.048 16.474 failed
Jekyll 5.199 20.081 82.701

1,000 pagesLink to this heading

Douze0.284 s
Hugo0.476 s
Eleventy1.565 s
Astro4.844 s
Jekyll5.192 s

4,000 pagesLink to this heading

Douze0.963 s
Hugo1.639 s
Eleventy5.947 s
Astro16.244 s
Jekyll20.051 s

16,000 pagesLink to this heading

Douze4.138 s
Hugo6.105 s
Eleventy38.122 s
Astrofailed
Jekyll81.746 s

Astro fails at 16,000 pages, on every run, after about 52 s: writing its content layer data store throws Invalid string length (the store is serialized as one string, larger than V8 allows).

Douze takes 60 to 70% of the time of Hugo, the next fastest: 16,000 pages in 4.1 s against 6.1 s. Eleventy takes 38 s, Jekyll 82 s, and Astro cannot build that many. Douze and Hugo use about 10 of the 14 cores, the others one or two.

CPU utilizationLink to this heading

User plus system CPU time of the build, divided by its wall clock time, mean of the runs. A value of 1 is one core busy; the VM has 14.

Generator 1,000 4,000 16,000
Douze 9.7 10.5 10.7
Hugo 7.7 8.5 9.7
Jekyll 1.0 1.0 1.0
Eleventy 1.3 1.3 2.0
Astro 1.3 1.2 1.1

Rebuilds with nothing changedLink to this heading

Fastest of 3 runs, after a first build that writes the cache:

Generator 1,000 4,000 16,000
Douze, disk cache 0.034 0.082 0.360
Jekyll, --incremental 0.264 0.557 1.744
Astro, content layer cache 1.826 5.241 failed

Hugo has no persistent cache for pages, and Eleventy's --incremental only applies to --watch and --serve, so they were not measured this way.

CaveatsLink to this heading

  • The features are close but not equal. Eleventy and Jekyll render no table of contents, Astro's is a flat list. Prism and Rouge write classes and no stylesheet is shipped for them; Douze, Hugo and Astro write the colors into the HTML, so their pages are larger.
  • The highlighters are different: Douze and Shiki use TextMate grammars, which are slower and more precise than Chroma, Prism or Rouge.
  • Each site was written for this scenario by the Douze project, from each generator's documentation.
  • The same as above: Docker Desktop on macOS, a build of Douze at commit 001838c, and 3 runs per size.

bench/ssg-comparison/run-docs-heavy.sh runs it again, and results-docs-heavy.md next to it has every number, the page counts and the versions.

Internal benchmarksLink to this heading

bench/Douze.Bench measures the native douze binary on large generated sites, directly on macOS (Apple M4 Pro, 14 cores, 48 GB), and bench/README.md records the results of each change. The latest measurements, from 2026-10-22, median of 3 runs:

Site Build Wall
Synthetic, 32,000 pages of about 4 KB (2 layouts, includes, a navigation of 50 items, 5 data files, a paginated page, 200 assets) Clean, no cache 4.6 s
Same site, one page edited From the disk cache 1.0 s
API reference: 19,712 pages rendered from 78 MB of JSON data, each with a sidebar of 342 packages Clean, no cache 2.0 s

Esc to close