A data transfer protocol that shares the schema once, not on every response.
FlyWire — schema-aware, binary-capable record transport
A client fetches a table's schema once, at session start, then caches it. Every response after that carries only values, at the fixed byte offsets the cached schema already describes — no field names, no per-message type metadata. Two encoding strategies are available per table: a lean, human-readable default, and a configurable fixed-width binary strategy with string pooling for cases that need real random-access speed or want data that isn't sitting in the clear.
What's actually proven, not just designed
Smaller, for real
Pooled binary beats best-case positional JSON on size at every scale tested — real Postgres data, not synthetic. At 10,000 rows it is 0.50x the size raw and 0.67x on the wire, measured, with the method stated in the testing reference.
True O(1) random access
Every record sits at a known, fixed offset. Fetching one record never means reading the rest — about 2,095 times faster than a full JSON re-parse at 10,000 rows (measured, with its range), and far more against FlyWire's own plain-text strategy.
Real relational data
A genuine, Postgres-enforced foreign key
(maintenance_records.asset_id → assets.asset_id),
one-to-many, queried and round-tripped through the full pipeline
— not a placeholder ordinal standing in for a relationship.
One parser, measured both ways
Since release 0.12.0 the ANVL parser is anvil.js
0.13.1-rc, pure JavaScript, on a server and in a browser (no
WebAssembly file to serve). Against the previous native
anvil-node 0.11.0-rc it is a little slower on the
small read envelope, a few microseconds per read; it is faster at
validating writes and at decoding Table text; and loading a schema
costs about 5 ms, once per schema per process. Reported as
measured, including where it loses (on 0.13.0-rc; 0.13.1-rc was not re-measured, and ANVL reports it within 0.97-1.08x of 0.13.0-rc, time ratio, lower is faster); the method and the ratios are
in the testing and metrics document.
Full CRUD, schema-validated
Create, Read, Update, and Delete — including batch writes, a
real where{} condition primitive, cursor-paged
queries, custom actions, long-poll and write hooks — proven end
to end over real HTTP against real Postgres, behind a reusable
server (createFlyWire) with identity hooks. Every
write is validated against the schema before it becomes SQL;
client input never becomes SQL text directly.
Told straight, not just the good parts
Pooled binary's size and random-access wins come with a real,
measured cost: end to end, JSON is about 2.8 times faster than
FlyWire Binary at 10,000 rows (20.9 ms against 58.3 ms), Binary is
1.27 times faster than FlyWire Table, and at 17 rows Binary is not
faster than Table. Encoding is slower than JSON.stringify
(the work that makes the size win possible isn't free), and the
decode stages are reported as measured, not as improvements. Both
sides of the story, with the method, are in the testing and
metrics reference — not smoothed over because parts of it are
inconvenient.
Where this stands
Pre-release, and not publicly distributed yet. The core protocol — schema handshake, both encoding strategies, string pooling, a real database adapter, schema generation with drift detection, a reusable server with identity hooks, a Node client library and typed errors, and full CRUD with queries, actions and hooks — is built and tested against a real PostgreSQL database, over real HTTP. AQL — a structured query language that replaces hand-written SQL on the request side too — is the next major design work. Full status, reasoning, and open questions live in the docs.