Marmite: a static site generator for people who write blogs

One command, one directory, one output folder

The stated purpose is deliberately narrow. Marmite, which expands to Markdown makes sites, is a very simple static site generator, and the how it works section says it does one simple thing only: it reads all the .md files in the input directory, parses them to HTML content using CommonMark, extracts optional metadata from frontmatter or the filename, generates an HTML file for each page, and outputs the rendered static site to the output folder. It also copies or generates the static and media directories into the output. The usage is two paths and a message:

$ marmite folder_with_markdown_files path_to_generated_site
Site generated at path_to_generated_site/

The output folder defaults to a site subfolder of the input folder, so with no arguments at all it reads and writes in the same place. The motivation is quoted from a user in the readme, that they are a big user of other static site generators but it is frequently frustrating that it takes so much setup to get started, and that just having a directory of Markdown files and running a single command sounds really useful. The licence is AGPL, the crate is on crates.io as marmite, and the project ships a demo and documentation site at marmite.blog.

What you should know before you start, including the flat output

There is a section of caveats before the feature list, and it is the most useful part of the readme. Marmite is meant to be simple, so do not expect complex features. It is for bloggers, so writing and publishing articles in chronological order is the main use case. The generated static site is flat HTML by default, with each page at a path of a name followed by .html, .rss or .json, and workspaces can produce subdirectory-based multi-site layouts instead. Taxonomies cover tags, stream, series, authors and languages for internationalisation. And Marmite uses the date attribute to differentiate posts from pages, which is a decision with a consequence, because a page without a date and a post with one are handled by different templates and end up in different listings. That last point is worth internalising before you start writing, since retrofitting a date convention onto an existing site means reclassifying every file. The project also publishes a playground and a one-click blog template repository.

Markdown features that go past CommonMark

The parsing layer is CommonMark with GitHub Flavoured Markdown and a set of extensions, and the Markdown library in the dependency list is comrak with the shortcodes feature enabled. The feature list names the specific syntaxes. Emojis in the colon form, spoilers written with double pipes, wikilinks in the form of a name and a url in double brackets and Obsidian style links, and GitHub style markdown alerts for callouts. Raw HTML is allowed, which matters for anyone who needs to embed something the generator does not know about. The parser is configurable, with CommonMark extensions and rendering options set in the configuration file, and the whole thing is zero-config to start with and optionally fully configurable through a marmite.yaml. The metadata comes from frontmatter or from the filename, and the frontmatter handling is done with a frontmatter generator crate, so both styles work without you having to choose. Shortcodes are a feature in their own right, with YouTube, Spotify, cards, galleries, table of contents and custom templates among them, and there is a CLI flag that lists all the available shortcodes.

Feeds, search, series and the taxonomy model

The publishing features are what separate this from a page generator. RSS feeds are generated for the index and per tag, per author, per stream and per language, so a multilingual site gets separate feeds per language without extra work. Tags and multi-author support with profile pages are there, and multi streams let you keep separate content in separate listings, which is how a site that mixes long articles with notes can still look coherent. Series support gives ordered chronological content groups with navigation between them, so a book written as posts can be read as a sequence. Draft content management filters drafts out of the feeds and the search index rather than hiding them, which is the behaviour you want from a static generator. There is a static search index with inline match previews, next and previous post navigation that is stream aware, an automatic sitemap, internal link validation at build time with an optional strict failure mode, redirect aliases through a frontmatter field that generates redirect pages for old urls, and a dry run flag that shows all the site urls without building anything.

The built-in server, live reload and incremental rebuilds

Marmite ships a built-in HTTP server with WebSocket live reload, and the watch flag detects changes and rebuilds the site automatically. The dependencies explain the design. There is a small HTTP server crate and a WebSocket implementation for the live reload channel, and a file watching crate for the watch mode. The image processing is where the parallelism shows, with automatic image resizing that runs in parallel, supports incremental builds and has a configurable quality, plus an image gallery with automatic thumbnail generation. The image crate handles the pixel work and there is a zip crate, which is presumably for the downloadable bundles the static site can offer. For the syntax highlighting in the theme, the build-time highlighting uses arborium, and the theme can render Mermaid diagrams and maths either as native SVG at build time or client side. The whole thing is a single binary with everything embedded, and the assets are compiled in with a crate that embeds a folder of files and interpolates the folder path, which is why there is no assets directory to ship alongside it.

Themes, workspaces and the AI skill

The built-in theme covers light and dark modes, multiple colour schemes, a responsive layout, spotlight search, an index page that is easy to replace, custom CSS and JavaScript, and customisable Tera templates, and the templates engine in the dependency list is Tera. On top of that there is a theme system with remote theme installation and a CLI command to start a new theme from scratch, so a theme is a folder of templates and static assets you can fork. The workspace feature supports multi-site layouts, where a single command builds several sites, configuration is inherited between them, and cross-site references are possible. There is also an AT Protocol integration for publishing posts to the decentralised social web, with its own subcommand for managing it. The most unusual entry in the list is the embedded AI agent skills, and the CLI shows how it works, with a flag that prints the embedded agent skill document to stdout and two flags that install it into a .agents/skills directory or into a .claude/skills directory for Claude Code. The repository has matching directories at the root for both, along with a CLAUDE.md and an AGENTS.md, so the tool can teach an agent how to manage the site.

One codebase, many ways to install it

The distribution channels are unusually broad, and the packaging explains them. The project is published to crates.io, to pip and uvx through a Python binding built with maturin, and to Homebrew, the AUR, FreeBSD, Docker and an install script. The install script is the shortest route:

curl -sS https://marmite.blog/install.sh | sh

The Python packaging is a thin wrapper, with the project metadata listing no Python dependencies at all, and the maturin configuration pointing at a python package directory and binding a binary. The Docker image is a two-stage build from a Rust slim image with a release compile and a distroless Debian runtime, and the entrypoint runs the binary with the current directory as input and site as output. The Cargo manifest excludes the example content and site, the Python directory, the assets and the Docker and contribution files from the published crate, so the package stays small. The toolchain is pinned by a rust-toolchain.toml file and a mise.toml, and the project is version 0.4.2, classified as beta, with the last three releases being 0.4.2, 0.4.1 and 0.4.0 in the space of a few weeks. The project description in the metadata is the plainest statement of intent available, that Marmite is the easiest static site generator.

Editorial conclusion

Marmite is a good fit for a blogger or a small team whose publishing needs are chronological articles, tags, a feed and a search index, and who would rather not maintain a configuration file. It is the wrong tool if you need a documentation site, a landing page site or anything with a page hierarchy, because the project is explicit that the default output is flat and that writing and publishing articles in chronological order is the main use case. It is also the wrong tool if you need a stable toolchain, since the project is classified as beta at version 0.4.2 and has moved through several minor versions in the past few months. Before adopting it, read the section on what you should know before you start, because the flat output and the date attribute deciding posts from pages will shape your content structure, and note the licence, since the code is AGPL-3.0-or-later and the project is published under a name that suggests a lighter commitment. The last push was on 2026-10-17.

Frequently asked questions

Official sources

1. License: AGPL-3.0
2. Project website
3. README
4. Releases
5. rochacbruno/marmite on GitHub