NativeTernary: A Self-Delimiting Binary Encoding with Unary Run-Length Hierarchy Markers for Ternary Neural Network Weights, Structured Data, and General Computing Infrastructure

Abstract: BitNet b1.58 (Ma et al., 2024) demonstrates that LLMs can operate entirely on ternary weights {-1, 0, +1}, yet no native binary wire format exists for such models. NativeTernary closes this gap. Benchmarked against GGUF on the real BitNet b1.58 2B4T architecture (24 layers, ~170 tensors, 2B parameters): NativeTernary encodes ternary weights at exactly 2.000 bits per weight -- 1.31x smaller than GGUF Q2_K and 4.0x smaller than GGUF int8 -- while reducing boundary and framing overhead by 460x (91 bytes vs ~42KB of GGUF tensor headers). Encode throughput: 47--69 MB/s. Decode throughput: 35--45 MB/s on commodity hardware. The decoder is a 10-line stateless state machine resilient to bitstream corruption.

• The paper introduces a self-delimiting binary encoding that maps ternary data symbols with a reserved delimiter to embed hierarchical structure.
• It achieves optimal storage efficiency, reducing boundary overhead from around 42 KB to 91 bytes for models like BitNet b1.58.
• The approach enables hardware-agnostic decoding suitable for low-power embedded systems and robust, error-resilient telemetry.

Technical Analysis of NativeTernary: Self-Delimiting Binary Encoding for Ternary Data and Structure

Overview and Motivating Problem

NativeTernary introduces a self-delimiting binary encoding optimized for ternary-valued data—most notably, neural network weights restricted to $\{-1, 0, +1\}$ or $\{0, 1, 2\}$—while embedding multi-level semantic structure within the encoded stream. This addresses a salient gap made explicit by the advent of fully ternary LLMs such as BitNet b1.58, which, despite using a ternary-valued weight structure, are serialized using legacy binary wire formats designed for larger alphabets and flat data. NativeTernary leverages an information-theoretically tight mapping: three data symbols correspond to three of the four possible 2-bit patterns, while the fourth pattern is repurposed as a delimiter encoding hierarchy by run-length.

This approach delivers a wire format that is simultaneously:

• Storage-optimal for ternary data on binary hardware (2 bits per trit with no wastage).
• Capable of arbitrarily deep, self-describing hierarchical structure at degenerate overhead.
• Hardware-agnostic, requiring no change to binary infrastructure while permitting efficient hardware/software decoders.

Core Encoding Scheme

The encoding is formally defined by mapping the $2^2=4$ possible 2-bit patterns into three data symbols and one reserved delimiter. The primary instantiation reserves $\{11\}$ as the delimiter for semantic boundaries and assigns the remaining pairs to the three trit values, supporting both balanced ($\{-1,0,+1\}$) and unsigned ($\{0,1,2\}$) interpretations.

Structural hierarchy is inscribed into the bitstream via unary run-lengths of consecutive delimiter pairs: one pair denotes a low-level (e.g., token/character) boundary, two for word-level, and so on. This unary approach scales delimiters linearly with depth, exploiting the empirical exponential rarity of higher-order structural breaks (i.e., longer boundaries demarcate less frequent, larger syntactic units such as sentences, paragraphs, or files).

The design parameter of delimiter selection ({11}, {00}, {01}, or {10}) enables tradeoffs between hardware detection logic, energy efficiency, and channel noise properties. A notable variant employs $\{00\}$ as the delimiter for ultra-low-power CMOS use cases, minimizing bit switching in the physical layer.

Detailed Variant and Error Analysis

NativeTernary also presents a dual-starter variant wherein two bit pairs ({10} and {11}) act as symbol starters, allowing for dual-namespace streams or protocol framing. Data density here is reduced to 0.5 bits per bit, but synchronizability and multiplexing applications are enhanced.

Error asymmetries are scrutinized: with unsigned ternary, the proximity (in Hamming space) of a data symbol’s bit pattern to the delimiter creates a risk of certain single-bit errors causing false structural boundaries. Balanced ternary is more robust in environments with high bit error rates due to a more symmetric bit-pattern layout.

Storage and Boundary Overhead Benchmarks

