Skip to content

The stateful backend
for every app.

Every user, order, and agent gets an actor with its own SQLite database, files, jobs, and live channels. One Rust engine, on your laptop and across three zones.

Measured on AWS c8id.

Standalone WAL, dm-thin fork, local NVMe.

Three-zone commit3-zone p99
0.76 ms p990.76 ms
50 GiB fork50 GiB fork
0.63 ms p990.63 ms
Hybrid search
0.43 ms p990.43 ms
Hot actorhot actor
47.5k cmd/s47.5k/s
Idle actor
167 B167 B

One engine for every piece of state.

No queue, cache, or database to wire together. The actor is the unit of state, storage, and scale.

  • 1

    Actors with their own database

    Typed state machines in Effect. Each actor owns SQLite tables, timers, schedules, and live channels, and runs one command at a time.

  • 2

    Storage that forks in a millisecond

    SQLite plus a POSIX folder per actor. Forks are copy-on-write, so size doesn’t change the cost. Continuous export to your own bucket.

  • 3

    One Rust engine, laptop to three zones

    akterd runs akter dev on your laptop and a two-of-three NVMe quorum in the cloud. The engine is the same in both.

One actor for every thing you track.

Small enough to keep millions idle and fast enough to wake on demand. Each one is its own database.

Every entity gets its own database

Make an actor for each thing your app tracks. It wakes when called, commits one command at a time, and uses no compute while it sleeps.

Small when idle
An idle actor takes about 167 bytes, so millions can wait.
Fast to wake
1.67 ms cold start, 2.25 ms wake at p99 on c8id hardware.
One writer
Each actor owns its SQLite file, so there are no locks or races.
Hot keys hold
47.5k commands a second on a single hot actor.

Every actor gets its own folder

Keep uploads, exports, and working files beside the rows that describe them. A file write commits with the command that made it.

Plain POSIX paths
Read and write with the file calls you already know.
One owner
Only the actor touches its folder, so files never race.
Commits with state
A rename lands in the same turn as the rows beside it.
Forks share blocks
A 50 GiB volume forks in 0.63 ms at p99. Landing now.

Search without a second system

Vector, BM25, and hybrid ranking run inside the actor’s own SQLite, so the index can’t drift from the data. Search is landing now.

Hybrid ranking
0.43 ms at p99 over 100k vectors on c8id.
Six plain tables
The index is ordinary SQLite tables inside the actor.
Scoped to the actor
A query reads one actor’s rows and nothing else.
Forks with the data
Fork an actor and its index comes with it.

Live updates from every actor

Clients join an actor’s room and receive each event as it happens. Presence shows who is connected without touching the database.

Live queries
Results update when the rows under them change.
Presence
Know who is in a room, held in memory only.
One connection
Updates and presence share one connection.
UI hooks
React, Solid, and Svelte hooks ship with the SDK.

Measured on real hardware, not promised.

Every number on this page comes from AWS c8id instances, with the setup and the caveat beside it. Targets we haven’t proven yet are labeled as targets.

FIG. 1 3-AZ quorum commit, 10,000 samplesc8id.large ×3, us-west-2a/b/c, io_uring O_DIRECT

commit latency, ms

0.76 ms
Commit across three zones at p99
Standalone write-ahead log commit. Not yet wired to akterd SQLite inserts.
0.63 ms
To fork a 50 GiB volume at p99
dm-thin copy-on-write on c8id.xlarge, 200 runs, activation included.
47.5k/s
Commands on a single hot actor
64 clients at 2.36 ms p99. Durable Objects soft limit is about 1,000 req/s.

akterd figures use local NVMe and a Rust echo worker. Full three-zone end-to-end numbers are still targets.

Methodology and raw runs

Six layers you never have to wire together.

From the client in your app to the bucket you own, every layer is part of one engine with one contract.

Break a zone. Watch the quorum hold.

The same quorum code that runs akterd, compiled to WebAssembly and running in this page. Nothing here is a video.

epoch … · p99 … · … commits/s

us-west-2aidle
…
us-west-2bidle
…
us-west-2cidle
…

      FIG. 3 crates/sim-wasm, running in your browserSimulated · needs JavaScript to run

      Four meters. Nothing for idle.

      Pay for what actors do, not for servers waiting. Every month starts with $5 of free usage, and spend caps stop cleanly.

      MeterPriceUnitWhat counts
      Writes$0.40per millionCommands, timers, and schedule runs.
      Reads$0.10per millionQueries and live updates pushed to clients.
      Storage$0.15per GiB-monthSQLite and Akter.fs, hot and cold.
      Compute$0.08per vCPU-hourRunning microVM time, billed per second.

      akter backupYour data exports continuously to your own bucket, readable with stock sqlite3 and tar.

      Start with one actor.

      Run akterd on your laptop with one command. Ship the same code to three zones when you’re ready.