# Cap'n Proto — Insanely Fast Serialization and RPC

> A data interchange format and RPC system designed for zero-copy reads, created by the original author of Protocol Buffers as a successor with no encoding or decoding step.

## Install

Save as a script file and run:

# Cap'n Proto — Insanely Fast Serialization and RPC

## Quick Use
```capnp
# schema.capnp
struct Person {
  name @0 :Text;
  age  @1 :UInt32;
  email @2 :Text;
}
```
```bash
capnp compile -oc++ schema.capnp
# Generates schema.capnp.h and schema.capnp.c++
```

## Introduction
Cap'n Proto is a serialization framework where the in-memory representation IS the wire format. There is no encode/decode step — data is read directly from the serialized bytes via pointer arithmetic. This makes it faster than Protocol Buffers for many workloads, especially when only a subset of fields are accessed.

## What Cap'n Proto Does
- Serializes structured data with zero-copy reads (no parsing or unpacking required)
- Provides a built-in RPC system with promise pipelining to reduce network round trips
- Defines schemas in a dedicated language with forward/backward compatibility guarantees
- Generates type-safe bindings for C++, Rust, Go, Python, Java, and JavaScript
- Supports memory-mapped files for instant random access to large datasets

## Architecture Overview
Cap'n Proto uses a pointer-based layout where each struct and list is stored at a fixed position with inline pointers to child objects. Reading a field is a single pointer dereference with no deserialization. The RPC layer uses object capabilities and promise pipelining: a client can call a method on a not-yet-returned result, and the framework batches the calls into a single network round trip.

## Self-Hosting & Configuration
- Install the capnp compiler from your package manager or build from source
- Add the runtime library as a dependency (libcapnp for C++, capnp crate for Rust)
- Define schemas in .capnp files and compile to target language bindings
- Use packed encoding for wire transfer to reduce size by 50-90% for sparse messages
- Integrate with CMake or Bazel using provided build rules

## Key Features
- Zero-copy deserialization: read fields directly from the byte buffer with no allocation
- Promise pipelining in the RPC layer eliminates sequential round trips for chained calls
- Schema evolution supports adding/removing fields without breaking existing readers
- Time-travel RPC: call methods on future results before they arrive
- Canonical encoding enables content-addressable storage and deterministic hashing

## Comparison with Similar Tools
- **Protocol Buffers** — requires encode/decode steps; Cap'n Proto skips this entirely for faster reads
- **FlatBuffers** — also zero-copy but lacks an RPC system and promise pipelining
- **MessagePack** — schema-less binary format; Cap'n Proto provides type safety and faster random access
- **Apache Thrift** — includes RPC but encoding is not zero-copy; Cap'n Proto is faster for read-heavy workloads
- **gRPC** — HTTP/2-based RPC on top of protobuf; Cap'n Proto RPC is lower-level with less overhead

## FAQ
**Q: When should I choose Cap'n Proto over Protocol Buffers?**
A: When read performance matters more than wire size, or when you need promise pipelining in your RPC layer. For simple request/response APIs, protobuf/gRPC has a larger ecosystem.

**Q: Is Cap'n Proto suitable for network protocols?**
A: Yes. Use packed encoding for wire transfer and the built-in RPC framework for structured communication.

**Q: Can I use Cap'n Proto without the RPC system?**
A: Absolutely. The serialization format works standalone for storage, IPC, or any data interchange scenario.

**Q: How does schema evolution work?**
A: Fields are identified by number. New fields can be added with new numbers, and removed fields become unknown data that is preserved on read-modify-write.

## Sources
- https://github.com/capnproto/capnproto
- https://capnproto.org

---
Source: https://tokrepo.com/en/workflows/asset-a6f39f13
Author: Script Depot