Voynich Manuscript Decryption: A Novel Compression-Based Hypothesis and Computational Framework

1. Introduction

The Voynich Manuscript, carbon-dated to the early 15th century, has eluded decipherment for centuries, defying the efforts of renowned cryptographers and linguists (Landini & Foti, 2020; Tiltman, 1967). Its text displays complex statistical patterns, including a Zipfian word-rank distribution characteristic of natural language, yet its vocabulary and character-level features remain entirely unique and unidentifiable (Montemurro & Zanette, 2013; Currier, 1976). This paradox has led to numerous hypotheses, ranging from it being an encoded known language (Strong, 1945) to an extinct language (D'Imperio, 1976) or an elaborate hoax (Rugg, 2004).

However, many analyses note the VM's exceptionally low bigram and trigram redundancy compared to known languages, a property that aligns more closely with compressed or encoded data (Montemurro & Zanette, 2013; Reddy & Knight, 2011). Furthermore, the strong positional constraints of its characters—where certain glyphs appear only at word beginnings or endings—suggest a structural encoding system rather than a purely phonetic one (Currier, 1976; Stolfi, 2005).

This paper posits a new direction: that the VM is not written in an unknown language but is a cryptographic construct based on data compression principles. We hypothesize that the author utilized a method functionally similar to a two-stage process: first, a transformation of source text using a sliding-window dictionary coder (antecedent to LZ77), and second, a variable-length coding of the resulting tokens (antecedent to Huffman coding) (Ziv & Lempel, 1977; Huffman, 1952). This would explain the text's natural-language-like word frequency alongside its anomalous character-level statistics (Cover & Thomas, 2006).

2. Hypothesis: A Compression-Based Cryptographic Model

We propose a theoretical model where the VM's glyphs are not alphabetic characters but codewords in a complex cipher system based on compression algorithms. The model consists of two conceptual stages:

The first stage involves processing a source text (e.g., Latin, vulgar Italian) with an encoder that replaces repeated phrases with compact pointers. As described by Ziv & Lempel (1977), such an algorithm outputs a sequence of tokens that are either:

• Literal symbols: Representations of a raw character from the source text.
• Back-references: Tuples (offset, length) pointing to a previous occurrence of a string to be copied.

We posit that the VM's repetitive "words" (e.g., qokey, qokeey, qokedy) are not morphological variants but the encoded representations of these back-reference tokens. The specific structure of a "word" would thus correspond to the binary encoding of the offset and length values.

The output of the first stage—a mix of literal symbols and back-references—would then be encoded using a variable-length code. Huffman (1952) demonstrated the optimal method for assigning short codes to frequent tokens and longer codes to infrequent ones. The high frequency of certain VM glyphs (e.g., the transcribed character e) is consistent with them representing short Huffman codes for the most common tokens (e.g., the space character, common vowels, or small length values).

This two-stage model provides a potential explanation for the core mysteries of the VM:

• Zipf's Law: The source text's word distribution is preserved.
• Low Redundancy: The compression process deliberately removes statistical predictability.
• Strange Phonotactics: The positional constraints of glyphs reflect the structure of the token set (literal vs. offset vs. length codes), not phonology.

3. Methods: A Computational Framework for Testing

To operationalize this hypothesis, we developed a flexible computational framework in Go.

A accurate machine-readable transliteration of the VM is paramount. Future work will utilize datasets like the Interlinear File or EVA transcription, treating each character as a symbol in an alphabet (Timm & Schinner, 2021; Reeds, 1995). For this proof-of-concept, a simulated bitstream was generated.

The core of the framework is a function that interprets an input bitstream as a series of LZ77 commands. The algorithm requires the specification of key parameters:

• offsetBits: The bit-length of the field encoding the backward distance.
• lengthBits: The bit-length of the field encoding the match length.
• literalFlag: The prefix bit(s) signaling a literal symbol.

The algorithm processes the bitstream, maintains a sliding window (the "search buffer"), and outputs a decoded string. It is executed iteratively across a wide parameter space.

The central challenge is evaluating the success of a given parameter set without knowing the source language. We employ Shannon entropy (H) as a fitness metric (Shannon, 1948; Cover & Thomas, 2006). Natural language has a characteristic entropy rate. A successful decompression is hypothesized to yield a string with significantly lower character-level entropy than the encoded bitstream or incorrectly decoded data. The formula for Shannon entropy H of a string X is: H(X) = -Σ P(x_i) log₂P(x_i), where P(x_i) is the probability of character x_i.

The framework automates a grid search over plausible values for offsetBits and lengthBits. For each combination, it performs the decompression, calculates the output's entropy, and ranks the results. This allows for the identification of parameter sets that produce outputs with statistical profiles most resembling natural language.

4. Code

File: voynich_decompressor/main.go

File: voynich_decompressor/go.mod

File: voynich_decompressor/README.md

Methodology

• Bitstream Generation: Text is encoded into binary representation
• Parameter Testing: Tests various (offsetBits, lengthBits) combinations
• Entropy Analysis: Uses Shannon entropy to identify promising results
• Result Evaluation: Compares decompressed output with original text

Parameters

• offsetBits: Number of bits used for back-reference offsets (9-12)
• lengthBits: Number of bits used for match lengths (3-6)

Output Metrics

• Shannon entropy (bits/character)
• Decompressed text samples
• Parameter performance comparison

5. Discussion and Future Directions

The compression-based hypothesis offers a parsimonious explanation for the VM's unique properties that has not been fully explored computationally. This framework provides a tool for such exploration. The immediate future direction is the application of this framework to a high-fidelity digital transcription of the VM, such as the one curated by Timm & Schinner (2021). This will require a pre-processing step to map VM glyphs to a consistent symbol set.

Furthermore, the assumption of a Huffman coding stage could be refined. Instead of a fixed mapping, an adaptive model could be tested. Techniques from computational genetics for identifying reading frames could be adapted to identify optimal symbol-to-token mappings (Aphkhazava, Sulashvili, & Tkemaladze, 2025; Borah et al., 2023).

A significant challenge remains validating any promising output. A drop in entropy is necessary but not sufficient for success. Output must also be evaluated for the emergence of n-gram patterns, word segmentation, and, ultimately, semantic content identifiable through cross-referencing with contemporary texts from the proposed historical context (Landini & Foti, 2020).

6. Conclusion

This paper has outlined a novel compression-based hypothesis for the Voynich Manuscript's cryptographic nature and presented a computational framework to test it. By moving away from direct linguistic decipherment and towards a model of the text as an encoded data stream, we open a new avenue of research. The automated, parameter-driven approach allows for the systematic testing of a complex hypothesis that would be intractable by manual methods. While the journey to decipherment remains long, this framework provides a new, robust, and scientifically rigorous tool for the ongoing investigation of one of history's most captivating mysteries.