eduKateSG · VOYNICH RESEARCH LIBRARY · TANGENTIAL VOYNICH IV
Tangential Voynich | Put the Manuscript Through a Compiler
Characters without letters. Tokens without words. Grammar without meaning. What happens when an unread manuscript is forced through lexing, parsing and syntax before anyone is allowed to translate it?
← Tangential Voynich: The Wrong-System Protocol · Previous False World: Operating System · Voynich Research Library
There is something beautifully dangerous about looking at the Voynich Manuscript and seeing words.
The spaces invite us.
Rows of repeated shapes invite us.
The page looks written.
So the modern reader performs an almost invisible conversion:
mark → letter → word → sentence → language → meaning.
Every arrow feels natural.
None is guaranteed.
A compiler engineer is professionally trained to distrust exactly this kind of collapse.
A compiler does not look at a stream of characters and instantly ask what the program wants.
It moves through layers.
Characters are grouped into tokens.
Tokens are arranged under grammar.
Grammar yields structural trees.
Only later does semantic analysis ask whether the structure makes sense.
This makes a compiler an unusually powerful wrong world for Voynich.
What if the biggest mistake in Voynich analysis is not choosing the wrong translation, but compiling the manuscript from the wrong units?
The Voynich Manuscript is not computer source code.
That statement is part of the experiment.
We are going to put it through a compiler precisely because a compiler is alien enough to make our assumptions visible.
FALSE-WORLD CONTRACT
Voynich Is Not Source Code
- A glyph is not a programming character.
- An EVA transcription token is not a lexical token merely because software calls it one.
- A space is not proven whitespace syntax.
- A gallows glyph is not an operator.
- A line is not a statement.
- A paragraph is not a function.
- A Currier population is not a programming language dialect.
- A diagram is not a syntax tree.
- A sequence that parses under an invented grammar is not therefore meaningful.
- A successful formal grammar does not identify historical function, language or provenance.
Every compiler term in this article is temporary. It may generate a test. It may not generate a meaning.
Parseability is not decipherment.
What a Compiler Does Before Meaning
A simplified compiler pipeline might look like this:
character stream → lexical units → parse structure → semantic checks → intermediate representation → output.
The order matters.
If the lexer groups characters incorrectly, the parser receives the wrong tokens.
If the parser imposes the wrong grammar, later semantic analysis inherits a distorted structure.
If semantic assumptions are injected too early, the system can appear to work only because its earlier layers were quietly bent to fit the desired meaning.
This is almost a perfect description of one of the central dangers in Voynich research.
A researcher may decide that one visible form is a “word.” That decision determines counts, entropy, morphology, frequency, co-occurrence and syntactic claims downstream.
A different segmentation may produce a different statistical object from exactly the same ink.
The compiler tangent therefore begins with a severe rule:
Do not let semantics choose the lexer.
This connects directly to the existing Voynich research on EVA, Transcription and the Segmentation Problem.
Lexing: What Is the Unit?
A lexer turns a raw character stream into classified units.
Consider ordinary source code:
total = price + tax;
A human programmer does not interpret every character independently. The lexer groups several characters into identifiers such as total and price, recognises operators such as = and +, and treats punctuation under defined rules.
The key point is that the visible character scale is not necessarily the functional scale.
That is exactly where Voynich becomes interesting.
Possible analytical units include:
- individual visible strokes;
- transcribed glyphs;
- multi-glyph recurring components;
- blank-delimited strings;
- morphological families;
- line-position units;
- larger recurrent sequences.
The compiler asks a question that a dictionary does not:
Which segmentation produces the most stable structural rules across held-out material?
That is far stronger than asking which segmentation looks linguistically familiar.
A good unit definition should improve prediction, survive transcription alternatives, reduce ad hoc exceptions and transfer across manuscript populations.
If a segmentation works only on the page from which it was invented, it is not a lexer.
It is a story.
The Blank-Space Test: Whitespace Is Syntax Only If It Behaves Like Syntax
Programming languages treat whitespace in very different ways.
In some, spaces are mostly ignorable. In others, indentation defines structure. A newline may end a statement in one language and be insignificant in another.
This is an excellent alien control for Voynich spaces.
A visible blank is an observation.
A word boundary is an interpretation.
The compiler tangent asks:
- Are all blanks statistically equivalent?
- Do narrow and wide gaps predict different continuations?
- Does removing some separator classes damage structural prediction more than removing others?
- Do edge-glyph relationships survive when apparent tokens are resegmented?
- Are some cross-space dependencies stronger than within-token dependencies?
If all spaces behave uniformly like hard lexical breaks, the conventional tokenisation gains support.
If separator regimes differ, we should stop pretending one visible gap has one universal function.
This question is especially timely because recent work has challenged the assumption that every visible separator should be treated as an ordinary word boundary.
The compiler did not discover that problem.
It makes the category error obvious.
Token Classes Before Token Meanings
A compiler groups lexical units into classes before it understands the program’s purpose.
One string may be an identifier.
Another may be a number.
Another an operator.
Another punctuation.
The compiler tangent suggests that Voynich analysis should distinguish structural classes from lexical meanings.
For example, two forms may belong to the same structural class if they:
- occupy similar positions;
- accept similar left neighbours;
- accept similar right neighbours;
- show similar boundary preferences;
- substitute for one another in comparable contexts;
- vary similarly across manuscript populations.
They do not need to look alike.
Likewise, two visually similar forms may belong to different structural classes.
This is a major conceptual shift.
Classify by behaviour before classifying by interpretation.
That principle connects naturally to Word Families, but the compiler tangent pushes it beyond visual morphology into distributional role.
Parsing: Which Sequences Are Structurally Legal?
Lexing identifies candidate units.
Parsing asks how those units may be arranged.
In a programming language, the tokens +, 7, x and = may all be valid lexical items. That does not mean every order is legal.
The Voynich equivalent is powerful.
A glyph family may be common. Another may be common. Their combination may nevertheless be rare or absent.
The parser asks:
- Which transitions are permitted?
- Which are strongly disfavoured?
- Which sequences recur as larger units?
- Which orderings are asymmetric?
- Which constraints depend on position?
- Which constraints change at boundaries?
This overlaps with the railway article’s route-conflict test and the operating-system article’s permission and mutex tests.
Three false worlds are now independently pointing toward the same neutral question:
What combinations are structurally unavailable despite adequate opportunity?
That repeated convergence is more important than the compiler metaphor itself.
Grammar Without Semantics
Formal grammar can describe structure without describing meaning.
A grammar might contain production rules such as:
A → BC
B → bB | b
C → cD | c
These rules define allowable construction. They do not tell us whether the resulting string means “bring water,” “Mars is rising,” or absolutely nothing.
This is a useful antidote to one of the great Voynich temptations.
We may discover a reproducible structural rule and feel pressure to translate it immediately.
The compiler says no.
First establish whether the rule predicts unseen material.
Then determine whether it belongs to syntax, morphology, abbreviation, cipher state, generation or scribal practice.
Meaning comes later.
Syntax can be real before semantics is known.
This is precisely the logic behind the existing Syntax Before Semantics research lane.
The Parse Tree: Surface Sequence May Hide Hierarchy
A compiler does not treat a valid program as a flat row of tokens.
It constructs hierarchy.
Consider the expression:
a + b * c
The visible sequence is linear, but multiplication may bind more tightly than addition. The functional structure is hierarchical.
This raises a major Voynich question:
Are blank-delimited strings themselves composed of smaller units with different binding strengths?
For example, apparent prefixes and suffixes may not be equal attachments. Some components may form tight recurrent cores while others behave like optional boundary material.
We can test hierarchical grouping through:
- subsequence recurrence;
- replacement patterns;
- conditional entropy;
- edge stability;
- mutual information among component positions;
- cross-population survival.
If a smaller recurrent unit predicts behaviour better than the whole apparent token, the flat token model weakens.
The parse-tree metaphor disappears.
Hierarchical segmentation survives.
Precedence: Some Constraints May Dominate Others
Programming languages contain precedence rules.
One operator can bind more strongly than another. Parentheses can override default order.
The Tangential question is whether several Voynich constraints operate at different strengths.
For instance:
- line position may strongly predict one component;
- Currier regime may alter another;
- local neighbour may dominate a third;
- paragraph status may override ordinary line-start behaviour.
Rather than asking which single variable explains a form, we can estimate a hierarchy of constraints.
One simple modelling approach is to compare predictive gain as variables are added or removed.
If line position explains most of the variance and page type adds little, line position has higher structural precedence under that model.
The language of “precedence” is temporary.
The neutral result is a ranked constraint hierarchy.
Operators: Do Some Forms Transform Context Rather Than Name Things?
The word operator is one of the most dangerous words in Voynich research.
It sounds explanatory.
It can become a disguised translation.
The compiler tangent gives us a way to use the concept without promoting it prematurely.
An operator-like form should not merely look unusual. It should have measurable structural effects.
- It may occupy restricted positions.
- It may change the distribution of neighbouring components.
- It may alter which continuation classes are legal.
- It may appear across multiple local vocabularies while preserving the same structural role.
- Its presence may predict a transformation between related forms.
If none of those properties survives, calling it an operator adds nothing.
If they survive, the neutral result is not “this glyph means APPLY.”
It is:
This form participates in a reproducible context-transforming relation.
That is narrower.
And therefore much stronger.
Scope: The Same Form May Behave Differently Inside Different Regions
Programming languages contain scope.
A name may be valid inside one function but not another. The same identifier may refer to different objects in different scopes.
This creates a useful way to think about Voynich regionality.
A form’s behaviour may depend on whether we condition on:
- page;
- quire;
- Currier regime;
- proposed hand;
- visual morphology;
- label versus running text;
- line position;
- paragraph position.
A global frequency can hide local grammar.
Suppose form X precedes family Y globally 20 per cent of the time. That statistic may be meaningless if the relation is 60 per cent in one population and 2 per cent in another.
The scope tangent therefore asks:
At what structural scale does a rule become stable?
That is a more important question than whether the rule exists in one global corpus average.
Local and Global Names: One Shape Can Participate in More Than One Rule
A compiler can encounter the same spelling in different scopes without treating every instance as globally identical.
Voynich research should be equally cautious.
The same transcribed form may occur under different page regimes, line positions or visual contexts.
Before collapsing them, test whether their neighbourhood distributions are equivalent.
If identical forms behave differently in distinct contexts, there are several possibilities:
- polyfunctionality;
- scribal variation;
- hidden segmentation;
- different generative modes;
- different semantic uses;
- transcription collapse of genuinely distinct glyphs.
The compiler analogy cannot choose among them.
It prevents premature global identity.
Syntax Errors: The Most Interesting Sequence May Be the One That Never Occurs
A syntax error is valuable because it marks a violation of structure.
Voynich has no error messages.
But we can still ask what a hypothetical syntax error would look like statistically.
If two common components are never observed in one order despite thousands of opportunities, that absence may reveal a rule.
If a rare combination occurs once in a damaged region, the event may be a transcription error, scribal correction, exceptional construction or evidence against the rule.
The crucial discipline is to predefine what counts as violation.
Otherwise every exception becomes an excuse.
A structural grammar is only useful if it can be wrong.
This turns “strange token” into a falsification problem.
Does the model predict that this sequence should not exist?
If it exists reliably, the model changes or dies.
Error Recovery: Do Apparent Violations Reveal the Grammar?
Compilers often attempt to continue after an error so that one mistake does not prevent all later analysis.
That behaviour suggests another Voynich question.
If an unusual form or sequence occurs, does normal local structure resume immediately afterward?
Or does the unusual event alter the following distribution?
We can compare:
- pre-event distribution;
- event neighbourhood;
- post-event recovery distance;
- matched rare-event controls;
- boundary-conditioned effects.
This overlaps with the railway tangent’s delay-propagation model and the operating-system tangent’s interrupt-response model.
Three alien systems now independently produce a neutral quantity:
perturbation decay length.
How far does a local unusual event influence the sequence?
That is becoming a Tangential invariant candidate.
Ambiguous Grammar: What If More Than One Parse Fits?
A grammar is ambiguous when one sequence can be parsed in more than one valid way.
Voynich is almost certainly full of analytical ambiguity because we do not know the correct unit boundaries.
The compiler tangent therefore says: do not hide ambiguity.
Represent it.
If a sequence can be segmented as:
[AB][CDE] or [ABC][DE]
both parses should remain alive until evidence discriminates.
Then compare which parse:
- recurs elsewhere;
- improves held-out prediction;
- reduces exception count;
- aligns with boundary geometry;
- survives across transcription variants.
This replaces premature segmentation with a parse forest: several candidate structures retained under explicit uncertainty.
The phrase parse forest will disappear from the final Voynich claim.
The principle should remain:
Where unit structure is uncertain, analysis should propagate multiple candidate segmentations rather than silently choosing one.
Type Checking: Structurally Similar Does Not Mean Interchangeable
Programming languages can distinguish types.
Two values may both occupy an expression but not be valid in the same operation.
This suggests a test for Voynich structural families.
Two forms may share visual morphology but differ in positional behaviour.
Two forms may share neighbours but differ at boundaries.
Two forms may appear interchangeable within one Currier regime but not another.
A useful structural “type” therefore requires several independent compatibility dimensions.
- positional compatibility;
- left-context compatibility;
- right-context compatibility;
- boundary compatibility;
- population compatibility;
- replacement compatibility.
Only if these align should two units be merged into one functional class.
This protects us from assuming that visual resemblance equals functional identity.
Semantic Analysis: The Compiler’s Most Important Restraint
A program can be syntactically valid and still semantically nonsensical.
For example, a compiler may successfully parse an operation whose operands have incompatible types.
This is perhaps the most important compiler lesson for Voynich.
A sequence can possess deep, reproducible structure and still not tell us what it means.
A formal grammar can fit.
A state model can fit.
A network model can fit.
None of those is a semantic bridge by itself.
Structure is necessary for many meaningful systems. It is not sufficient to prove meaning.
This is where many decipherment claims fail.
They discover or impose a structural regularity and immediately label it with a meaning.
The compiler insists on a separate semantic pass.
Tangential Voynich should too.
Intermediate Representation: Sometimes the Best Model Is Not the Original Surface
Compilers often translate source code into an intermediate representation before producing machine code.
The intermediate representation strips away some surface differences while preserving structure relevant to later operations.
This is an intriguing model for Voynich analysis.
Raw transcription may preserve too much surface detail.
Overaggressive normalisation may preserve too little.
Perhaps we need several neutral intermediate representations:
- glyph-shape class;
- multi-glyph component class;
- positional role class;
- token-family class;
- boundary-state class;
- page-interface class.
Then ask which representation best preserves cross-population predictions.
This is not decipherment.
It is model engineering.
The right representation can make a hidden regularity visible without telling us what the regularity means.
Optimisation: Beware the Model That Fits Because It Has Learned Every Exception
A compiler may optimise a program while preserving behaviour.
Research models also get “optimised”—but in dangerous ways.
A researcher sees an exception and adds a rule.
Then another exception appears.
Another rule is added.
The model becomes more accurate on the pages already seen.
It may simultaneously become less scientific.
This is overfitting.
The compiler tangent therefore insists on optimisation with invariants:
- rules must remain stable;
- held-out prediction must improve;
- exception count must not explode;
- alternative segmentations must be tested;
- the model must survive other manuscript populations.
A model that only works after seeing every page is not a compiler.
It is a memoriser.
Compiler Warnings: Not Every Oddity Needs to Be Fatal
Compilers distinguish fatal errors from warnings.
This is a useful scientific habit.
A Voynich model should not collapse because one rare exception appears.
But neither should it silently ignore the exception.
We need graded failure states.
| Observation | Possible treatment |
|---|---|
| Single ambiguous transcription | Uncertainty flag; do not promote as rule violation. |
| Rare but verified exception | Warning; test whether model permits exceptional class. |
| Repeated violation across independent pages | Major grammar failure. |
| Violation restricted to one hand or interface | Possible scope-specific rule. |
| Violation disappears under alternate segmentation | Segmentation-sensitive warning. |
This is more faithful than forcing every anomaly into “the theory is false” or “the theory is still true.”
Scientific models can fail locally, conditionally or globally.
A Grammar Can Generate Gibberish
This point must be made explicit.
A formal grammar can generate perfectly structured nonsense.
Programming-language grammar can generate syntactically valid expressions that do nothing useful.
Human-produced pseudo-text can exhibit local constraints.
Ciphers can preserve or create structure.
Copy-and-modify procedures can create families, recurrence and positional regularity.
Therefore:
Discovering a grammar would be a major result. It would not, by itself, prove that the manuscript contains natural-language prose.
This is why Tangential Voynich keeps generator models, language models, cipher models and notation models alive simultaneously.
The compiler is a structural interrogator.
Not a semantic judge.
Reverse Tangential Test: Hide the Meaning of Real Source Code
The compiler tangent becomes scientific when we reverse it.
Take several known programming languages.
Remove identifiers, comments, file names and semantic labels.
Replace token types with neutral symbols.
Preserve sequence, punctuation, line structure and scope boundaries.
Can the methods intended for Voynich recover:
- token classes;
- operator-like positions;
- statement boundaries;
- nested structure;
- scope;
- illegal combinations;
- grammar families;
- language or dialect populations;
- perturbation recovery?
Then run the same analysis on generated pseudo-code with no executable meaning.
If the method cannot distinguish structured meaning-bearing code from structured nonsense, its Voynich conclusions must remain correspondingly narrow.
A method should prove what it can recover in known worlds before we let it make metaphysical claims in an unknown one.
What Would Make the Compiler World Fail?
| Compiler projection | Failure condition | Possible neutral residue |
|---|---|---|
| Lexer | No segmentation is more stable or predictive than conventional blank-delimited tokens. | Conventional tokenisation remains competitive. |
| Token classes | Behavioural clustering is unstable across samples and transcription variants. | No robust structural classes recovered. |
| Grammar | Rules require many page-specific exceptions and fail held-out material. | Local constraints may exist without compact grammar. |
| Parse hierarchy | Sub-token grouping adds no predictive value beyond flat units. | Hierarchical segmentation unnecessary under tested model. |
| Operator-like forms | Context-transforming effects disappear under frequency and position controls. | No special transition class. |
| Scope | Rules remain statistically equivalent across populations. | Global model may be adequate. |
| Syntax errors | Supposedly forbidden sequences occur freely when coverage expands. | Exclusion was sampling artefact. |
| Type classes | Replacement and neighbourhood behaviour do not support distinct functional families. | Visual similarity may be superficial. |
The compiler should fail aggressively where the manuscript does not support it.
That failure is part of the design.
The Compiler Experiment Pack
- Multi-segmentation lexer challenge: compare blank-delimited, glyph-component and learned multi-symbol units.
- Separator-regime test: test whether all visible gaps behave as one boundary class.
- Behavioural token classes: cluster units by positional and neighbour distributions rather than visual resemblance alone.
- Negative-grammar scan: identify stable prohibited combinations under opportunity-matched controls.
- Hierarchical grouping test: compare flat and nested representations on held-out prediction.
- Constraint-precedence analysis: rank line position, boundary state, Currier regime, hand and local context by predictive contribution.
- Transition-transformer test: search for forms associated with reproducible before/after distribution changes.
- Scope analysis: estimate the structural scale at which rules become stable.
- Ambiguous-parse propagation: preserve several plausible segmentations instead of forcing one.
- Type-compatibility analysis: test functional interchangeability across contexts.
- Perturbation-recovery analysis: measure how quickly normal distributions resume after unusual events.
- Reverse compiler calibration: anonymise known code and structured pseudo-code and test recovery limits.
- Held-out Voynich gate: freeze unseen pages before grammar optimisation.
- Metaphor removal: rewrite all surviving claims without compiler terminology.
Three Wrong Worlds, One Emerging Measurement Set
We now have three deliberately incompatible false worlds.
Railway control.
Operating systems.
Compilers.
Their surface metaphors disagree almost completely.
Their surviving neutral questions are beginning to converge.
| Neutral measurement | Railway | Operating system | Compiler |
|---|---|---|---|
| Boundary-conditioned change | Terminal / turnaround | Boot / shutdown / interrupt | Statement / scope boundary |
| Structural bridge forms | Interchange | System call / IPC bridge | Transition-mediating token class |
| Stable exclusion | Route conflict | Permission / mutex | Syntax prohibition |
| State persistence | Delay propagation | Memory | Parse context / recovery length |
| Shared deeper rules | Several lines, one network | Several processes, one kernel | Several local strings, one grammar family |
| Representation sensitivity | Node definition changes network | State definition changes process model | Lexer choice changes grammar |
| Known-world calibration | Anonymised railway | Anonymised OS trace | Anonymised code / pseudo-code |
This is the first moment when Tangential Voynich begins to become more than a series of creative essays.
It is starting to construct a cross-world invariant test suite.
The wrong worlds disagree about what the manuscript is. They are beginning to agree about what should be measured.
Metaphor Removal
Now delete the compiler.
Remove source code.
Remove lexers.
Remove parse trees, scopes, operators, syntax errors and types.
What remains?
- The functional unit of Voynichese is not established by visual spacing alone.
- Alternative segmentation schemes should compete on predictive stability rather than familiarity.
- Units can be classified by structural behaviour before meaning.
- Stable negative constraints may reveal structure as strongly as positive recurrence.
- Apparent strings may possess hierarchical internal organisation.
- Different constraints may operate at different strengths.
- Some forms may correlate with reproducible context transformations without receiving lexical meanings.
- Rules may be scope-dependent across manuscript populations.
- Analytical ambiguity should be propagated rather than hidden.
- A formal grammar, if discovered, would not by itself establish natural language or semantics.
- Known-world calibration can tell us what our methods are actually capable of recovering.
Those claims no longer depend on computer science vocabulary.
The compiler has done its job.
World Return
The Voynich Manuscript is not a program waiting to be compiled.
But the compiler has taught us a discipline that may be much more important than another translation attempt.
Do not call a glyph a letter because it looks like writing.
Do not call a blank-delimited string a word because the page contains spaces.
Do not call a repeated component a morpheme because it behaves regularly.
Do not call a boundary grammatical because it changes probability.
Do not call a context-transforming form an operator because the word sounds useful.
First identify the units.
Then identify the allowed structures.
Then test whether those structures survive unseen material.
Only then begin asking what they might mean.
Perhaps the manuscript has resisted us partly because we keep trying to read a semantic object before we have correctly compiled its representation.
That sentence is not a claim that Voynich is code.
It is a warning about us.
Tangential Voynich: The Wrong-System Protocol → · Operating-System Experiment → · Railway Control Experiment → · Voynich Research Library →
Next Tangent: treat the manuscript as a database. Records, keys, joins, indexes, nulls, schemas, repeated fields and missing relationships will force a completely different attack on the same object.
NEXT FALSE WORLD · DATABASE
The compiler asked whether we are using the right units. The database asks whether those units participate in larger records, cross-layer identities and relationships that can survive separation across pages.
Continue to Tangential Voynich | Treat the Manuscript as a Database →