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
110 ns/op
Over 6x faster than Protobuf & FlatBuffers (0 allocs)
Full Zero-Copy Decode
159 ns/op
Over 8x faster than Protobuf, faster than FlatBuffers
Compact Wire Size
360 Bytes
40% smaller than FlatBuffers (600 B), near Protobuf (341 B)
Full Message Decode Speed
OmniBuf
159 ns
FlatBuffers
225 ns
Cap'n Proto
989 ns
Protobuf
1304 ns
MessagePack
3235 ns
JSON
5073 ns
Full Message Encode Speed
OmniBuf
110 ns
FlatBuffers
732 ns
Protobuf
739 ns
Cap'n Proto
1318 ns
MessagePack
2048 ns
JSON
2204 ns
Format Feature Matrix
Format Uses .proto Wire Size 1-Pass Encode Schema-Less Types append(a, b) Merge
OmniBuf Yes 360 B Yes (110 ns) Yes (+ opt Field #0) Yes
Protobuf Yes 341 B No (2-pass Size) No (Opaque Type 2) Yes
FlatBuffers No (.fbs) 600 B (+76%) Bottom-up only No No
Cap'n Proto No (.capnp) 560 B (+64%) Arena pointers No No
MessagePack / JSON Optional 656 B / 803 B Yes (Slow) Yes (Repeated Keys) No