cairn
Cairn is my embedded CMS and admin-interface scaffold for SvelteKit sites on Cloudflare. It's an open source project: free code that (hopefully) helps people.
I built cairn for my own sites. I host everything on Cloudflare, because nothing else does bulletproof, security-forward hosting at almost no cost, but unfortunately committing to Cloudflare limits your choice of tools. The git-based CMSes that remain get the storage right, keeping content as plain files in your own repo, but they still ask editors to think in git, and for normal human beings who write, that's a bridge too far. I wanted the people who write content for sites to get a tool that takes their writing seriously and keeps the version control invisible.
Editor-first
Cairn gives non-technical content editors a first-class writing experience with all the modern affordances: a markdown editor built for prose in the spirit of iA Writer, a live preview that renders through the same function as your public pages, so editors see exactly what ships. It also has focus, typewriter, and Zen modes, a spellchecker with a per-site dictionary, and an optional AI copy-edit (tidy, built on Claude) that proposes fixes and never applies them for you. Editors sign in from an emailed link (no GitHub account, no password), and cairn exposes the signed-in identity to your own routes, so what you build next to cairn knows who's editing. The magic-link flow is a default, not a requirement: a developer can replace the auth outright. The editors' own front door is Welcome, editors.
Content storage and types
Behind the editor, cairn stores all site content as markdown committed to the site's own GitHub repo, but in no way requires editors to understand git or version control. Saves go to a holding branch, one per entry, and a conflicting edit is refused rather than merged by guesswork. Publishing copies the entry to main with the editor as commit author, and from there the site deploys like any other push. (The default magic-link authentication requires a small D1 database.)
Content is a fixed set of concepts you declare. Posts and Pages are available out of the box, and you can add others if you need them, each with a typed frontmatter schema. Inside the markdown, content components render through remark directives, the accepted way of extending markdown with richer structures. The starter set covers callouts, alerts, an inline icon, pull quotes, CTAs, FAQs, video, and an expiring announcement banner, each with a schema-driven insert form in the editor. You declare your own the same way. Figures are built into the engine itself.
Small is beautiful
Most of the sites I build have some degree of functionality beyond being a good CMS, so whatever managed the content had to be easy to extend once I wrote it. Nothing I found gave me all three: the hosting, the editor experience, and the room to grow.
Cairn is deliberately small. It manages markdown content and the admin where editors write, and that's it. Anything else your site does (member signups, event registration, reservations, a roster), you build next to cairn, and there are documented seams where your code has to touch the engine. Your own admin screens mount inside cairn's, in the same DaisyUI and Tailwind idiom the scaffold is built from, so what you add and what cairn ships read as one admin to the people using it.
The stack is fixed: SvelteKit, Cloudflare, GitHub, no abstraction layers over any of them. Why cairn explains the rationale and the limits of my choices.
An enforced design language
The admin design language is written down, and cairn checks it. The admin's type scale and spacing are tokens with named roles. Each toolkit component carries measured norms, generated into a manifest you can query. A packaged audit, npx cairn-audit, checks your markup and your rendered screens in both themes against the same rules cairn runs over its own admin. And the standard itself ships in the package as a skill an AI coding agent can load, with annotated exemplar screens and a derivation ladder for components the toolkit doesn't cover. An agent building your next screen works from the written language instead of guessing from rendered ones. You still make the design judgments. The tokens, the norms, and the audit just stop you from having to rediscover what cairn already decided. Why the design language is enforced gives the reasoning and the limits.
Waymark and Topo
Cairn ships with a starter template called Waymark: a complete, working site with the component library wired in, built in the DaisyUI and Tailwind idiom and meant to be restyled or replaced. The unmodified template runs live at cairn.pub, and a scaffolded site begins as exactly that site. For many basic sites, that's the finish line. A site that grows past a basic CMS keeps building on the same template instead of starting over. The live cairn.pub demo is neutral Waymark wearing the cairn theme, its opt-in identity layer. It is one worked example of the re-skin, covered in Make Waymark your own.
A second template, Topo, is planned: a documentation-first derivative of Waymark that will carry cairn's own docs when it lands.
Quickstart
npm install @glw907/cairn-cmsA working site needs four things from you. Write an adapter that describes your content: the concepts, the GitHub repo to commit to, your render function. Mount the admin routes, a handful of copied files, then give the Worker its three bindings in wrangler.jsonc: D1 for auth, an email sender for the sign-in links, and R2 for media. Then deploy. The tutorial covers each step with the real files.
The docs go deeper when you need them. The guides are task recipes, with the editor-facing ones grouped on their own, while the reference keeps a page per package entry point that CI checks against the code. The explanation pages cover the architecture and the security model.
Cairn is pre-1.0. It runs two production sites today, ecxc.ski and 907.life. If you ever remove it, your content is still plain markdown in your repo, and the rendering is what you'd rewire. Versioning and upgrades live in the upgrade guide. History is in the CHANGELOG. Security reporting goes through the policy, and the license is MIT.