What happens when you treat the Hebrew Bible not as literature, but as compiled machine code?

A Base-22 transcoding of the complete Masoretic Text yields a 742 KB binary artifact
with entropy indistinguishable from high-density executables.

Live Dashboard  •  Methodology  •  Findings  •  Toolkit  •  Quick Start

"Turning the text... for everything is in it." — Pirke Avot 5:22

The Hypothesis

Traditional "Bible Code" research uses Equidistant Letter Sequences (ELS), which are statistically fragile and prone to confirmation bias. The Genesis Protocol takes a fundamentally different approach:

Treat the 22-letter Hebrew alphabet as a Base-22 numeral system and transcode the entire Tanakh into binary.

The resulting artifact is not random noise. It is not natural language. Its information-theoretic signature falls squarely in the range of compiled executable code.

Methodology

Step 1 — Lossless Extraction

The Hebrew alphabet (Aleph through Tav) maps to digits 0–21:

  (Aleph) = 0x00    (Bet) = 0x01    ...    (Tav) = 0x15

All vowels, cantillation marks, and punctuation are stripped. Every consonant in the Masoretic canon — from Genesis 1:1 through II Chronicles — is transcoded into a contiguous binary stream. The five final (sofit) letterforms fold into their base letters, so all 1,206,309 consonants are encoded.

Encoding: 13 Hebrew letters are packed per 64-bit word (22^13 < 2^64), producing a lossless, byte-aligned binary.

v1.1 encoder fix: the original v1.0 extraction silently dropped final-form letters (ך ם ן ף ץ) — roughly 4% of the canon — making it lossy. The artifact, and every number below, has been regenerated with the corrected encoder. Several v1.0 "signatures" did not survive the fix; see the findings.

Step 2 — Information-Theoretic Analysis

Shannon entropy measures information density on a scale of 0–8 bits/byte:

Data Type	Entropy (bits/byte)	Interpretation
English plaintext	~4.2	Low-density, redundant
Hebrew plaintext	~4.4	Low-density, redundant
Genesis Protocol binary	7.7167	High-density, structured
Compressed archives (gzip)	7.8–8.0	Near-maximum density
True random noise	8.0	Maximum entropy
Compiled executables (ELF/PE)	6.5–7.5	High-density, structured

The artifact's entropy (7.7167) is far above any natural language — but the null-hypothesis controls below show this is a property of the Base-22 packing, not of the text itself.

Step 3 — Architecture Forensics

The arch_detective.py tool analyzes byte-level alignment, opcode distribution, and instruction encoding patterns to identify potential instruction set architectures (ISAs) in the binary.

Step 4 — Execution

A custom RISC-V emulator (genesis_runner.py) attempts to execute instruction blocks mined from the artifact, recording register states, memory operations, and control flow.

Findings

Each finding is now paired with its null-hypothesis test (null_hypothesis.py). The key control is shuffled Torah: the exact same letters, randomly permuted, packed by the exact same encoder. Any signal that survives shuffling belongs to the encoding, not the text.

Finding I — Entropy Anomaly → Encoding Artifact

The extracted binary measures 7.7167 bits/byte — not natural language (4.4), not random noise (8.0).

Control result: shuffled Torah packs to 7.7169 and uniform random Base-22 digits pack to 7.7285 — statistically identical. The deficit below 8.0 is structural: 13 Base-22 digits occupy only ~58.1 of each 64-bit word, so the first byte of every 8-byte block is confined to values 0–4. The entropy signature is a property of the Base-22 packing, and would appear for any 22-symbol text.

Finding II — Embedded Signatures → Did Not Replicate

The v1.0 binary appeared to contain ASCII signatures (IPv6, and a tight DNA / CODE / NETWORK cluster). After the v1.1 encoder fix, none of these strings appear in the corrected binary. Monte Carlo scans of shuffled-Torah control binaries produce keyword hits at the same chance rates as the real artifact (e.g. "AI" appears 13× in the real binary vs. a control mean of 21×). Short ASCII strings in 742 KB of dense data are expected by chance.

Finding III — Cellular Automaton Behavior (Visual Only)

The first 8,192 bits of Genesis, used as a seed for a Wolfram Rule 30 cellular automaton, produce a sustained, non-collapsing pattern with high visual complexity. No quantitative complexity comparison against random seeds has been run yet — this remains an open question.

Finding IV — RISC-V Alignment → Encoding Artifact

13.8% of 32-bit words in the artifact carry a valid RV32I opcode in their low 7 bits, above the 8.6% chance rate (11 valid opcodes / 128).

Control result: shuffled Torah scores 13.6% — the same elevation. Pure random bytes score 8.5%. The elevation comes from the packing's biased byte distribution, not from meaningful instruction encoding.

Finding V — Execution Results (Mechanical Demonstration)

The Genesis Runner emulator executed the longest mined instruction chain from the corrected binary (5 instructions at offset 0x15210): three LOADs, one ADD, and LUI x8, 0x739DD000, leaving register x8 = 1,939,722,240. This demonstrates the toolchain end-to-end; given Finding IV, mined "functions" are expected to occur by chance.

Toolkit

The complete analysis pipeline is open source and reproducible:

