From Jekyll or Eleventy

Both sites are a content tree, a layout directory and a template language with filters. Both also lean on plugins for what baudelaire has as config switches, so the config usually gets shorter and the templates get rewritten.

What is left is the frontmatter keys, the Liquid, the config and the layouts. Read keeping your URLs before you touch permalinks.

Jekyll: the tree

Jekyll: the config

Most of what a Jekyll site installs is already here:

Jekyll: frontmatter

--- is YAML here as well, so the block parses as written. Only the key names move:

---
layout: post
title: "Hello"
date: 2026-07-09
categories: [rust, cli]
published: false
excerpt: "A short summary."
---

becomes, in the same file and the same language:

---
template: post.typ
title: "Hello"
date: 2026-07-09
categories: [rust, cli]
draft: true
description: "A short summary."
---

title, date and categories did not have to move at all. An unquoted 2026-07-09 reaches the date reader as the ISO day it looks like, quoted or not, and [rust, cli] is a list of two - including a list of one, which YAML writes without ceremony.

A key that is neither a built-in nor a declared taxonomy is kept as it is, and a template reads it back with page.frontmatter.at("author", default: none). A key that is a near-miss of a real one fails the build naming what you probably meant, which is what catches a rename left half-done.

On a .typ page the same keys are a Typst dict, and the types are the language’s own:

#let frontmatter = (
  template: "post.typ",
  title: "Hello",
  date: datetime(year: 2026, month: 7, day: 9),
  categories: ("rust", "cli"),
  draft: true,
  redirect: ("/old/hello/",),
  description: "A short summary.",
)

Jekyll: Liquid in a post

Liquid is not markup here. A {% .. %} tag in a .md page is text, and stays text: nothing strips it and nothing warns. Grep for {% and {{ before you build.

A {% post_url %} becomes an ordinary link, and which spelling you give it decides whether the build checks it. A source path - .md or .typ, whichever the target actually is - is rewritten to that page’s permalink, and fails the build when no page sits there:

See [the sleepers](sleepers.md).

A URL (/blog/sleepers/) is passed through untouched, so it is neither checked nor carried along by a later rename.

An include, if the page stays markdown, is an eval fence:

```typ eval
#import "/templates/parts.typ": note
#note[The include you used to register.]
```

That fence runs arbitrary Typst at build time. A site building posts it did not write should set content { markdown { eval #false } }.

Jekyll: categories in the URL

Jekyll can put categories in a URL (/:categories/:year/:month/:title/), and a permalink here has no taxonomy token. What reproduces those URLs exactly is a directory per category and {path}, which fills with the directories a page sits under:

content {
  collections {
    travel  { sort "date"; reverse #true; permalink "/{path}/{year}/{month}/{slug}/"; template "post.typ" }
    history { sort "date"; reverse #true; permalink "/{path}/{year}/{month}/{slug}/"; template "post.typ" }
  }
}

content/travel/night-train.md then publishes at /travel/2026/03/night-train/, as before. The cost is one collection per category and a home-page listing that filters across them (pages(page.lang).filter(p => p.collection in ("travel", "history"))). Keep categories in frontmatter as well if you want the term listings.

A post in two categories cannot use it, since a file lives in one directory. Give those posts a frontmatter path naming the URL they had, which beats the collection’s pattern outright.

Eleventy: the tree

The data cascade is the piece with no counterpart. Eleventy merges global data, directory data files and frontmatter into one object per page. Here a page has its own frontmatter and nothing else, and the shared parts arrive explicitly: collection defaults for template, sort and permalink, client { } or typst { inputs } for constants, and an ordinary yaml("/data/x.yaml") read for data. What a template reads is visible in the template.

One more with no counterpart: pagination over arbitrary data, which here is always over a collection. A per-page permalink does carry over, as path, though it takes a literal URL rather than a pattern.

Layouts, in Typst

<!-- _layouts/post.html -->
<article>
  <h1>{{ page.title }}</h1>
  {% include byline.html %}
  {{ content }}
</article>

// templates/post.typ
#import "@baudelaire/html:0.1.0": h
#import "/templates/parts.typ": byline

#let post(page, body) = h("article")[
  #h("h1", page.frontmatter.title)
  #byline(page)
  #body
]

page.url is missing on purpose. Nothing site-wide may enter a page’s wrapper, or every page’s cache identity would depend on every other page; the site tree and the page catalogue come from @baudelaire/sections and @baudelaire/pages instead. See templates.

Commands

No Ruby, no Node, no lockfile: the Typst compiler, the bundler and the deploy client are all in the one binary. If you were on GitHub Pages’ own Jekyll build, you now need a workflow that runs baudelaire; see GitHub Pages.

Order of work

1. baudelaire init beside the old site, then copy the asset tree across, _sass/ included. A .scss under paths { assets } is compiled and published as .css, and a partial keeps its leading _.
2. Copy _posts/ into content/posts/ unchanged - the YAML blocks parse as they are - then rename the keys from the table above. Rename the dated filenames, or give each a slug, then set the collection’s permalink to the old shape.
3. Rewrite the layouts that section needs, starting with the shell.
4. Replace each plugin with its switch from the table above.
5. Grep the posts for {%, {{ and <: Liquid is text now, and raw HTML is refused.
6. baudelaire check, then compare the old and new sitemaps.

Converting the prose itself is optional, and separate. When you want Typst for a page - math, a figure, a template helper mid-page - Markdown to Typst has the pandoc pass and what it drops.