Baseline: zidl vs FlatBuffers vs Cap'n Proto

Historical document. Written on 2026-11-12, when the project was called zidl (later Graven). It is the first comparison against FlatBuffers and Cap'n Proto.

Obsolete for timings: the write methodology was biased against zidl (see round 2). Sizes and allocations remain valid.

Date: 2026-11-12 · Phases 1–2 of the plan runtime and benchmarks

Machine: Intel Core i9-14900HX (32 threads, up to 5.8 GHz), Linux 7.3 CachyOS, rustc 1.94.0, --release. Versions: flatbuffers 25.12.19 (flatc 25.12.19), capnp 0.27.3 (capnp 1.5.0), criterion 0.8.2. How to reproduce (at the time):

cargo bench -p zidl-bench --bench codec
cargo run --release -p zidl-bench --bin sizes
cargo run --release -p zidl-bench --bin allocs

All formats pass the same equivalence test (crates/zidl-bench/tests/equivalence.rs): the same checksum for 20 seeds × 4 scenarios.

Fairness notes

• Reused contexts. zidl uses SimplePool. FlatBuffers uses FlatBufferBuilder::reset() and a reused offsets vector. Cap'n Proto uses a reused ScratchSpaceHeapAllocator.
• Cap'n Proto writing. The output is serialize::write_message into a reused Vec, which includes a copy of the segments. Without that copy (a writev of the segments) it would be a little faster.
• Lists in Cap'n Proto. Cap'n Proto needs to know the list's size before writing it. The zidl column in bank uses a streaming list, the hard path. The zidl_known column uses a known count, comparable to Cap'n Proto.
• "Unverified" reading:
  • FlatBuffers: root_unchecked.
  • Cap'n Proto: traversal_limit = None. It still checks bounds, because Cap'n Proto always does.
  • zidl: read(), which validates required fields and checks bounds on every access.
• "Verified" reading:
  • FlatBuffers: root(), with the full verifier.
  • Cap'n Proto: the default ReaderOptions. Its verification is lazy, so it changes almost nothing.
  • zidl: a full verify() followed by read_all.
• Strings. zidl validates UTF-8 on every string read. FlatBuffers root_unchecked and Cap'n Proto as_bytes() do not. There is no measured _unchecked variant yet (see next steps).
• Optionals. FlatBuffers omits scalars equal to the default, which favors it in size when there are zeros. Cap'n Proto has no optional scalars; we use union { none; value }.

Size (bytes per message)

Allocations per written message (after warm-up)

Condition: the pool packs consecutive messages into the same 64 KiB chunk (split()), and only asks for a new chunk when less than ¼ is left. Messages dropped before the next one ⇒ 0 allocations. With 4 messages in flight (a send queue) ⇒ < 0.05 allocations/message (test in_flight_messages_amortize_allocations). The memory held is ≈ the size of the messages in flight + 1 chunk.

Time (median, ns)

Writing

¹ Only bank has a streaming variant; in the other rows the first column is zidl's only measurement (known count).

Reading every field (unverified)

Reading one field

Full read with verification

Verdict per criterion (spec §8)

Hypotheses for the losses (to validate in the next round)

1. Fixed write overhead (~30 ns).
   • Likely cause: SimplePool takes a Mutex twice per message (take and give). Add reserve and split().freeze().
   • Next step: measure with a thread-local pool, or reuse the Builder itself.
2. Writing lists is slower than Cap'n Proto.
   • Likely causes: every set goes through fixed_buf() (a match), plus a bounds check and set_bit. push uses resize with a zero-fill per element. With streaming, add the final memcpy and the pointer fix-up.
   • Cap'n Proto does one memset of the whole list and then only stores.
   • Next steps: zero the list in one block, set without a redundant bounds check, and specialize TableW for "fixed part in the main buffer".
3. read() costs ~4 ns more than root_unchecked.
   • Cause: check_required walks the Req list. Spec §4.3.1 asks for an AND with a precomputed mask; that was not implemented in this phase.
   • In lists, from_ref validates the required fields of every element (frame/500 = 500 validations).
   • Next steps: a mask per byte of bits, and validating elements once per list when elem_fixed_len covers the reader's layout.
4. Strings in bank.
   • Cause: zidl validates UTF-8 and the others do not.
   • Next step: measure the str_unchecked variant and/or validate UTF-8 only in verify().
5. The "no alignment" hypothesis did not turn out to be a problem.
   • In the scalar scenarios (telemetry, chunk, frame/10) zidl reads faster than both.
   • The read losses come from validation (items 3 and 4), not from unaligned access.