GitHub
0.0.1 · In development

Open-source backend-as-a-service

Your whole backend
in one binary.

Collections, REST API, auth, file storage and realtime in a single Rust binary backed by SQLite. Self-hosted, open source, zero config.

docker run -p 8080:8080 -v rackend_data:/data ghcr.io/axanet/rackend:0.0
  • Single static binary
  • SQLite
  • amd64 + arm64
  • No external services
Illustration: a laptop, a phone and a desktop each send requests to one server rack and receive responses.
requestresponserealtime event

01Quickstart

Running in a minute.

One command, no config file. Everything else is set up at runtime in the admin UI.

  1. Run it

    Start the container. The image runs on amd64 and arm64 and needs no other services.

    docker run -p 8080:8080 -v rackend_data:/data ghcr.io/axanet/rackend:0.0
  2. Create the admin account

    Open the one-time setup link from the logs and create the first superuser.

    INFO rackend is ready addr=0.0.0.0:8080
    WARN Open http://localhost:8080/_/setup?token=… to create the first superuser.
  3. Create a collection, call the API

    Add a posts collection in the admin UI, set its list rule, and you have a REST API.

    curl http://localhost:8080/api/collections/posts/records

+ Typed clients

Generate a client for any language.

Every instance describes its live schema as OpenAPI, typed per collection. Feed it to the generator you already use.

rackend openapi export > openapi.json
# then use any OpenAPI generator, e.g. openapi-generator, oapi-codegen, progenitor

Follow the getting started guide for every step with commands to copy, or read the docs.

02Features

Everything an app backend needs. Nothing to wire up.

A database you design at runtime, an API that enforces your rules, auth that can be the identity provider for your other apps, files and realtime. One process, one data directory.

Data

Access rules

One expression per operation, compiled to safe, parameterized SQL. Rules are checked live in the admin UI as you type. New collections are locked by default.

postsrule
listpublished = true || owner = @request.auth.id
viewpublished = true || owner = @request.auth.id
create@request.body.owner = @request.auth.id
updateowner = @request.auth.id
delete locked; superusers only
list rule → SQLillustrative
SELECT … FROM "posts"
WHERE "published" = ?1 OR "owner" = ?2
-- ?1 = 1, ?2 = <id from the auth token>

Data

Collections & REST API

Define tables at runtime in the admin UI and get a full REST API: filtering, sorting, pagination, relation expansion and batch transactions. Real SQLite columns, not JSON blobs.

GET/api/collections/posts/records?filter=published=true&sort=-created&expand=author

Auth

Built in

Your own OpenID Connect provider

rackend is an OIDC provider itself. Your apps log in through it with any standard OIDC library, on a hosted, themeable login page. No separate identity server to run.

  1. your app
  2. rackend login page
  3. id_token + access_token
issuer
https://your-rackend.example
flow
authorization code + PKCE
scopes
openid profile email offline_access

Auth

Authentication

Email and password, passkeys, one-time codes and magic links. Plus login with any OIDC provider: paste the issuer URL and rackend discovers the rest.

  • Google
  • Microsoft
  • GitHub
  • Authentik
  • Pocket ID
  • Keycloak
  • any OIDC issuer

Realtime

Realtime

Subscribe to record changes over SSE or WebSocket. Every event is checked against access rules, per subscriber. Ephemeral channels for presence and typing indicators.

{ "type": "record", "topic": "records:messages",
  "action": "create", "record": { … } }

Files

File storage

Local disk by default, or any S3-compatible store. Access is controlled by the same rules as records.

  • local disk
  • AWS S3
  • Cloudflare R2
  • Garage
  • RustFS

Operations

Observability

An audit trail of every change: who, what, when, before and after. Request logs, app and host metrics, a built-in dashboard, Prometheus and OpenTelemetry export.

  • Images & thumbnails

    EXIF and GPS metadata stripped on upload, orientation fixed, thumbnails generated on demand as WebP.

  • Collaborative editing

    Yjs-compatible collaborative documents out of the box. Works with Tiptap, BlockNote and CodeMirror.

  • OpenAPI for every instance

    An OpenAPI document generated from your live schema, typed per collection. Generate a client in any language.

  • Standard errors

    Every API error is an RFC 9457 problem details object with a stable, machine-readable code.

  • Admin UI

    Embedded in the binary: schema editor, records browser, auth and provider setup, dashboard, settings.

03Data safety

Built to keep your data.

Data safety wins over everything else in rackend's design. Upgrading should be the most boring thing you do all week.

  • Upgrades never lose data

    A verified backup before every schema migration, integrity checks after. If anything looks wrong, like an accidental downgrade, rackend refuses to start rather than risk your data.

  • Every upgrade path tested

    In CI, the database of every released version is upgraded to the latest one and checked.

  • A trash, not a drop

    Deleted fields and collections are kept in a trash for 30 days before they are purged.

  • Backups are a file copy

    One SQLite file plus a storage folder. Scheduled backups are built in.

  • One writer, always

    An exclusive lock stops a second instance from writing to the same data directory.

upgrade · v1.3 → v1.4illustrative
$ docker compose pull && docker compose up -d
✓ data directory locked        rackend.lock
✓ migration checksums verified
✓ backup written                backups/pre-upgrade-12-to-14-….db
✓ backup integrity_check       ok
✓ applied migration 13
✓ applied migration 14
✓ integrity_check, foreign_key_check ok
→ serving on 0.0.0.0:8080
accidental downgradeexit 78
✗ database schema v14 is newer than this binary supports (v12).
  Downgrading is not supported; restore a pre-upgrade backup
  from /data/backups to go back.

04Operations

One process. One data directory.

No Postgres, Redis or queue to run next to it. One static binary or one small Docker image, for amd64 and arm64.

Zero config to start

Everything is configured at runtime in the admin UI. Environment variables exist only for bootstrapping: listen address, data directory, an optional encryption key.

services:
  rackend:
    image: ghcr.io/axanet/rackend:1.0   # pin a minor version
    ports: ["8080:8080"]
    volumes: ["rackend_data:/data"]
volumes:
  rackend_data:

Runs where you already are

  • a €5 VPS
  • a Raspberry Pi-class board
  • your homelab
  • Coolify
  • Unraid

Inside the binary

A hexagonal core with no I/O of its own. Everything it talks to sits behind a port, so new adapters such as gRPC or MCP can be added later without touching it.

rackend · one process

Adapters in

  • HTTPREST · SSE · WebSocket · OIDC
  • gRPClater
  • MCPlater

Core

  • collections
  • rules
  • auth · OIDC
  • files
  • realtime
  • audit

Adapters out

  • SQLite
  • filesdisk or S3
  • images
  • mail

Data directory

  • data.db
  • logs.db
  • storage/
  • backups/

05How rackend differs

Standing on PocketBase's shoulders.

rackend is inspired by PocketBase, and shares its single-binary spirit. Here is where it takes a different path, and what it deliberately doesn't do.

vs. PocketBase

Same idea, more built in.

  • A built-in OIDC provider, so other apps can log in through rackend
  • Collaborative editing with Yjs-compatible documents
  • An audit trail and app + host metrics out of the box
  • Written in Rust

vs. Supabase / Appwrite

No stack to operate.

  • One process instead of a multi-service deployment
  • SQLite instead of Postgres
  • Aimed at single-app, single-server deployments

Honest trade-offs

What it won't do.

  • Single instance; no horizontal scaling
  • No custom server-side code (hooks) in v1
  • One app per instance; no multi-tenancy

Own your backend.

One command away. Free and open source.

docker run -p 8080:8080 -v rackend_data:/data ghcr.io/axanet/rackend:0.0