Kitchen-Sink vs. other static-site generators
By @lucasdicioccio, 415 words, 0 code snippets, 8 links, 0images.
There is no shortage of good static-site generators. This page is not here to declare a winner — Hugo, Eleventy, Jekyll, and Zola are all mature, well-documented tools with large communities, themes, and plugin ecosystems that Kitchen-Sink does not try to match. What follows is a factual side-by-side of a few structural choices, plus a plainer explanation of what we think is actually different about Kitchen-Sink.
We have not run comparative build-time or output-size benchmarks, so this page makes no performance claims for any of these tools.
Kitchen-Sink Haskell | Hugo Go | Eleventy JavaScript | Jekyll Ruby | Zola Rust | |
|---|---|---|---|---|---|
| Content format | CommonMark (with JSON/CSS/Dhall/templating sections) | Markdown + YAML/TOML front matter | Markdown + pluggable template languages | Markdown + YAML front matter | Markdown + TOML/YAML front matter |
| Templating | tramaj (typed expression + document language) | Go templates | Nunjucks, Liquid, EJS, Handlebars, JS, … (pluggable) | Liquid | Tera |
| Single file mixes content, style, and data | Yes | No | No | No | No |
| Built-in dev server with live reload | Yes | Yes (`hugo server`) | Yes (bundled dev server) | Yes (`jekyll serve`) | Yes (`zola serve`) |
| Request-time (on-the-fly) rendering, not just static output | Yes (`serve --servMode SERVE`/`DEV`) | No | No | No | No |
| Request-time dynamic pages backed by SQL datasources | Yes, opt-in (`--dynamic`) | No | No | No | No |
| Built-in API gateway / reverse proxy | Yes (`/api` proxy) | No | No | No | No |
| Multi-site hosting (one process, many domains) | Yes (`multisite`, Dhall-configured, SNI) | No | No | No | No |
what is actually distinctive about Kitchen-Sink
Table rows aside, here is the plainer version of what we think sets Kitchen-Sink apart — and why, mostly, it comes from being written by one person mainly for their own blog, not from a deliberate attempt to out-feature anyone.
one file, all the sections
The section-based format lets a single .cmark file
declare its layout, metadata, topics, CSS, and one or more content blocks —
including generator commands and templating sections — instead of spreading
content, front matter, and per-page styling across separate files and
directories. This is a genuine trade-off, not a free lunch: it means longer
individual files, and it is less friendly to non-technical collaborators
than a conventional content/ + layouts/ + assets/ split.
a real templating language, evaluated live
Most static-site generators run their templates once, at build time, to
produce static HTML. Kitchen-Sink’s tramaj sections
can do the same, but in serve mode the same engine can also evaluate
per request: opt-in with --dynamic, a route can query a SQL datasource
declared in kitchen-sink.json and render a page from the result, in the
spirit of SQLPage. You can also try tramaj directly
in your browser without installing anything.
the dev server doubles as a small API gateway
kitchen-sink serve is not only a preview server: it can proxy an /api
route to a backend of your choice (useful for local development of a
single-page app alongside its content), and in multisite mode it can host
several domains — with per-domain TLS/SNI and proxying rules — from a single
process, configured in Dhall. None of the tools in the table above are meant
to do this; it is not a criticism of them, it is simply a different job
(they generate files, ours also wants to be a small always-on daemon).
produce and serve share one pipeline
produce (one-shot build) and serve (dev server / production-ish serving)
run the exact same Site → Target → bytes pipeline — the only difference is
when a target gets realized (ahead of time to disk, or on the fly per
request). This is what makes on-the-fly dev-mode rendering and request-time
dynamic pages possible without a second code path to keep in sync.
When you might prefer one of the others
If you want a large theme ecosystem, a big plugin marketplace, non-technical content editors, or a tool with a much bigger community for support, Hugo, Eleventy, Jekyll, and Zola are all solid, more established choices. Kitchen-Sink is a smaller, more opinionated tool, built first for its author's own blog and now used as the demo of its own input format.