Keep your .proto files.
Upgrade the wire format.

Protobuf got schemas right, mostly, but its 2001 wire format made two costly mistakes: it requires the schema just to decode values, and its byte-by-byte LEB128 varints are slow as hell.

OmniBuf gives you all the benefits of Protobuf (your existing .proto files, compact binary payloads, schema evolution, and raw byte concatenation) in a wire format that is over 6x to 8x faster, easier to debug without a schema, and simpler to implement in any language.

One .proto Schema → Three Encodings
peer.proto message Peer { uint32 id = 1; string host = 2; } Protobuf (Standard) ✓ Compact binary size ✗ Needs schema to decode ✗ Slow varints & 2-pass JSON (Debugging) ✓ Debuggable without schema ✗ Bloated payload size ✗ Slow text parsing OmniBuf (Speed + Debug) ✓ Debuggable without schema ✓ Over 6x-8x faster ✓ Near-Protobuf binary size
FASTER • OVER 6X TO 8X FASTER SINGLE-PASS ENCODE & BRANCHLESS DECODE EASIER TO USE • INSPECT & DEBUG PACKETS WITHOUT THE ORIGINAL SCHEMA SIMPLER WIRE LAYOUT • FLAT [TAG][VALUE] STREAM WITH NO VTABLES OR POINTER GRAPHS ALL THE BENEFITS OF PROTOBUF • KEEP YOUR .PROTO FILES, EVOLUTION & COMPACT SIZE FASTER • OVER 6X TO 8X FASTER SINGLE-PASS ENCODE & BRANCHLESS DECODE EASIER TO USE • INSPECT & DEBUG PACKETS WITHOUT THE ORIGINAL SCHEMA SIMPLER WIRE LAYOUT • FLAT [TAG][VALUE] STREAM WITH NO VTABLES OR POINTER GRAPHS ALL THE BENEFITS OF PROTOBUF • KEEP YOUR .PROTO FILES, EVOLUTION & COMPACT SIZE

All the benefits of Protobuf.
Faster, easier, and simpler.

You shouldn’t have to abandon .proto or accept bloated zero-copy pointer graphs just to get fast serialization and readable packets.

1. Faster

No byte-by-byte varint loops. No two-pass encoding.

Protobuf’s LEB128 varints check a continuation bit on every single byte, stalling CPUs with branch mispredictions, and force encoders to walk the message tree twice just to calculate nested lengths. OmniBuf encodes integer byte-length in the first byte ( TZCNT ) for single-load decoding and writes messages forward in a single pass.

Over 6x faster encode
Over 8x faster decode
1-pass write • 1-load varints
2. Easier to Use

Debug packets without a schema & use normal structs.

Protobuf made a mistake by lumping strings, bytes, sub-messages, maps, and packed arrays into a single opaque wire type (Wire Type 2). OmniBuf spends slightly more tag space (~5% message size) so wire types match Protobuf types directly. Any CLI, proxy, or log viewer can decode values without the original .proto file, and you never have to wrestle with FlatBuffers ’ bottom-up builders.

Schema-less value inspection
+ Optional Field #0 inline field names for instant named JSON
3. Simpler to Implement

A flat [Tag][Value] stream with no vtables or pointer graphs.

Zero-copy formats require complex vtables, relative pointer graphs, alignment padding, and arena allocators. Even Protobuf requires special cases for groups, unpacked vs. packed arrays, and synthetic MapEntry sub-messages. OmniBuf is a flat stream of [Tag][Value] pairs with 4 integer widths (1, 2, 4, 9 bytes) and 16 explicit wire types.

No vtables or pointer graphs
4 integer sizes • 16 wire types • Flat stream layout
4. All the Benefits of Protobuf

Keep your .proto files, schema evolution, and compact payloads.

OmniBuf works directly with your existing .proto schemas and generated structs. You keep field numbers, safe forward and backward compatibility, near-Protobuf wire size (40% smaller than FlatBuffers), and raw byte concatenation ( append(msgA, msgB...)) for zero-parse message merging.

✓ Existing .proto schemas
✓ Safe field evolution
✓ append(msgA, msgB...) merge

Benchmark highlights.

Measured on an 11-field telemetry message with nested structs and arrays. Shorter bars = Faster.

1-Pass Forward Encode
6x Faster
Than Protobuf & FlatBuffers (0 allocs)
Full Zero-Copy Decode
8x Faster
Than Protobuf, faster than FlatBuffers
Compact Wire Size
40% Smaller
Than FlatBuffers, within ~6% of Protobuf
Full Message Encode Speed
OmniBuf
94 ns
Protobuf
561 ns
FlatBuffers
562 ns
Cap'n Proto
1016 ns
MessagePack
1552 ns
JSON
1720 ns
Full Message Decode Speed
OmniBuf
120 ns
FlatBuffers
170 ns
Cap'n Proto
772 ns
Protobuf
960 ns
MessagePack
2496 ns
JSON
3850 ns
Format Feature Matrix
Format Uses .proto Wire Size 1-Pass Encode Schema-Less Types append(a, b) Merge
OmniBuf Yes ~6% larger Yes (6x faster) Yes (+ opt Field #0) Yes
Protobuf Yes Baseline (1x) No (2-pass Size) No (Opaque Type 2) Yes
FlatBuffers No (.fbs) +76% larger Bottom-up only No No
Cap'n Proto No (.capnp) +64% larger Arena pointers No No
MessagePack / JSON Optional +92% / +135% larger Yes (Slow) Yes (Repeated Keys) No