
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.
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 runsSix 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.
- 01Your appActors, commands, and queries in TypeScript with Effect, running beside the engine.
- 02Cap’n Proto ABIA language-neutral turn protocol between your code and the engine, local or cloud.
- 03akterdThe Rust supervisor that wakes, runs, and evicts actors, locally and in the cloud.
- 04SQLite and Akter.fsEach actor’s own database file and POSIX folder, committed together in one turn.
- 053-AZ quorum WALEvery commit lands on two of three NVMe replicas before the caller hears back.
- 06Your bucketContinuous export of .sqlite and .tar.zst files to object storage you own.
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
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.
| Meter | Price | Unit | What counts |
|---|---|---|---|
| Writes | $0.40 | per million | Commands, timers, and schedule runs. |
| Reads | $0.10 | per million | Queries and live updates pushed to clients. |
| Storage | $0.15 | per GiB-month | SQLite and Akter.fs, hot and cold. |
| Compute | $0.08 | per vCPU-hour | Running 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.