Uruk — a multi-tenant CMS

A website is
data, not code.

Uruk composes entire sites from rows in Postgres — element trees rendered to HTML, cached until the data changes, edited by people and AI agents over the same API. No templates to commit. No build to run. No deploy to wait for.

sh — get running
$ git clone https://github.com/Galaktis/uruk && cd uruk
$ docker compose up
# http://localhost:8000 → this site, served from rows

Why the first city of writing lends its name

the stack is a ziggurat — state at the base, HTML at the summit

From tablet to page

Three moves, same as 3200 BC

A scribe pressed records into clay; a renderer presses rows into HTML. The pipeline is short enough to hold in your head.

01 · WRITE

Rows, not files

Every block on this page is an Element row — a kind, JSON parameters, content, and a parent. Pages are rows too, arranged in a URL tree.

{
  "kind": "heading",
  "content": "A website is data",
  "parameters": { "level": 1 },
  "parent_id": "0198…root"
}
02 · RENDER

The tree becomes HTML

A small library of committed renderers walks the element tree. Text is escaped by default; there are no per-site templates anywhere.

# the only committed "template"
@register("heading")
def heading(el, children, ctx):
    return format_html(
        "<h{0}>{1}</h{0}>",
        el.parameters["level"], el.content)
03 · CACHE

Cached until a row changes

Each render records which elements it touched. Saving one element evicts exactly the pages that used it — a shared header invalidates everywhere at once.

element.save()
└─ PageDependency reverse index
   └─ evict: /  /manifesto  …
✓ next request re-renders once

What the city provides

One deployment, many sites

A single Uruk serves any number of tenants. Each one is a walled district: its own schema, its own users, its own everything.

A schema per tenant

The Host header picks the tenant; the connection's search_path does the isolation. Users, content, and tokens never share tables across sites.

Exact invalidation

The hard problem, solved with a dependency graph: every render records what it read, so one edit evicts precisely the affected pages — nothing more, nothing stale.

Agents are editors

The first admin client is an MCP server, not a dashboard. An agent authenticates as a tenant user and can do exactly what that user's permissions allow.

Sites that travel

Every row has a UUIDv7 key, so a whole site exports as one JSON archive and restores anywhere without collisions. This very site ships as one.

Assets live in the DB

The CSS styling this page is a row, served at a content-hashed URL with an immutable year-long cache. Even the fonts are rows. Few files, full speed.

No commit-to-create

A new site is an API call, not a repository. The only committed code is the generic renderer library every tenant shares — everything else is rows.

Founding a city

Running in one command

Docker is the only requirement. On first start the app container migrates every schema and raises the default tenant — the site you are reading now — next to a remote MCP endpoint. Then hand an agent a token, let it build, review the draft in the Studio, and publish.

The full quickstart, including MCP setup
sh — from zero to served
$ git clone https://github.com/Galaktis/uruk && cd uruk
$ docker compose up -d
app   migrating public + tenant schemas, seeding the default site…
app   Listening at: http://0.0.0.0:8000
mcp   Listening at: http://0.0.0.0:8001  (/mcp)
# any hostname you point at it now serves this site