NativeTernary demonstrates significant empirical improvements in both storage density and boundary overhead compared to existing GGUF-based formats:

• Each trit is stored in exactly 2.000 bits versus 2.625 bits for Q2_K GGUF, and 8.000 bits for int8 GGUF.
• Structural boundary overhead reduction is pronounced: For BitNet b1.58 (2B params, 170 tensors), NativeTernary encodes all boundaries in 91 bytes versus $\sim$42 KB for GGUF tensor headers, a $460\times$ savings.

Encode throughput ranges from 47–69 MB/s; decode throughput achieves 35–45 MB/s on standard hardware. The provided reference C implementation underscores the low computational and memory footprint of both encoding and decoding.

Practical Applications and Implications

Ternary Neural Architecture Serialization

The encoding directly benefits storage, transmission, and deployment of ternary NNs (e.g., BitNet b1.58), offering a compact wire format natively matching the parametric domain, embedding boundary information required for tensor and layer demarcation with trivial overhead.

Hierarchical NLP and Sequence Data

By tying semantic hierarchy to the stream encoding, NativeTernary supports granular, on-the-fly parsing of boundaries. This could lead to new methodologies in hierarchical self-attention, structural conditioning, or modular context management in LMs, with no requirement for out-of-band structural tokens or parser side-channels.

Embedded Systems and Energy-Limited Domains

The decoder consists of a stateless, short (10-line) state machine and is thus suitable for deployment on low-power microcontrollers and edge devices. The {00}-delimiter variant specifically optimizes for domains where power is dominated by line switching—such as medical implantables or low-power wireless telemetry—without incurring semantic or operational loss.

Error-Resilient Telemetry and Real-Time Data

In environments with high link error rates (satellite downlinks, LoRa, industrial RF), the self-delimiting structure and stateless resynchronization enable robust error recovery and easy message boundary reacquisition.

Broader Infrastructure and OS Implications

The encoding paradigm enables a shift wherein data structure boundaries (e.g., file, record, memory page, network packet, etc.) could be moved from out-of-band metadata into the main data stream. Transitioning to such an intrinsic boundary representation involves staged adoption (libraries, drivers, firmware, eventual hardware acceleration), remains fully backward-compatible, and contrasts sharply with previous ternary computing proposals demanding fundamental hardware replacements.

Theoretical Analysis

Information-theoretically, NativeTernary achieves near-optimal density for ternary data. Three symbols per 2 bits ($\log_2 3/2 \approx 0.792$ bit/bit) is the maximal achievable under binary wiring. Delimiter overhead, when amortized over realistic structural distributions (natural languages or sensor streams), is sublinear and far below existing fixed-width approaches.

The self-synchronizing delimiter scheme is infinitely extensible and does not require specification revision for deeper hierarchies, further distinguishing it from approaches such as UTF-8 or protocol buffers.

Limitations

• NativeTernary does not compress fully random or non-ternary data; purely binary data incurs a worst-case $\{0, 1, 2\}$026% size expansion due to base conversion.
• The error vulnerability of unsigned ternary adjacent to the delimiter, present in some deployments, mandates case-by-case channel analysis.
• Infrastructure adoption necessitates staged software support, though no hardware changes are required for basic functionality.

Future Directions

NativeTernary opens the door for further research in several areas:

• Direct integration with hierarchical attention or structured sequence models, rethinking input representation.
• Exploration of dynamic delimiter allocation or adaptive encoding schemes for context-aware boundaries.
• Investigation of hardware co-design for ultra-low-latency streaming, particularly in low-energy and safety-critical domains.
• Formal analysis and mitigation strategies for error-propagation models in the presence of single-bit or burst noise.

Conclusion

NativeTernary offers a formal, practical, and information-theoretically justified scheme for ternary data encoding with inline hierarchical structure, operating wholly within established binary infrastructures. It achieves significant reduction in structural overhead for neural network weight storage, supports error-robust and power-aware deployment in embedded and telemetry contexts, and foreshadows broader possibilities for self-delimiting computing paradigms. Its open-source reference implementation and explicit transitional path from software to optional hardware acceleration ensure accessibility and viability for diverse computational domains.