v0.2.0 is out. Grab a binary for Linux or macOS, or the Docker image. Read the release notes

Open-source headless CMS, written in Rust

Content at the speed of your code.

Describe your content and get the API back. One Rust binary, one Postgres database, and access rules that reach down to a single field.

docker pull ghcr.io/tachyon-cms/tachyoncms:v0.2.0

v0.2.0 is pre-alpha. The content API, sign-in, access rules, blocks and rich text work; keep it off public networks for now.

How it works

Write a content type. Read it back over HTTP.

Send a collection to the server and its endpoints exist from that moment. Create, read, update and delete, with filters, sorting and pages. There's no code to generate and nothing to restart.

1 · Define a content type

POST /api/admin/collectionsAuthorization: Bearer tcs_…{  "slug": "posts",  "fields": [    { "name": "title", "type": "text",      "required": true, "maxLength": 120 },    { "name": "publishedOn", "type": "date",      "dateOnly": true }  ]}

2 · Add a post

POST /api/postsAuthorization: Bearer tcs_…{ "title": "Hello, world",  "publishedOn": "2026-10-12" }

3 · Read it back, no sign-in needed

GET /api/posts{  "docs": [{    "id": "01a183e3-0e0c-76c0-…",    "title": "Hello, world",    "publishedOn": "2026-10-12",    …  }],  "hasNextPage": false,  "limit": 10, "page": 1}
Real requests and responses from TachyonCMS v0.1.0. An ellipsis marks where a response is trimmed.

For developers

Fast because of how it's built, not because we said so.

You've read enough landing pages that promise speed with a chart and no method. Here's the architecture instead, and you can check every line of it.

Speed you can reason about

One Rust binary on Axum and Tokio, and Postgres beside it. That's the whole install. Each document sits in a single row, its published fields in one JSONB column. A post's own fields come straight from that row; linked documents you ask to populate come from theirs.

Numbers? Not yet. We'll publish reproducible benchmarks against the popular CMSs first, method and all, and only then quote one.

Security that lives in the query

An access rule isn't a check bolted on after the fetch. It becomes part of the SQL for whoever's asking, so nobody can find a hidden document by filtering for it. Filter values always travel as bound parameters.

Passwords are hashed with Argon2id, refused if they've turned up in a known breach, and five wrong ones in 15 minutes lock the account for 15 more. API keys carry scopes and can be rotated.

Built to be lived with

When a write fails, the error names the field: seo.title, links.0.url. Every error is RFC 9457 problem+json with a request ID you'll find in the logs.

Content types export to a JSON file you can diff in a pull request. IDs are UUIDv7, deletes are soft, and date-times are stored in UTC to the millisecond.

How TachyonCMS fits together

Access rules

Same request, different answer. That's the rule working.

Everyone reads what's published; authors also read their own drafts. You write that once, in the schema. Ann asks for /api/posts and gets both her posts. Someone signed out asks the same thing and gets one, and a guess at the draft's ID gets a 404. Your front end didn't filter a thing.

The rule, in the posts schema

"access": {  "read": { "or": [    { "published": true },    { "author": "$user.id" }  ] }}

Someone signed out

GET /api/posts{ "docs": [    { "title": "Hello, world",      "published": true }] } GET /api/posts/01a183e2-c02a-…404 Not Found

Ann, the author

GET /api/postsAuthorization: Bearer tcs_…{ "docs": [    { "title": "Half-finished thoughts",      "published": false },    { "title": "Hello, world",      "published": true }] }
Real responses from TachyonCMS v0.1.0, trimmed to each post's title and published flag.

For editors · On the roadmap

The admin isn't built yet. Here's the bar it has to clear.

If you're the one publishing the Tuesday newsletter, TachyonCMS has nothing for you today. It's an API. Here's where it's headed: an admin that comes after the editing basics below, held to one test. Someone who has only ever used WordPress should pick it up without training, from adding a content type to scheduling a post.

  1. Rich text and blocksIn v0.2.0
  2. Drafts, versions and scheduled publishingUnder way
  3. Media, with responsive imagesNext
  4. Live preview
  5. Authoring tools: push and pull content as Markdown files, bulk import
  6. The admin screenAfter those

Schema as code

Rename a field without losing a word of it.

Change title to headline in your schema file and ask what would happen. Leave out the rename and TachyonCMS tells you plainly that it would delete the data. Say it's a rename, and every document keeps its title under the new name.

schema.json, in your pull request

{ "collections": [  { "slug": "posts", "fields": [-   { "name": "title",+   { "name": "headline",      "type": "text", "required": true },    { "name": "published", "type": "checkbox" }  ] }] }

Terminal

$ tachyon schema diff schema.json~ change posts: remove title, deleting its data; add headline (text)  2 of 2 documents won't validate against the new fields  users isn't in the file; left as it is $ tachyon schema diff schema.json --rename posts:title=headline~ change posts: rename title to headline  users isn't in the file; left as it is $ tachyon schema apply schema.json --rename posts:title=headline~ change posts: rename title to headline  users isn't in the file; left as it is Applied.
Real output from tachyon 0.1.0, run against two existing posts. Nothing changes until apply runs.

Supply chain

Don't take the binary on trust. Check it.

A CMS holds your content and your users' passwords. You should be able to prove what you're running.

From the blog

What's new

Get involved

Want in? Start with something small.

TachyonCMS is young enough that one pull request changes it. The good first issues are real and sized for an evening: a CLI message that could say more, a validator that lets a bad email through, a header the API should send. Rust helps for most of them. Docs and copy fixes count just as much.

Pull it. Point it at Postgres. Define something.

$ docker pull ghcr.io/tachyon-cms/tachyoncms:v0.2.0

Or grab a binary for Linux or macOS. The docs take you from there to your first API key.