Beside other systems

These charts compare the same calls in glowcap, Cap’n Proto RPC, and Spritely Goblins. Each comparison runs on one machine in the same benchmark run, with test programs of the same shape. Performance reports glowcap’s own costs and checked budgets.

Benchmark snapshot of source v0.1.6-62-g19c1286a2 on 2026-11-15: Linux aarch64, 20 logical CPUs, 122 GiB RAM, Racket v9.3 CS, Spritely Goblins v0.18.0-52-gdcc2b2c5, and the glowcap archives built by Zig 0.17.1 in ReleaseFast. zig build bench-site-report repeats it.

A call beside Cap’n Proto RPC

Cap’n Proto RPC grew from the same ideas as CapTP, the protocol glowcap implements: calls pass object references, and a call can go to an answer that has not arrived. bench-capnp times two calls in the C++ reference library and in the capnp-rpc Rust crate. greet is the smallest message that is still a call. report is one application batch of a name, eight tags, and sixty-four readings, which the server sums. glowcap’s bars are the same two calls over its tcp transport, once under its Syrup codec and once under its Cap’n Proto codec.

Every bench runs a client thread and a server thread in one process over loopback TCP. The client makes one call at a time, and both threads sleep between calls, so every bar pays the same wakeups. The first group pins both threads to one core and the second gives each its own core.

Every client builds the request, sends it, and reads the reply’s fields inside the timed window, and compares them after the clock stops. The C++ bench and its generated code are compiled with full optimization (-O3), and the Cap’n Proto library it links keeps its own build settings. The Rust row runs the capnp-rpc crate on a current-thread tokio runtime through the futures compat layer.

Latency is the median (p50) of 3,000 calls from the run identified above. The benchmarks README describes the workloads and how to compare repeated runs.

Cap'n Proto C++glowcap, Syrupglowcap, Cap'n Proto codecCap'n Proto Rust
greet: one small call round trip over loopback TCP, p50 µs, lower is better.
10.5 8.8 8.9 19.4 one core 14.8 13.1 12.7 19.6 one core each
report: one application batch (a name, eight tags, sixty-four readings) answered with its count and sum, p50 µs, lower is better.
10.8 10.5 9.8 19.1 one core 15.1 14.8 13.9 19.1 one core each
greet, one coregreet, one core eachreport, one corereport, one core each
Cap'n Proto C++10.5 µs14.8 µs10.8 µs15.1 µs
glowcap, Syrup8.8 µs13.1 µs10.5 µs14.8 µs
glowcap, Cap'n Proto codec8.9 µs12.7 µs9.8 µs13.9 µs
Cap'n Proto Rust19.4 µs19.6 µs19.1 µs19.1 µs

The same app on glowcap and Goblins

Each application is written once in Racket and run with two backends: Spritely Goblins and glowcap’s Racket binding. The actors run in Racket, so these results do not measure glowcap’s Zig actor runtime or concurrent load. The “glowcap + time-travel” row enables snapshot support without taking snapshots. The benchmark methodology explains what is held constant.

Goblinsglowcap bindingglowcap binding + time-travel
Latency (p50 ms, lower is better).
0.21 0.05 0.04 echo 0.44 0.1 0.09 registry 0.48 0.09 0.1 mint 1.04 0.19 0.17 taskboard
Throughput (req/s, higher is better).
2.5k 20.6k 22.6k echo 1.1k 10.7k 10.5k registry 1.2k 10.6k 10.6k mint 552 5.1k 5.4k taskboard
suiteGoblins p50 (ms)glowcap p50 (ms)glowcap +tt p50 (ms)Goblins req/sglowcap req/sglowcap +tt req/s
echo0.210.050.042,54820,62522,624
registry0.440.10.091,07910,68410,495
mint0.480.090.11,17310,56410,552
taskboard1.040.190.175525,1285,445

Time-travel: snapshot and restore

A snapshot saves every actor’s state, and a restore rewinds them to it. This run varies actor count and bytes per actor.

Goblinsglowcap
Snapshot (µs by actor count).
7.9 0.5 64 33.1 2.7 256 125 16.1 1024 559 134.6 4096
Restore (µs by actor count).
3.4 2.3 64 12.3 9.6 256 60.6 64.4 1024 254.5 347.3 4096
actorsglowcap snapshot µsGoblins snapshot µsglowcap restore µsGoblins restore µs
640.57.92.33.4
2562.733.19.612.3
102416.112564.460.6
4096134.6559347.3254.5

Both runtimes share each actor's state instead of copying it, so snapshot cost follows the number of actors, not their size. A glowcap snapshot takes 16.2 µs with 64-byte actors and 33.4 µs with 16384-byte actors. The runtimes differ, so compare their trends, not their absolute times. On restore, glowcap frees rewound copies immediately, and Goblins leaves that cleanup to its garbage collector.