Skip to content

Benchmark: the reference PDS, Monolith, vlpds, zds and tranquil

harness/bench.mjs, run with just bench (node bench.mjs --setup && node bench.mjs --rounds 3 --json ../bench/results.json), from a clean state (see The PDS benchmark). There are three rounds per implementation, one implementation at a time, and every one runs in Docker the same way. Each round is a fresh container on a fresh volume, registering with a fresh in-memory PLC directory (@did-plc/server) run by the bench. Every round warms the server the same way first: each part and route at a tenth of its size, on accounts of its own. It then runs the parts, the routes, the curves by the number of callers, the mix and the subscribers coming and going. A storage round of each follows. README.md, “What it measures”, says what each of those is. The raw numbers of every round, and every server’s recorded configuration, are in bench/results.json.

  • Apple M1 Pro, 8 cores, 32 GiB, macOS 26.5.2 (arm64), APFS on the internal SSD. Docker Desktop 28.0.1, its Linux VM given 8 CPUs and 7.7 GiB. Every server, and the client’s ceiling responder, runs in that VM.
  • The client: Node v24.22.1, 4 worker threads (harness/lib/loadpool.mjs).
  • The load on the machine was not light (see “Caveats”). The 1-minute load average was 3.7 when the run started; at each round’s start and end it was:
    • Monolith 6 to 13;
    • the reference 9 to 10;
    • vlpds 6 to 29;
    • zds 13 to 16;
    • tranquil 8 to 22.
  • Pins, as bench/impls.json has them and results.json records:
    • Monolith: this repository’s Dockerfile (Rust 1.98 on Debian trixie, as deployed), built from 42abe3c. That is the last commit to change what the image is built from, and the commit the run was at. Image sha256:044e78d7…, linux/arm64.
    • reference: @atproto/pds 0.5.55 from npm, started through @atproto/dev-env 0.6.26’s TestPds as perf.mjs does, pinned by harness/package-lock.json. It runs in the image bench/docker/reference.Dockerfile builds (Node 24.22.1 on Debian trixie), sha256:fd421a48…, linux/arm64.
    • vlpds: release v1.3.0 of jazware/vlpds, commit 91fa452993865b2f91ff5ed5b87fc28356796d0c, its release image ghcr.io/jazware/vlpds@sha256:e1aca7934017bb757ef3717bbd964ae758cf704dc623703262c512fd462c0477 (linux/arm64 here).
    • RustFS 1.0.4, vlpds’s S3 store: rustfs/rustfs@sha256:ed9210d6411d77ffceb70d94b964a3cb7d225983368bc25bebe01e995293dcc2. It passed vlpds-bucket-probe (from the vlpds image): all six correctness checks, SAFE for vlpds.
    • zds: release v0.7.8 of tangled.org/zat.dev/zds, commit cef2c63d7d6d7dd87b90100566307e9aa8a4d170, built by --setup with its own Dockerfile (Zig 0.17.0, -Doptimize=ReleaseSafe) into monolith-bench-zds:cef2c63, image sha256:124944cb…, linux/arm64. Its published image (atcr.io/zat.dev/zds:latest) is amd64 only and predates v0.7.8, so it was not used.
    • tranquil: release v0.8.0 of tangled.org/tranquil.farm/tranquil-pds, commit ce17e8a4948aa216c6c1056122966a11b8a693c8, built by --setup with its own Dockerfile (Rust 1.99.1 on Debian trixie, the binary UPX-compressed, on distroless) into monolith-bench-tranquil:ce17e8a, image sha256:a6a27312…, linux/arm64. Its published image (atcr.io/tranquil.farm/tranquil-pds) needs a login to pull, so it was not used.
    • PostgreSQL 18.7, tranquil’s database: postgres@sha256:1018733457011bf88d81db98cf43aac6d5150afc18787dbe204771fedf80ff95 (postgres:18-alpine, as tranquil’s compose files run it).

