Cap'n Proto is a data interchange format and RPC system created by Kenton Varda, the author of Protocol Buffers v2. It was designed from the ground up to eliminate the encode/decode overhead that makes traditional serialization formats slow.

The key innovation is zero-copy reads: Cap'n Proto stores data directly in its wire format inside memory. Reading a field is a single pointer dereference — there is no deserialization step. Writing is direct memory layout — there is no serialization step either.

Cap'n Proto also includes a full RPC system with promise pipelining, capability references, and three-party handoff — features not present in FlatBuffers or Protocol Buffers.

Because Cap'n Proto uses the wire format as the in-memory representation, encoding and decoding approach zero nanoseconds. Compare to formats that require a full object graph construction on every read or write:

Cap'n Proto schemas are defined in .capnp files. Each file carries a 64-bit ID (generated by capnp id). Fields are numbered from @0 — numbers are stable identifiers that allow forward/backward compatible evolution.

@0xdeadbeefdeadbeef;  # 64-bit file ID (generate with: capnp id)

struct Person {
  name  @0 :Text;
  age   @1 :UInt32;
  email @2 :Text;
}

struct AddressBook {
  people @0 :List(Person);
}

Compile the schema to a binary blob and to C++ glue with:

# Compile to binary (used at runtime by LoadSchema)
capnp compile -o /dev/null --src-prefix=. schema.capnp  # validates
capnp compile -oc++ schema.capnp                        # emits schema.capnp.h + .c++

Struct field setters

Serialization

Struct field getters

List operations

uses capnproto;

var
  Schema : TCapnSchema;
  B      : TCapnBuilder;
  Root   : TCapnStruct;
  Data   : string;
  R      : TCapnReader;
begin
  { Load the compiled schema binary }
  Schema := LoadSchema('/path/to/person.capnp.bin');

  { ── Write ───────────────────────────────────────── }
  B    := NewBuilder;
  Root := InitRoot(B, Schema, 'Person');

  SetText(Root, 0, 'Alice');                   { name  @0 }
  SetUInt32(Root, 1, 30);                      { age   @1 }
  SetText(Root, 2, 'alice@example.com');       { email @2 }

  Data := Serialize(B);   { wire format — zero-copy layout }
  FreeBuilder(B);

  { ── Read ────────────────────────────────────────── }
  R    := NewReader(Data);
  Root := GetRoot(R);

  WriteLn(GetText(Root, 0));     { Alice }
  WriteLn(GetUInt32(Root, 1));   { 30    }
  WriteLn(GetText(Root, 2));     { alice@example.com }

  FreeReader(R);
  FreeSchema(Schema);
end.

Both formats are schema-driven and produce compact binary output. The fundamental difference is the memory model: