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.
| greet, one core | greet, one core each | report, one core | report, one core each | |
|---|---|---|---|---|
| Cap'n Proto C++ | 10.5 µs | 14.8 µs | 10.8 µs | 15.1 µs |
| glowcap, Syrup | 8.8 µs | 13.1 µs | 10.5 µs | 14.8 µs |
| glowcap, Cap'n Proto codec | 8.9 µs | 12.7 µs | 9.8 µs | 13.9 µs |
| Cap'n Proto Rust | 19.4 µs | 19.6 µs | 19.1 µs | 19.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.
| suite | Goblins p50 (ms) | glowcap p50 (ms) | glowcap +tt p50 (ms) | Goblins req/s | glowcap req/s | glowcap +tt req/s |
|---|---|---|---|---|---|---|
| echo | 0.21 | 0.05 | 0.04 | 2,548 | 20,625 | 22,624 |
| registry | 0.44 | 0.1 | 0.09 | 1,079 | 10,684 | 10,495 |
| mint | 0.48 | 0.09 | 0.1 | 1,173 | 10,564 | 10,552 |
| taskboard | 1.04 | 0.19 | 0.17 | 552 | 5,128 | 5,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.
| actors | glowcap snapshot µs | Goblins snapshot µs | glowcap restore µs | Goblins restore µs |
|---|---|---|---|---|
| 64 | 0.5 | 7.9 | 2.3 | 3.4 |
| 256 | 2.7 | 33.1 | 9.6 | 12.3 |
| 1024 | 16.1 | 125 | 64.4 | 60.6 |
| 4096 | 134.6 | 559 | 347.3 | 254.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.