As its image runs it (docs/guide/deploying.md): PDS_PORT=2583, PDS_BIND_ADDRESS=::, PDS_DATA_DIR=/data, with /data a fresh volume each round. The bench adds only what a local benchmark needs:

  • PDS_HOSTNAME=localhost and PDS_PUBLIC_URL=http://127.0.0.1:<port>;
  • handle domains .test,.example;
  • the bench’s PLC directory (http://host.docker.internal:<port>), with a fresh secp256k1 rotation key each round;
  • rate limits off and invites not required;
  • every private range trusted as a proxy, so that subscribers’ addresses in X-Forwarded-For count.

It is also given an AppView, PDS_BSKY_APP_VIEW_URL=http://127.0.0.1:9 with did:web:api.bsky.app, as every server on the network has one. Without it, getPreferences is not served (spec/PROXY.md). Nothing in the workload is forwarded there. Its DID cache is as it comes (PDS_DID_CACHE_SECS, an hour). In the storage round only, PDS_REPO_BACKFILL_LIMIT_MS=10000.

As perf.mjs runs it: dev-env’s TestPds with rateLimitsEnabled: false, inviteRequired: false and hostname: localhost, its dataDirectory and blobstoreDiskLocation under /data, a fresh volume each round (harness/bench-reference.mjs). It listens inside its container on the port it is reached at, and registers DIDs with the bench’s PLC directory through host.docker.internal. In the storage round only, repoBackfillLimitMs 10000.

As its docs run a single node: the release image’s tiny profile (deploy/ansible/roles/vlpds/defaults/main.yml at v1.3.0, the profile docs/operations/deploy.md describes for one node): a 2560 MiB container memory limit (--memory 2560m --memory-swap 2560m, which sizes its caches), --stop-timeout 90, VLPDS_NODE_ID=single, VLPDS_SHARDS=1, VLPDS_LEASE_TTL_MS=60000, VLPDS_SLATEDB_MANIFEST_POLL=60s, a 4096 MiB SST disk cache on a Docker volume, and tiny’s firehose, backfill and export sizes (--firehose-ring-mb 64, live ring 32, merge queue 32, max lag 64, backfill cache 32 / read-ahead 16, 4 backfills, 4 exports, MST node cache 64, 1 firehose thread). Threads are its defaults (I/O = the 8 cores the VM shows, workers = 4). VLPDS_PLC_MODE=directory with a fresh secp256k1 rotation key, and fresh random JWT secret, admin and internal tokens and KEK each round (not --dev-mode). The bench’s own changes, as for the others: rate limits off (VLPDS_NO_RATE_LIMITS), invites not required (its default), the bench’s PLC directory (http://host.docker.internal:<port>), a loopback URL (VLPDS_PUBLIC_URL=http://127.0.0.1:<port>), and nothing sent off the machine (--crawlers= for no relays, --asn-lookup off). Each round runs on a Docker network of its own with a fresh RustFS container and volume, and the bucket made through the S3 API; vlpds’s container and RustFS’s are made before the start clock and removed, with their volumes and network, after the round. In the storage round only, VLPDS_LOG_RETENTION=10s and VLPDS_LOG_RETENTION_INTERVAL=5s.

As its deployment runs it (docs/deployment.md, fly.toml), on its Dockerfile’s ENV (ZDS_HOST=0.0.0.0, ZDS_PORT=2583, ZDS_DB=/data/zds.sqlite3) with ZDS_BLOBSTORE_PATH=/data/blobs, /data a fresh Docker volume each round; a fresh secp256k1 ZDS_PLC_ROTATION_KEY, ZDS_JWT_SECRET and ZDS_ADMIN_TOKEN each round; no memory limit (its deployment’s 1 GiB is the Fly VM’s, not a zds setting). zds has no dev mode. Its defaults kept: handle domains .test, invites not required, permissioned data off, mail provider comail (createAccount sends no mail, and with no Comail key nothing is sent). The bench’s own changes: its PLC directory (ZDS_PLC_DIRECTORY=http://host.docker.internal:<port>), a loopback URL (ZDS_PUBLIC_URL=http://127.0.0.1:<port>, from which it derives did:web:127.0.0.1%3A<port>), no relays asked to crawl (ZDS_CRAWLERS=, in place of bsky.network and vsky.network), and ZDS_MAX_CONCURRENT_REPO_EXPORTS=8. zds has no general rate limits to turn off; its cap on full getRepo exports at once (4 by default, a 429 past it) is the one limit the workload hits, and it is raised to the 8 the workload runs at once. Its container is made before the start clock and removed, with its volume, after the round; zds is its container’s PID 1 with no SIGTERM handler, so the bench kills it rather than wait out docker stop.

As its container docs run it (docs/2_INSTALL_CONTAINERS.md, docker-compose.prod.yaml): on PostgreSQL, its default repository backend, with blobs as files under /var/lib/tranquil-pds/blobs (a fresh Docker volume each round) and its in-process cache (ripple, one node); the image’s SERVER_HOST=[::], SERVER_PORT=3000; PDS_HOSTNAME=tranquil.test, its handles under that; fresh random JWT_SECRET, DPOP_SECRET and MASTER_KEY each round. It signs PLC operations with each account’s own key, so it has no rotation key to give. The bench’s own changes: rate limits off (DISABLE_RATE_LIMITING), invites not required (INVITE_CODE_REQUIRED=false), its PLC directory (PLC_DIRECTORY_URL=http://host.docker.internal:<port>), private addresses fetchable so that it reaches that directory (ALLOW_PRIVATE_FETCH), no relays asked to crawl (CRAWLERS=,, a list of none), the gate that holds an account’s logins and record writes until it verifies an email off (DISABLE_ACCOUNT_VERIFICATION_GATE), and MAX_CONCURRENT_REPO_EXPORTS=8, raised from 4 as zds’s is. With no sender address its email is off, so createAccount sends no mail. Its passwords need an upper-case letter, so the bench’s accounts’ have one. PostgreSQL runs at its defaults (max_connections 100, shared_buffers 128 MB, fsync and synchronous_commit on), as user tranquil_pds and database pds with a fresh password. Each round runs on a Docker network of its own with a fresh PostgreSQL container and volume, ready for connections before the start clock; both containers are removed, with their volumes and network, after the round. tranquil has no setting that makes a backfill window of 10 s, so its storage round runs on its defaults.

  • Apple M1 Pro, 8 cores, 32 GiB, macOS 26.5.2 (arm64); Node v24.22.1; Docker 28.0.1, its Linux VM 8 CPUs, 8218316800 bytes.
  • Load average (1 min): 3.7 at the start, 13.3 at the end; 6.2 to 28.5 at the rounds’ starts and ends.
  • The client: 4 worker threads, each with its own connections, kept alive. Its ceiling, a responder in Docker answering every request with 2 bytes and doing nothing else, requests per second (the best of three):
at once148163264256
per s18765351809313634181222309828688

Each part’s requests per second (replay: events sent per second), the mix’s, start time and memory, each the best round; for the firehose’s live parts, the p50 of their lag, the best round. Detail follows.

referencemonolithvlpdszdstranquil
createAccount per s33633969
createRecord per s1293507582445316
applyWrites per s712205303323136
getRecord per s11558258 ‡434326622454
listRecords per s5484230253119531608
getRepo per s36529541191690108
uploadBlob per s1541175131405315
createRecordSerial per s955766822355
firehose lag p50 ms1.00.52.414.03.7
firehoseLoaded lag p50 ms11.54.34.6not served21.0
replay per s1182541549202745378119302
mix per s37540901331614 ◊736
start ms314618013653991105
idle RSS MiB (median)376.119.3177.116.537.6
peak RSS MiB828.4152.4501.254.5138.2

‡: at least 50% of the client’s ceiling at the same concurrency (above): the client may be part of what limits it. ◊: the server closed each connection after its answer, the client opened one a request, and it ran out of local ports and waited for them (each closed connection holds its port for a while): the rate is held to how fast they came back, and the times are from when each request was sent.

40 requests, 4 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)max ms (best)max ms (median)
reference3332107.4118.7162.7171.3
monolith636257.659.781.582.1
vlpds3934101.8114.4147.8175.3
zds66560.7708.71444.91618.2
tranquil98431.6459.5487.3628.8

1000 requests, 16 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference129127121.9123.6160.5174.2
monolith350733653.83.920.520.9
vlpds58258021.524.650.055.3
zds44544029.629.999.0102.0
tranquil31630346.248.2113.7130.6

200 requests, 8 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p95 ms (best)p95 ms (median)
reference7170109.3111.2133.4133.4
monolith220519873.43.75.06.2
vlpds30328321.825.342.444.5
zds32331021.922.047.650.8
tranquil13612755.357.381.690.6

2000 requests, 16 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference1155114012.712.731.932.0
monolith8258 ‡78601.61.75.96.8
vlpds434341262.72.919.020.1
zds266222524.65.121.927.5
tranquil245424315.35.527.928.7

1000 requests, 16 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference54853726.126.254.170.5
monolith423041103.03.116.117.5
vlpds253123914.84.923.130.1
zds195318556.97.124.125.5
tranquil160814068.79.833.236.3

1000 requests, 8 at once.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference36536119.419.942.548.3
monolith295426442.42.45.912.5
vlpds11919544.96.428.628.6
zds69063710.010.331.632.5
tranquil10810469.470.0128.8154.4

1000 requests, 8 at once, of 64 KiB each; then, not timed, a record of each account referring to its first blob, for getBlob.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference15415248.148.990.493.7
monolith117511365.35.421.021.5
vlpds13113158.259.7105.4108.2
zds40537816.017.453.257.8
tranquil31529922.622.754.658.3

1000 requests, one after another, as one person posting: no other write to share a sync with.

implper s (best)per s (median)p50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference95939.29.428.629.6
monolith5765721.41.56.06.4
vlpds686711.512.241.744.2
zds2232143.63.620.422.1
tranquil555515.815.946.850.5

100 putRecords one after another, 20 subscribers; each time is the firehose’s lag, from a write’s answer to a subscriber having its commit, 0 when the commit came first. No rate: the writes’ would be the write path’s, which the write parts measure.

implp50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference1.01.16.315.0
monolith0.50.52.93.0
vlpds2.42.617.921.2
zds14.015.362.366.5
tranquil3.73.823.624.9

400 putRecords, 16 at once, each to a different account, 20 subscribers; each time is the firehose’s lag, from a write’s answer to a subscriber having its commit, 0 when the commit came first. No rate: the writes’ would be the write path’s, which the write parts measure.

implp50 ms (best)p50 ms (median)p99 ms (best)p99 ms (median)
reference11.513.047.153.1
monolith4.310.222.940.0
vlpds4.64.823.125.5
zdsnot served: its live firehose skips commits when writes come at once: of a warm-up of 40 putRecords, 4 at once to 4 accounts, each of 20 subscribers was sent 34 to 37 (its log: subscribeRepos end start_cursor=466 end_cursor=506 frames=35), so no lag can be timed for the rest
tranquil21.022.662.375.0

4 subscribers from cursor 0, as relays catching up: each is sent every event the server made in the round, warm-up and all, then a write made once all are connected. Throughput is the events sent to them all up to that write’s commit, per second; each time is a subscriber’s, from asking to having that commit.

implper s (best)per s (median)p50 ms (best)p50 ms (median)max ms (best)max ms (median)
reference11825116391079.71096.91079.71097.0
monolith4154940703276.7308.1307.3313.7
vlpds2027417750606.0693.2611.8701.7
zds5378145960197.9237.5204.7239.5
tranquil1930215850663.0811.1670.6816.7

The routes a client calls most, besides the parts above, each measured alone: requests per second, then the p50 and the tail of their times, each the best round. A route a server answered with no 2xx in the warm-up is not served, with its answer.

routen, at oncereference per sp50 mstail msmonolith per sp50 mstail msvlpds per sp50 mstail mszds per sp50 mstail mstranquil per sp50 mstail ms
describeServer1000, 1642853.120.0 (p99)7939 ‡1.65.6 (p99)49442.417.8 (p99)39913.418.1 (p99)47182.619.5 (p99)
oauthMetadata1000, 1634744.29.1 (p99)9120 ‡1.54.2 (p99)28354.221.4 (p99)36303.511.3 (p99)56212.36.4 (p99)
createSession200, 822355.5362.7 (p95)22354.7364.0 (p95)72109.3146.8 (p95)29234.4426.5 (p95)15525.9697.9 (p95)
getSession1000, 1622146.723.5 (p99)8260 ‡1.75.2 (p99)42433.019.8 (p99)18486.430.4 (p99)21286.625.2 (p99)
getPreferences1000, 16139410.627.8 (p99)8349 ‡1.66.3 (p99)50672.618.4 (p99)27414.520.2 (p99)19926.828.1 (p99)
getServiceAuth1000, 1670020.744.2 (p99)9081 ‡1.63.5 (p99)37543.021.6 (p99)25305.422.4 (p99)22326.025.4 (p99)
resolveHandle1000, 1631714.818.8 (p99)8309 ‡1.513.8 (p99)29444.132.4 (p99)33234.012.3 (p99)55482.119.6 (p99)
describeRepo1000, 16131711.129.6 (p99)8176 ‡1.66.1 (p99)25165.028.1 (p99)29564.320.6 (p99)25875.136.1 (p99)
getLatestCommit1000, 16136710.526.4 (p99)9889 ‡1.53.0 (p99)39402.921.4 (p99)36633.521.3 (p99)32574.127.2 (p99)
syncGetRecord1000, 1651327.963.0 (p99)8563 ‡1.73.7 (p99)30054.120.4 (p99)94714.343.8 (p99)14569.332.0 (p99)
listRepos1000, 16111812.629.1 (p99)57982.210.2 (p99)64021.769.8 (p99)14169.334.7 (p99)32844.386.1 (p99)
getBlob1000, 1657824.852.9 (p99)17338.225.7 (p99)79516.655.4 (p99)15449.025.8 (p99)113612.434.9 (p99)
refreshSession1000, 16108711.044.6 (p99)46392.816.8 (p99)62020.864.1 (p99)368 ◊34.6134.8 (p99)67121.348.7 (p99)

‡: at least 50% of the client’s ceiling at the same concurrency (above): the client may be part of what limits it. ◊: the server closed each connection after its answer, the client opened one a request, and it ran out of local ports and waited for them (each closed connection holds its port for a while): the rate is held to how fast they came back, and the times are from when each request was sent.

Each at 1, 4, 16, 64, 256 callers at once: requests answered with a 2xx per second, and the p50 and tail of their times, the best round; and how many were answered otherwise, in the median round, counted rather than stopped at.

callersreferencemonolithvlpdszdstranquil
1473/s, p50 1.9, p99 6.1 ms1309 ‡/s, p50 0.7, p99 1.9 ms557/s, p50 1.2, p99 17.1 ms518/s, p50 1.6, p99 7.9 ms365/s, p50 2.2, p99 17.0 ms
41120/s, p50 3.1, p99 16.7 ms3855 ‡/s, p50 0.9, p99 2.6 ms1493/s, p50 1.9, p99 19.2 ms1452 ◊/s, p50 2.3, p99 11.4 ms1113/s, p50 2.9, p99 20.3 ms
161250/s, p50 11.6, p99 29.1 ms8742 ‡/s, p50 1.5, p99 4.6 ms3993/s, p50 3.0, p99 20.6 ms238 ◊/s, p50 4.2, p99 18.5 ms2592/s, p50 5.2, p99 26.8 ms
641289/s, p50 42.6, p99 202.0 ms15886 ‡/s, p50 3.7, p99 11.5 ms7865/s, p50 6.2, p99 28.5 ms317 ◊/s, p50 11.7, p99 42.1 ms3785/s, p50 14.0, p99 62.1 ms
2561370/s, p50 76.6, p99 4127.2 ms18286 ‡/s, p50 8.8, p99 34.0 ms12314/s, p50 19.4, p99 40.6 ms923 ◊/s, p50 40.6, p99 220.5 ms4260/s, p50 51.4, p99 122.2 ms
callersreferencemonolithvlpdszdstranquil
194/s, p50 9.6, p95 17.2 ms604/s, p50 1.4, p95 2.6 ms71/s, p50 11.3, p95 30.3 ms214/s, p50 3.6, p95 9.7 ms48/s, p50 18.4, p95 38.9 ms
4112/s, p50 33.3, p95 51.7 ms1543/s, p50 2.1, p95 3.8 ms164/s, p50 20.5, p95 45.0 ms354/s, p50 8.1, p95 28.6 ms130/s, p50 26.5, p95 51.4 ms
16115/s, p50 135.5, p95 161.1 ms3331/s, p50 4.0, p95 10.5 ms596/s, p50 22.4, p95 46.1 ms341/s, p50 34.5, p95 97.5 ms246/s, p50 60.4, p95 87.7 ms
64119/s, p50 533.1, p95 579.6 ms4025/s, p50 11.6, p95 39.5 ms1655/s, p50 31.7, p95 56.1 ms334/s, p50 111.7, p95 476.9 ms292/s, p50 185.6, p95 341.4 ms
256111/s, p50 2185.5, p99 2600.0 ms4133/s, p50 48.0, p99 103.7 ms3281/s, p50 65.3, p99 135.9 ms336/s, p50 523.1, p99 2001.6 ms291/s, p50 778.0, p99 1315.1 ms

10000 requests, 32 at once, of each 100 so many of each route, with 2 subscribers to the firehose: requests per second, then each route’s p95 in the mix beside its p95 measured alone (the parts’ and the routes’ tables), the best round, in ms.

routeof 100reference p95 in mixalonemonolith p95 in mixalonevlpds p95 in mixalonezds p95 in mixalonetranquil p95 in mixalone
all, per s37540901331614 ◊736
getSession1554.112.412.83.416.97.197.218.622.813.9
getPreferences1067.717.013.23.513.55.881.311.226.713.8
getRecord2570.020.013.63.315.98.181.011.820.810.4
listRecords15108.347.314.27.222.312.883.315.423.917.1
describeRepo568.716.913.53.519.412.565.511.412.110.6
getBlob10249.845.119.817.322.042.077.719.217.328.8
getLatestCommit563.018.412.22.410.99.275.19.712.37.8
createRecord10149.0149.523.58.3104.242.9121.175.6365.583.8
applyWrites3194.4133.424.15.0102.142.4118.847.6331.481.6
uploadBlob2242.171.418.114.3146.189.292.441.154.745.3

11 cohorts of 20 subscribers, each from an address of its own: a cohort connects, has one write’s commit and goes. The server’s threads and RSS 2 s after the first cohort went and 2 s after the last, and how many of the subscribers it refused, the median round.

implthreads after the firstafter the lastRSS MiB after the firstafter the lastrefused, of all
reference1111843.1843.20 of 220
monolith234234121.0118.10 of 220
vlpds3030505.0504.50 of 220
zds444448.648.80 of 220
tranquil131393.494.10 of 220

Start: from docker start of the server’s container, made already, to its first answered describeServer, on an empty volume. Idle RSS: 2 s after start, before any request. Peak RSS: the most sampled (every ~100 ms) through the warm-up and the whole round. Each the server’s own process in its container, from docker top.

implstart ms (best)start ms (median)idle RSS MiB (median)peak RSS MiB (best)peak RSS MiB (median)
reference31463193376.1828.4843.6
monolith18025719.3152.4188.8
vlpds13651394177.1501.2515.2
zds39943416.554.554.6
tranquil1105116437.6138.2147.0

Not in the table above: what a server needs running beside it, its RSS sampled apart (the sum over its container’s processes, from docker top, as fast as that answers; for PostgreSQL, whose processes share its buffers, the sum of their PSS, which counts each shared page once).

implbeside itidle MiB (median)peak MiB (best)peak MiB (median)
vlpdsRustFS172.0435.4487.4
tranquilPostgreSQL57.1522.7534.5

From each implementation’s storage round, apart from the rounds above: a fresh server started with a backfill window W of 10 s where it has a setting for one, the same warm-up of the parts and the parts, whose speed is not kept (a short window changes what replay sends). What it keeps on disk: the sum of the sizes of the files on its container’s volume (its log goes to docker logs, not there). Under load: once the parts end, after replay. At rest: after the parts, no request for 2 W + 1 s (21 s), then one createRecord to each account the round made, the warm-up’s too, then the size sampled every 500 ms for 10 s, the least kept (spec/STORE.md, “Bounds”). Live state: of each of those accounts, its getRepo, the blobs listBlobs lists and the uploads no record references.

implbackfill windowdata under load MiB (median)data at rest MiB (median)live state MiB (median)at rest ÷ live (median)
referenceW = 10 s94.895.469.81.37
monolithW = 10 s102.670.869.81.01
vlpdsW = 10 s1.61.769.80.02
zdsits default: no setting94.695.369.81.37
tranquilits default: no setting62.562.569.90.89

zds: zds has no setting for it: none of the ZDS_* variables its binary reads is a backfill window or an event retention, so at rest is measured with what it keeps by default.

tranquil: its backfill window is FIREHOSE_BACKFILL_HOURS, in whole hours (72 by default), and it prunes the events past EVENT_RETENTION_MAX_AGE_SECS (7 days by default, and never less than that window) once a minute at most: nothing sets a window of W with a pass in the quiet, so at rest is measured with what it keeps by default.

Not in the table above: what a server keeps in what runs beside it (vlpds: its bucket, the files on RustFS’s volume; tranquil: its database, the files on PostgreSQL’s volume), measured the same way at the same moments; the last column counts the server’s own and this together.

implbeside itunder load MiB (median)at rest MiB (median)both at rest ÷ live (median)
vlpdsRustFS76.678.71.15
tranquilPostgreSQL120.6121.02.63

pds.js is pinned, but only the compatibility check runs it: it hosts one account, and the workload makes 40. Cocoon, millipds and rsky-pds are not pinned, and tranquil ran only on PostgreSQL, not on tranquil-store, its embedded store. bench.mjs takes any of them as an adapter (README.md, “Adding an implementation”).

Every server served every part, route and section, with one exception: zds did not serve the firehose under load, as its table says.

  • The machine was not idle for the whole run. The run waited until the 1-minute load average was at most half the cores (3.7 at its start). Other work on the machine then rose: rounds started and ended at load averages of 6 to 29, highest while vlpds and tranquil ran. Every server’s numbers are lower and noisier than an idle machine’s would be. Best-of-three is reported for that reason, and the medians beside each best show the spread.
  • Every server ran in Docker Desktop’s Linux VM, behind its port forwarding. All five pay the same forwarding cost and see the same 8 CPUs, the same volume driver and the same path to the PLC directory. The forwarding has a cost of its own, which the client’s ceiling measures: about 1,900 requests a second one at a time, 13,600 at 16 at once, and 28,700 at 256 (the first table). A rate marked ‡ is at least half of that, and the client and the forwarding may be part of what holds it: Monolith’s getRecord at 16 at once, its fastest routes, and its getRecord curve at every number of callers.
  • Durability: every server’s syncs land on the VM’s virtual disk. Whether Docker Desktop passes them through to the Mac’s drive as a full flush was not established. On Linux, Rust’s sync_all/sync_data (Monolith), SQLite’s fsync (the reference, zds), PostgreSQL’s WAL flush (tranquil) and RustFS’s fsync (vlpds) are the same kind of call, so the five pay the same kind of sync. The write numbers are therefore far higher than a native run with macOS’s F_FULLFSYNC, for Monolith most of all (createRecord 3,507 a second here, against 369 natively with F_FULLFSYNC). They show each server’s write path under the same sync, not the cost of a sync through a drive’s cache. Blobs: the reference writes them with fs.writeFile and zds with fwrite, and neither syncs them; Monolith syncs a blob’s file when a commit first references it, not when it is uploaded (spec/DURABILITY.md, “Blobs”); tranquil syncs each to a temp file before renaming it into place; vlpds’s are PUT to RustFS, which syncs them.
  • zds closes every connection after its answer (connection: close), so the client opens a connection a request. At a few hundred a second the client ran out of local ports, as each closed connection holds its port for a while. A request then waited for one and was sent again (README.md, “A connection a request”). That is marked ◊: zds’s getRecord curve at 4, 16, 64 and 256 callers, its refreshSession and its mix. Its rate there is held to how fast the client’s ports came back (238 a second at 16 callers, against 2,662 in the getRecord part at 16 at once), not to zds. A server’s many clients each have ports of their own.
  • zds’s mix is its single connection. zds keeps everything in one SQLite database on one connection. In the mix, every read’s p95 rose to 65–97 ms beside the writes, from 10–19 ms alone, where Monolith’s, vlpds’s and tranquil’s reads stayed within 11–27 ms.
  • The reference’s writes do not climb with callers. Its createRecord stays at about 115 a second from 4 callers to 256, with p50 growing from 33 ms to 2.2 s. Its getRecord stays at about 1,300 a second from 16 callers on, with p99 4.1 s at 256.
  • vlpds’s writes are batched across requests. Every write on the node goes into one log, group-committed into segments that are PUT to the bucket. Its createRecord climbs with callers (71 a second at 1, 3,281 at 256) as more writes share a segment, while one write at a time (createRecordSerial, 68 a second) pays a whole PUT.
  • tranquil’s writes level off at about 300 a second. Its createRecord is 48 a second at 1 caller and 291 at 256, with p50 growing to 778 ms; in the mix its createRecord and applyWrites p95 rose to 331–366 ms, from 82–84 ms alone, while its reads stayed within 12–27 ms.
  • zds’s firehose skips commits under concurrent writes. Each of the 20 subscribers of the warm-up of firehoseLoaded (40 putRecords, 4 at once, each to a different account) was sent 34 to 37 of the 40 commits, by its own log (subscribeRepos end ... frames=), though the sequence numbers ran on by 40. Written one at a time, every commit reached every subscriber. So the part is not served for it: no lag can be timed for a commit not sent.
  • zds’s and tranquil’s limits raised. Their default cap of 4 full getRepo exports at once answers the workload’s 8 at once with a refusal. It was raised to 8 (ZDS_MAX_CONCURRENT_REPO_EXPORTS, MAX_CONCURRENT_REPO_EXPORTS), as rate limits are off for the others. zds’s other caps are not reached: 32 subscribeRepos connections (no part holds more than 20) and 4 cursor backfills at once (replay’s 4).
  • tranquil’s gates off. Its default holds an account’s logins and record writes until it verifies an email or other channel; with no mail leaving the machine, none could, and the other servers have no such gate. It is off for the run, as invite codes are for all of them.
  • replay’s events are each server’s own. Every server makes its own events for the same round, since an account’s creation is several events and not the same several everywhere. So replay compares events sent per second, not the time to send one fixed stream.
  • Storage. vlpds keeps almost nothing on its own volume (its SST cache, 1.7 MiB): its data is in the bucket, 79 MiB at rest, counted apart. tranquil keeps only its blobs on its own volume (62.5 MiB); its database, 121 MiB at rest, is counted apart. zds and tranquil have no backfill window to set to 10 s, so their at-rest sizes include every event of the round. The live state is about the same for all five, 69.8 MiB, nearly all of it the uploads no record references, which each server holds for an hour.
  • Memory. Every figure is the server’s own process in its container, from docker top: pds, Node’s MainThread, vlpds, zds, tranquil-pds. vlpds runs under a 2,560 MiB container limit, which sizes its caches; the others have none. RustFS’s memory is on top of vlpds’s and PostgreSQL’s on top of tranquil’s, each in a table of its own; PostgreSQL’s is the sum of its processes’ PSS, as they share its buffers. The PLC directory runs in the bench’s process and is counted for none. The reference’s figures include the Node runtime and dev-env’s module graph. tranquil’s binary is UPX-compressed, as its Dockerfile builds it, and unpacks into its memory at start.
  • createAccount includes the PLC operation to the bench’s directory, through host.docker.internal, for all five. createSession is about 22 a second for Monolith and the reference alike: it is their password hash. tranquil’s is 15 a second.