NC06: Hybrid Binary Compression Format

• NC06 is a hybrid compression format that segments file data into text and binary regions, integrating LLM-based and conventional codecs for efficient processing.
• It employs a segmentation heuristic that classifies bytes as text-like (printable ASCII) or opaque binary, ensuring mode-specific compression.
• NC06’s container structure stores metadata and payloads to faithfully reconstruct original file order, guaranteeing deterministic, lossless recovery.

NC06 is NACRITH’s hybrid binary compression format and processing path for arbitrary files, introduced in "Nacrith: Neural Lossless Compression via Ensemble Context Modeling and High-Precision CDF Coding" (Tacconelli, 23 Feb 2026). In the paper’s taxonomy, NC06 is not merely a coding trick inside arithmetic coding and not just a protocol; it is a hybrid container and compression workflow that extends a token-level transformer-based lossless compressor to files containing both text-like and opaque binary regions. Its central function is to segment an input byte stream into text and non-text regions, apply NACRITH’s neural text compressor where a LLM is meaningful, and use conventional binary codecs elsewhere, thereby bridging the gap between token-level neural compression and byte-level real-world file structure (Tacconelli, 23 Feb 2026).

1. Definition and problem setting

NC06 is described as a chunked container format that segments arbitrary binary files into text and non-text regions, applying neural compression to text-like content and traditional codecs to opaque data (Tacconelli, 23 Feb 2026). The paper states that NACRITH “handles arbitrary binary files through the NC06 hybrid format,” and explicitly positions this capability as absent from prior LLM-based compressors known to the authors. The same source further characterizes NC06, to the authors’ knowledge, as the first LLM-based binary compressor (Tacconelli, 23 Feb 2026).

The problem NC06 addresses follows directly from the assumptions of NACRITH’s base compressor. NACRITH’s core path is token-based: text is tokenized with SmolLM2’s BPE vocabulary, predicted with an LLM plus online auxiliary models, and entropy-coded with arithmetic coding. That pipeline presumes meaningful text structure. Arbitrary binaries do not satisfy that assumption, because executables, images, compressed archives, and mixed-format documents can contain long byte ranges with no useful mapping to linguistic tokens. The paper therefore presents NC06 as a selective representation: text-like byte regions are compressed with the full neural pipeline, while opaque binary regions are extracted and compressed with standard binary codecs (Tacconelli, 23 Feb 2026).

This design implies that NC06 is not a byte-level arithmetic code layered under token coding, and not an escape-symbol mechanism injecting arbitrary bytes into a token stream. The paper’s description supports region-level mode switching: the system alternates between a token-based neural path for text and a conventional byte-oriented path for binary payloads. A plausible implication is that NC06 should be understood primarily as a systems-layer extension of NACRITH rather than as a new probabilistic model.

2. Segmentation strategy and hybrid workflow

The NC06 path is segmentation-driven. The input byte stream is scanned and partitioned into alternating text chunks and binary chunks (Tacconelli, 23 Feb 2026). Bytes in printable ASCII range $32\text{–}126$ plus tab, LF, and CR are deemed text-like. The paper then specifies four refinement rules for the segmentation heuristic: short text runs of fewer than 64 bytes are demoted to binary; binary gaps of at most 8 bytes between text runs are bridged; and small binary chunks under 64 bytes adjacent to text are absorbed into text (Tacconelli, 23 Feb 2026). These rules implement region-level cleanup rather than symbol-level interleaving.

Once segmentation is complete, text chunks are sent through the ordinary NACRITH text compressor, while binary chunks are withheld from the transformer path. The paper is explicit that all binary chunks are concatenated into a single blob and compressed with LZMA for blobs of at least 4 KB, gzip for smaller blobs, or stored raw if neither reduces size (Tacconelli, 23 Feb 2026). The binary side therefore forms a single auxiliary payload rather than multiple independently coded binary substreams.

The workflow can be summarized as follows.

Stage	Paper-supported behavior
Segmentation	Partition bytes into alternating text and binary chunks
Text path	Tokenize and compress with the normal NACRITH neural pipeline
Binary path	Concatenate binary chunks into one blob; use LZMA, gzip, or raw
Packaging	Store metadata sufficient to reconstruct original ordering

The significance of this workflow is practical. A compressor restricted to plain text is not, in the ordinary systems sense, a general-purpose file compressor. NC06 addresses that limitation by making mode selection explicit at the region level, allowing the LLM to operate only where token semantics are meaningful and conventional codecs to handle the remainder (Tacconelli, 23 Feb 2026).

3. Interaction with NACRITH’s text compressor

Within text chunks, NC06 does not introduce a distinct text-modeling law. Instead, it reuses NACRITH’s standard token-probability pipeline (Tacconelli, 23 Feb 2026). The model side is given by the SmolLM2-135M causal transformer with next-token probabilities

