protoarraySchema-based serialization that stays JSON

Objects travel as positional arrays, about half the bytes of JSON, faster than JSON.stringify and JSON.parse, and on records, strings and tagged messages faster to encode than the binary codecs. One metaschema definition validates the values and shapes the wire. No compiler, no dependencies, Node.js and browsers.

Get Started

Why protoarray?

Compare with alternatives

📦

Half the bytes, still JSON

{ name: 'Alex', age: 27 } travels as ['Alex', 27]: the keys never repeat, both sides know them from the schema. The payload is plain JSON, so HTTP, WebSocket, brokers, logs and storage take it as it is.

How it works

⚡

Fast as a binary codec

Native JSON.parse and JSON.stringify do the text, generated code the rest: ×1.5 encode and ×1.8 decode against JSON on a typical record, and the fastest encoder of the comparison on records, strings and tagged messages.

Benchmarks

🗺️

One metaschema definition

The @alexify/metaschema definition that validates the values shapes the wire too: enums, dates, BigInts, bytes, decimals, flags, sets, maps, unions and references. Its snapshot is JSON a server hands to its clients.

metaschema and protoarray

🔁

Evolution and migrations

Append fields and older and newer peers keep reading each other. resolve() reads an old writer's payload into the current shape (renames, defaults, widened types), and a registry tags each payload with the id of its schema.

Migrations and the registry

🧱

Layouts for lists

Columns, a flat stride or a presence mask for sparse records, ids written as differences and repeated strings interned: a list of a thousand records takes 58% fewer bytes than JSON, and the least after gzip of any format measured.

Collections and layouts

🛡️

Any runtime, even a strict CSP

Generated code where the runtime allows it, closures where it does not. protoarray compile writes your schemas into a module that runs at the speed of generated code with no eval: Workers, the edge, a strict CSP.

Standalone modules

🌊

Streams

NDJSON and TransformStreams for Node.js and browsers, and parseItems to read the records of a long array as the text arrives, with a length limit for untrusted input.

Streaming

🪶

Zero dependencies, about 22 KB

No runtime dependencies and about 22 KB min+gzip; the registry, resolve, streams and standalone modules are subpaths you import when you need them. CommonJS with ESM named imports, TypeScript types from the metaschema schema.

Runtimes

Benchmarks

protoarray is measured against JSON and eleven JavaScript codecs on the same seven payloads, each library in a fresh process and checked to give the value back before it is timed. The chart shows a round trip, one encode and one decode; pick a scenario, or encode, decode and the payload sizes on their own. protoarray is the fastest encoder on records, strings and tagged messages and has the fastest round trip of one record, decodes faster than JSON on every payload and faster than every codec on long strings, and writes about half the bytes of JSON. msgpackr's shared structures decode faster on the other payloads, and mostly numeric ones are the honest exception, where avsc and msgpackr lead.

One record: round trip

One record: 10 fields, nested address, tags, 2 orders. Encode one payload and decode it, payloads a second, linear scale, higher is better. The line marks JSON.

protoarraycodegen

940k

msgpackrrecords, shared structures

916k

protoarraystandalone module, no eval

899k

avscType.forSchema

840k

protobufjsreflection, Root.fromJSON

717k

protoarraycodegen + metaschema check

689k

protoarrayclosures, no eval

623k

fast-json-stringifycompiled stringify, JSON.parse

615k

JSONstringify · parse

572k

msgpackrpack · unpack

442k

cbor-xrecords

358k

@msgpack/msgpackEncoder · Decoder

356k

v8.serializestructured clone, Node only

277k

BSONserialize · deserialize

273k

protobuf-escreate · toBinary · fromBinary

261k

devaluestringify · parse

184k

superjsonstringify · parse

109k

Apple M3 Max · 16 cores · Node v24.14.1 · median of 5 × 400 ms rounds, each library and scenario in a fresh process · 2026-10-16

Method, cold start, bundle size, release over release and the two backends →

protoarraySchema-based serialization that stays JSON

Half the bytes, still JSON

Fast as a binary codec

One metaschema definition

Evolution and migrations

Layouts for lists

Any runtime, even a strict CSP

Streams

Zero dependencies, about 22 KB

Benchmarks ​

Benchmarks