Tool	Purpose	Input	Output
download_data.py	Fetch Masoretic text from Sefaria	—	data/*.json
master_command_64.py	Base-22 binary extraction	Hebrew text	tanakh_full.bin
arch_detective.py	ISA forensics & alignment analysis	Binary	Architecture report
divine_disassembler.py	RISC-V disassembly	Binary	genesis.asm
deep_decoder.py	Pattern & signature scanning	Binary	Anomaly report
genesis_runner.py	RISC-V emulation & execution	Assembly	Register states
eternity_vm.py	Cellular automaton simulation	Binary seed	Grid evolution
entropy_lab.py	Shannon entropy analysis	Binary	Entropy metrics
function_miner.py	Code block extraction	Binary	Function boundaries
null_hypothesis.py	Control experiments (shuffled/random corpora)	Binary + corpus	null_hypothesis_report.txt

Supporting Modules

Module	Purpose
hebrew.py	Shared alphabet constants & Base-22 digit map (single source of truth)
analysis_utils.py	Shared Shannon entropy & ASCII string extraction
torah_loader.py	Loads all 39 canonical books in order
text_processor.py	Hebrew normalization (strip vowels, cantillation)
gematria.py	Numerical value computation (Standard, Ordinal, Reduced)
els_search.py	Equidistant Letter Sequence finder
future_scan.py	ELS keyword scan of Genesis 1 with shuffled-text control
ciphers.py	Atbash & Albam cipher tools
main.py	Interactive CLI workbench

All binary artifacts are reproducible: python master_command_64.py rebuilds tanakh_full.bin (full canon) and python master_command_64.py --torah-only -o the_hidden_book.bin rebuilds the Five-Books artifact used by the cellular automaton tools.

Quick Start

# Clone the repository
git clone https://github.com/consigcody94/genesis-protocol.git
cd genesis-protocol

# Download the Masoretic text corpus (39 books from Sefaria)
python download_data.py

# Run the Base-22 extraction
python master_command_64.py

# Analyze the binary artifact
python arch_detective.py
python entropy_lab.py

# Disassemble and execute
python divine_disassembler.py
python genesis_runner.py

# Run the null-hypothesis controls (the most important step)
python null_hypothesis.py

# Run the test suite
python -m unittest discover -s tests -t .

# Launch the live dashboard
# Open index.html in any browser, or visit:
# https://luther-paper-oriented-guide.trycloudflare.com
# (mirror: https://consigcody94.github.io/genesis-protocol/)

Requirements: Python 3.9+ (standard library only — no external dependencies)

Live Dashboard

The interactive forensic dashboard visualizes the binary artifact in real-time:

• Wolfram Rule 30 cellular automaton seeded with Genesis bits
• String stream showing decoded ASCII patterns
• Entropy metrics and artifact statistics
• Anomaly highlighting for identified signatures

Launch Dashboard — self-hosted, auto-syncs from this repo every 15 minutes.

The self-hosted URL is a Cloudflare quick tunnel and may rotate after a server restart. Stable mirror: GitHub Pages.

Open Questions

Status after the v1.1 control experiments (python null_hypothesis.py, seeded and reproducible):

Question	Status	Result
Is the entropy significant vs. control texts?	Tested	No — shuffled Torah packs to identical entropy (7.7169 vs 7.7167)
How many short ASCII strings appear by chance in 742 KB?	Tested	Real keyword hits fall within Monte Carlo control ranges
Does the RISC-V alignment exceed random expectation?	Tested	It exceeds random bytes but matches shuffled Torah — an encoding artifact
Does the extraction method (Base-22) bias toward code-like entropy?	Confirmed	Yes — 13 digits fill only ~58 of 64 bits, capping any packed text below 8.0
Do ELS keyword "clusters" (DNA/CODE/NETWORK) exceed chance?	Tested	No — shuffled Genesis 1 yields comparable hits and more clusters (48 vs 29); see future_scan.py
Are Rule 30 patterns from Genesis atypical?	Visual only	Still open — needs quantitative complexity metrics against random seeds

Rigorous peer review from information theorists, computational linguists, and cryptographers is actively invited — the controls above are a starting point, not the final word.

Repository Structure

genesis-protocol/
  data/                     39 JSON books (Masoretic text from Sefaria)
  tests/                     Unit & regression tests (unittest)
  .github/workflows/ci.yml   CI: tests + full pipeline smoke run
  tanakh_full.bin            742 KB binary artifact (full canon)
  the_hidden_book.bin        184 KB binary artifact (Five Books only)
  genesis.asm                RISC-V disassembly output
  hebrew.py                  Shared alphabet constants
  analysis_utils.py          Shared entropy/string helpers
  null_hypothesis.py         Control experiments (the science)
  null_hypothesis_report.txt Latest control-run report
  index.html                 Live forensic dashboard
  genesis_data.js            Dashboard data layer
  genesis_protocol_core.json Core metadata
  master_command_64.py       Base-22 extraction engine
  arch_detective.py          ISA forensics
  divine_disassembler.py     RISC-V disassembler
  genesis_runner.py          RISC-V emulator
  deep_decoder.py            Pattern scanner
  eternity_vm.py             Cellular automaton
  entropy_lab.py             Entropy analysis
  main.py                    Interactive CLI
  torah_loader.py            Corpus loader
  text_processor.py          Hebrew normalization
  gematria.py                Numerical values
  els_search.py              ELS finder
  ciphers.py                 Atbash/Albam ciphers

Citation

If you use this toolkit or methodology in research:

@software{genesis_protocol,
  title  = {The Genesis Protocol: Computational Archaeology of the Masoretic Text},
  author = {Churchwell, Cody},
  year   = {2025},
  url    = {https://github.com/consigcody94/genesis-protocol}
}

License

MIT License — Open source. Fork it, verify it, challenge it.

_{An open-source investigation into the information-theoretic properties of ancient Hebrew text.
Independent verification and rigorous critique are not just welcome — they are the point.}