$$P_{\mathrm{LLM}}(t_{n+1}\mid t_1,\dots,t_n)=\mathrm{softmax}(Wh_n+b).$$

These probabilities can be adjusted by the adaptive log-space bias head,

$$\tilde p(t)=\frac{p_{\mathrm{LLM}}(t)e^{b_t}}{\sum_{t'} p_{\mathrm{LLM}}(t')e^{b_{t'}}} =\mathrm{softmax}(\log p_{\mathrm{LLM}} + b)_t,$$

and can be combined with the token-level N-gram model through linear mixture,

$$p_{\mathrm{mix}}(i)=\sum_{j=1}^{M} w_j p^{(j)}(i),\qquad \sum_j w_j=1.$$

The mixture weights are updated online after observing token $t_i$ via

$\log w_j \mathrel{+}= \eta \log p^{(j)}(t_i),$

followed by renormalization (Tacconelli, 23 Feb 2026).

The paper further states that the mixer usually collapses toward the LLM except on highly predictable tokens, where confidence-based skip bypasses the LLM entirely. When the N-gram entropy satisfies

$H(P_{\mathrm{ng}}) < T,\qquad T=1.5 \text{ bits},$

the system uses

$p = P_{\mathrm{ng}}.$

For text chunks in NC06, the probabilities are quantized to a high-precision cumulative distribution with total $2^{24}$, using

$c_i=\max(1,\; p_i \cdot (T - V)),$

with $$P_{\mathrm{LLM}}(t_{n+1}\mid t_1,\dots,t_n)=\mathrm{softmax}(Wh_n+b).$$0, $$P_{\mathrm{LLM}}(t_{n+1}\mid t_1,\dots,t_n)=\mathrm{softmax}(Wh_n+b).$$1, and residual assigned to the argmax-probability token (Tacconelli, 23 Feb 2026). Arithmetic coding then proceeds over the resulting cumulative counts.

This means NC06 is specific mainly in segmentation and packaging, not in token modeling. The transformer, online predictors, adaptive bias head, confidence skip, CDF precision upgrade, and arithmetic coder operate exactly as they do for ordinary NACRITH text compression. The mathematical machinery governing NC06 text regions is therefore inherited from the parent system rather than specialized for the hybrid file format (Tacconelli, 23 Feb 2026).

4. Encoding, decoding, and container structure

The paper does not provide NC06-specific pseudocode, but it describes an end-to-end workflow sufficiently clearly to reconstruct the major stages (Tacconelli, 23 Feb 2026). Encoding begins from an arbitrary byte file, performs segmentation, concatenates binary chunks into a single binary blob, and compresses each text chunk with the normal NACRITH text pipeline. For each text chunk, the Hugging Face tokenizer converts text into token IDs; deterministic state is initialized, including transformer KV cache, N-gram tables, mixer, and adaptive head; token probabilities are generated; those probabilities are quantized to a $$P_{\mathrm{LLM}}(t_{n+1}\mid t_1,\dots,t_n)=\mathrm{softmax}(Wh_n+b).$$2-precision CDF; tokens are arithmetic-coded; and online models are updated after each symbol (Tacconelli, 23 Feb 2026).

The final NC06 container stores an extended header and structured entry table, followed by the compressed binary section and the arithmetic-coded text streams. The paper states that the container stores “a flags byte,” “temperature,” “entry table,” “binary section,” and “parallelized text streams,” so that the decoder can reproduce “the exact ensemble configuration used during compression” (Tacconelli, 23 Feb 2026). Section 3.12 additionally states that parallel streams are stored in NC05 and NC06 containers, and their per-chunk headers encode token count, bit count, and stream length.

The supported NC06 file-format elements described in the paper are concise but incomplete.

Component	Paper-supported description
Magic	NC06
Versioning	Version byte
Configuration	Flags byte encoding active features; temperature
Structure	Structured entry table for alternating text/binary chunks
Payloads	Binary section and text streams, potentially parallelized

Decoding is the exact inverse. The decoder parses the NC06 header, version, flags, temperature, and entry table; recovers the binary payload using the indicated method; reconstructs each text stream token by token using the same tokenizer, LLM state, N-gram model, mixer, and adaptive head; detokenizes recovered tokens; and interleaves text and binary chunks in original order according to the entry table (Tacconelli, 23 Feb 2026). The paper emphasizes that, because every component is deterministic with identical state on both sides, reconstruction is perfectly lossless.

5. Relation to generic NACRITH features

Several major features of NACRITH are directly used by NC06 but are not NC06-specific. The high-precision $$P_{\mathrm{LLM}}(t_{n+1}\mid t_1,\dots,t_n)=\mathrm{softmax}(Wh_n+b).$$3 CDF upgrade is a generic NACRITH feature used for token arithmetic coding inside NC06 text chunks (Tacconelli, 23 Feb 2026). The token-level N-gram model, adaptive log-space bias head, and confidence-based LLM skip are likewise generic mechanisms inherited by the NC06 text path. The llama.cpp backend, KV-cache sliding window, and multi-worker parallel compression are also generic system features that NC06 can exploit for text regions (Tacconelli, 23 Feb 2026).

What is specific to NC06 is narrower and architectural. The paper identifies three distinguishing elements: segmentation of arbitrary bytes into text-like versus binary chunks; binary-blob concatenation with conventional compression fallback; and the NC06 container structure that stores both kinds of content together (Tacconelli, 23 Feb 2026). NC06 is therefore not a separate probabilistic coder. It is the systems layer that allows NACRITH’s text-centric coder to coexist with ordinary binary compression in one lossless representation.

This distinction matters for interpretation. Compression gains reported elsewhere in the paper primarily validate the NACRITH text engine. NC06’s contribution is that it makes that engine applicable to arbitrary files without requiring the transformer to model byte regions for which its tokenizer and training distribution are poorly matched. A plausible implication is that NC06 should be evaluated as a hybrid orchestration mechanism whose effectiveness depends on the quality of both its segmentation heuristic and its text-modeling backend.

6. Novelty, evidence, and limitations

The paper treats NC06 as novel because it broadens LLM-based compression from a text-only setting to a general file-compression setting (Tacconelli, 23 Feb 2026). Prior systems discussed in the same work, including Delétang et al., FineZip, ts_zip, and LLM-Text-Compressor, are framed primarily as text compressors. In the paper’s comparison table, Nacrith is marked as supporting binary files while several LLM-based comparators are not. The authors accordingly claim that NC06 extends neural compression to arbitrary binary files and, to their knowledge, is the first LLM-based compressor to handle non-text files (Tacconelli, 23 Feb 2026).

The evidentiary basis for NC06 is capability-level rather than benchmark-level. The paper directly supports that NC06 exists, is implemented, integrates with parallelization and container design, and enables arbitrary binary handling. It does not provide a benchmark table for arbitrary binary files compressed with NC06, compression-ratio comparisons on binary corpora against gzip, xz, or zstd, throughput or memory breakdowns specific to NC06, or ablations isolating segmentation heuristics, binary-gap bridging, blob concatenation, or the LZMA/gzip/raw choice (Tacconelli, 23 Feb 2026). All quantitative results reported in the paper concern text corpora such as alice29.txt, asyoulik.txt, modern English samples, enwik8, and an out-of-distribution 2025 government text.

The implementation constraints documented in the paper also delimit NC06’s practical scope. The text side assumes SmolLM2 token IDs and a compatible tokenizer; the paper notes a dual-tokenizer architecture in which llama.cpp is used for inference while Hugging Face handles tokenization and detokenization because llama.cpp mishandles 47 whitespace and repeat tokens in SmolLM2’s vocabulary (Tacconelli, 23 Feb 2026). Deterministic reconstruction further depends on reproducible numerical behavior: the adaptive head uses float64, and bit-exact reproducibility requires identical hardware and software configuration, including GPU architecture, BLAS library, and driver version. The paper also leaves parts of the NC06 binary-side metadata unspecified, so a full independent reimplementation cannot be derived from the text alone (Tacconelli, 23 Feb 2026).

The segmentation heuristic is explicitly ASCII-centric, using printable ASCII plus tab, LF, and CR as the criterion for text-likeness. The paper does not discuss UTF-8 multilingual text, files with embedded higher-bit textual encodings, PDFs, or binary formats containing semantically structured but non-ASCII text (Tacconelli, 23 Feb 2026). This suggests that NC06 is most directly aligned with files whose text-like regions are primarily ASCII or near-ASCII. The paper also notes broader NACRITH runtime constraints that affect NC06 text regions as well, including roughly 20–30 tok/s in steady state on a GTX 1050 Ti, about 1.2 GB VRAM per worker, approximately 500 MB GGUF weights, and a 2,048-token context with sliding-window truncation beyond that (Tacconelli, 23 Feb 2026).

NC06 is therefore best understood as a hybrid file/container format that enables arbitrary-binary lossless compression by combining NACRITH’s LLM-based text coder with conventional byte-oriented codecs for non-text regions. The paper provides a solid conceptual description of segmentation, binary-blob handling, container roles, and deterministic reconstruction, while leaving the full formal bitstream specification and binary-workload evaluation incomplete (Tacconelli, 23 Feb 2026).