- Entry date
- 29 May 2026
- Category
- Hardware
- Lead over the world
- a working bench encoder and a shared spec, ahead of any single device's own story
- Access
- 🔓 Public
One 16-byte header, one CRC, one magic number — NVP1 — that Hush's camera node streams live today. The spec calls itself 'the binding contract' precisely because the Rust receiver crate it's meant to anchor hasn't been written yet.
- 16 B + CRC-16
- NVP1 frame format: magic, type, channel, 16-bit length, 64-bit timestamp, payload, checksum
- 15.8 fps
- real encoder throughput bench-measured on Hush's camera node using this exact frame format (CAM len=410, trits=2050, nonzero=1432)
- 2 of ~5
- Novaterra organs with anything built against the spec — Hush (running encoder), Conch (reserved channel range, no running code); Optic/Pulse/Band have a reserved range and nothing else
- 0
- reference receiver crates built (wavetrinity-runtime/sensor_ingest.rs) — today's real receiver is a bench Python script
Honest evaluation
The frame format is real and one encoder runs it live on ESP32 hardware; 'a shared protocol across a device family' is proven for one device plus a name reservation for the rest, not yet a validated, interoperable spec.
What would prove or disprove it further
What would prove or disprove it further: build the reference receiver
crate the spec already names (sensor_ingest.rs) and get it to correctly
decode Hush's live camera stream — that closes the biggest gap on its own.
The stronger test: get a second team, or at minimum a second, independently
written encoder (Conch's, once it has running code), to emit NovaP/1 frames
and have the same receiver decode both without device-specific handling.
That's the test that would turn "a spec two devices have made room for" into
"a protocol two devices actually speak."
The evidence — full reasoning behind the verdict
Verdict: partly-proven.
The narrow claim — that a small, versioned binary frame format can carry real sensor data off a real ESP32 device, over Wi-Fi, at a measured frame rate, with no JSON or generic RPC framework in the loop — is proven: Hush's encoder does exactly that today, and the 15.8 fps figure comes off a real serial console, not a projection. The wider claim — that NovaP/1 is the shared protocol a whole device family speaks — is not yet proven. It's real for one device's encoder, backed by one other device's channel reservation, and resting on a receiver implementation that the spec itself admits doesn't exist yet.
How/why it landed here: a wire format is cheap to specify and cheap for one team to implement against its own bench receiver, which is exactly why that part is done. A shared receiver runtime that has to serve multiple devices, survive protocol evolution, and be trusted by teams other than the one that wrote it is a bigger, slower piece of engineering — the kind of thing that reasonably comes after there's more than one device generating real traffic worth building a proper receiver for. Sequencing "prove the frame format on the hardest single device first, build the shared runtime once there's real multi-device demand" is a defensible order, not a broken promise — but it does mean the current honest state is "one encoder, one spec document," not "an interoperable family protocol."
Runnable proof — see it work
A wire protocol is easy to over-claim: write a spec document, call it "the standard," and let the reader assume a whole device family is already talking to each other over it. This report tries to say exactly how much of that is true today, and how much is still a document.
What it was
NovaP/1 is a binary wire format designed to carry sensor data — ternary
band coefficients, heart-rate readings, gesture "marker" events, and
eventually audio — off any Novaterra wearable and onto a receiver, with no
JSON, no generic RPC framework, and (by design) no human-readable
intermediate format anywhere on the wire. The frame layout is small and
fully specified: a fixed 16-byte, big-endian header — a 4-byte magic
(NVP1), a 1-byte message type, a 1-byte channel ID, a 16-bit length, and a
64-bit microsecond timestamp — followed by a variable-length payload and a
2-byte CRC-16-CCITT checksum. Message types 0x00–0x08 are reserved for the
spec itself (ternary coefficients, threshold updates, glyph text, heartbeat,
mute/unmute, a channel-descriptor JSON blob sent rarely for debugging, a
voice-activity flag, and time-sync), 0x09–0xEF are reserved for future v1
extensions, and 0xF0–0xFE are left open for a device to define its own
extensions — Hush uses 0xF0 for its "Marker" event, for instance. Channel
IDs work the same way: 0x00–0x05 are spec-defined (camera, through
wake-word), and each device claims its own block above that — Hush uses
0x10–0x14 for CSI, seismocardiography, skin temperature, BLE-neighbour
scanning, and a Muse-headband reply channel; Conch, a separate Novaterra
earpiece project, reserves 0x20–0x2F. A time-sync exchange
(offset = ((T0+T2)/2) - T1) is specified to keep devices and receiver
loosely aligned, re-run roughly every 30 seconds. Versioning is forward-
stable by convention: an NVP1 receiver is expected to silently discard
message types it doesn't recognise, and a breaking change is expected to
bump the magic to NVP2 rather than reinterpret existing bytes.
The spec's own stated audience is explicitly wider than one device: it names "the necklace sensor codec, downstream NovaTerra Studio, [and] an external dolphin-pack producer" as example implementers, and the wider Novaterra product overview states plainly that Hush, Conch, and three more planned organs (Optic, Pulse, Band) are all meant to speak it — "Same NovaP. Same Twin. Different organ."
What we built
ResearchOne real, running encoder, and one real, disclosed gap on the receiving
end. Hush's bench implementation frames its camera stream and heart-rate
channel exactly per this spec, on real ESP32 hardware, streaming to a
Python receiver over Wi-Fi TCP — the measured throughput (96×96 greyscale
capture, Walsh-Hadamard transform, ternary threshold, five-trit packing,
streamed as NVP1 camera frames) is 15.8 fps, taken directly off a real
serial-console log: CAM len=410 trits=2050 nonzero=1432 rate=15.8fps.
That's not a simulated or projected number — it's what the frame counter on
a real board says.
What isn't built: the spec's own designated reference implementation, a
Rust receiver crate meant to live in the wavetrinity runtime
(sensor_ingest.rs). The spec's own text is candid about this — it says
that crate "will land... at the W5 wire-up stage," and that "until then,"
the written protocol document itself is "the binding contract." In plain
terms: there is no canonical NovaP/1 decoder yet, only a bench Python
script written to unblock one team's own testing, and the spec document
standing in for the thing it describes.
Adoption across the family is real but partial. Hush's own team didn't start with NovaP/1 — an earlier design council record shows they had built a homegrown protocol, internally called "NTP/1," before a later council deprecated it in favour of adopting NovaP/1 as the shared, external spec, on the explicit reasoning that "the receiver is the customer" — i.e. a format two teams have to agree on is worth more than one team's locally-optimal choice. Conch, a separate earpiece project, backs that up with real evidence: it reserves its own NovaP channel range under the same spec in its own design council. Optic, Pulse, and Band — the other three planned organs — have a reserved channel range named in the product overview and nothing else; no architecture document, no code.
What we learned — including the honest gaps
- A frame format that's cheap to specify precisely is exactly the kind of thing that gets built first and proven fastest. A 16-byte header with a CRC is a small, checkable design surface — writing it down and getting one encoder to emit it correctly on real hardware is a genuinely lower bar than building a shared receiver runtime, which is why the encoder side is real and the receiver side isn't.
- "The receiver is the customer" is a real design principle with one real data point behind it, not a proven pattern yet. Hush switching away from its own homegrown NTP/1 is a good sign — a team choosing the harder, shared spec over the easier, bespoke one usually means the shared spec is worth something. But one team's course-correction plus one other team's channel-range reservation is not the same as two independent teams' software actually agreeing on the wire.
- "Spec-first, implementation-later" is disclosed honestly, not hidden. The document's own language — "until then, the protocol spec... is the binding contract" — says outright that the receiver crate doesn't exist. That's the right way to write a spec ahead of its reference implementation; it just means the claim "NovaP/1 is a shared, working protocol" is currently carried by one encoder and one document, not by a tested round trip between independent codebases.
Where it went / status
Active bench research. The frame format is specified precisely and proven by one real encoder on real hardware; the shared receiver runtime named in the spec's own text has not been built, and only one other device (Conch) has taken the concrete step of reserving space under the format. Tiered research throughout — this report treats "a spec named for a family" and "a protocol a family actually speaks" as different claims, and is careful about which one the evidence currently supports.
What is still open — kept visible
The honest edges, next to the wins. This is what turns 🔬 into 🟢 — honestly.
- The receiver-side reference implementation doesn't exist yet. The spec's own text says the crate 'will land... at the W5 wire-up stage. Until then, the protocol spec... is the binding contract' — an honest way of saying the authoritative implementation is a document, not code, and today's actual receiver (twin-receiver.py) is a bench script standing in for it.
- Only two of roughly five planned Novaterra organs have anything real built against the spec: Hush has a running encoder on ESP32 hardware; Conch (a separate earpiece project) has a reserved NovaP channel range (0x20-0x2F) and an architecture document, not running code. Optic, Pulse, and Band have a reserved channel range and nothing else — 'a spec five devices share' is, today, one encoder that speaks it plus four written or partial reservations.
- No interoperability test exists between two independently written implementations. The claim that rests on firmest ground — 'the frame format works' — is proven by exactly one encoder (Hush's) and one bench receiver script written by the same project; nobody has yet built a second, independent NovaP/1 implementation and checked that it reads the first one's bytes correctly.
- This is the second, unrelated vocabotics project named 'NovaP.' A separate existing lab report covers a completely different binary protocol also called NovaP — a lock-free ring buffer moving GPU-inference tokens between Rust processes, 15 bytes per token, nothing to do with sensors or wearables. Same brand, two unconnected wire formats built for different stacks; this report is about the sensor one, whose magic bytes are literally 'NVP1.'
- Hush's own team didn't get here on the first try: they originally built a homegrown protocol internally called 'NTP/1,' then deprecated it in favour of adopting NovaP/1 as the external, authoritative spec once the case for a shared family format was made. That's a disclosed course-correction, not evidence the design was right from day one.
Where this connects
- The device whose encoder actually proves this wire format works
- The unrelated, differently-scoped protocol that happens to share this name
- The codec family in the same 'ternary, not pixels' naming lineage
- The same primitives-and-typed-wiring bet, applied to a software feature slice instead of a wire format
Sources
- hardware/esp32/nova/07-05-NOVAP_BINARY_PROTOCOL.md — NovaP/1 wire format spec (frame layout, TYPE/CHAN tables, CRC, versioning policy)vocabotics internal hardware design docs · as of 2026-05-29
- hardware/esp32/products/06-hush/05-implementation/README.md — bench bring-up log showing a real NovaP/1 encoder running on ESP32 hardwarevocabotics internal hardware design docs · as of 2026-05-30
- hardware/esp32/products/README.md — Novaterra device family overview ('All speak NovaP')vocabotics internal hardware design docs · as of 2026-05-29
- hardware/esp32/council 006.md — decision to deprecate Hush's homegrown NTP/1 in favour of adopting NovaP/1vocabotics internal hardware design docs · as of 2026-05-29
- hardware/esp32/council 008.md — Conch (earpiece) NovaP channel-range reservation under the same specvocabotics internal hardware design docs · as of 2026-05-29