Zelah Hutchinson - Introduction

Who I Am

Zelah Hutchinson is constructing a unified substrate for thinking — a geometry of computation where:

numbers become rooms
stories become algorithms
constraints become logic
reversible steps become energy‑efficient computation
and every artifact is a doorway into a larger conceptual architecture

It's a long‑term project, built piece by piece, openly, and with the intention of lasting far beyond any single tool or system.

Current Practice: I'm currently doing deep offline work to develop a mind palace and program on paper.

What I've Built

C2L (Compile to Lisp)

Bracket-to-Lisp compiler with optional Scheme dot-notation translation. Transforms [ into ( and auto-closes at line ends. Includes a JavaScript port of a Scheme self-hosting compiler for right-to-left argument gathering.

Compiles to Scheme and the Calculus of Indications (Spencer-Brown's Laws of Form).

CORE (COmpREss)

Bijective compression algorithm with dual encodings and control sequences. Uses BigInt for arbitrary precision. Starting with 4, applies one-encode (n × 2) - 3 for 1-bits and zero-encode (n × 2) - 2 for 0-bits, then subtracts 4.

Self-delimiting, reversible, with alternate output for compression control.

LEGENDARY / ONENOTNONE

Complete multiplayer social gaming platform built on Puter.js. Public message board for finding players, private group chat for gaming sessions. Full auth system, real-time messaging, group management.

User #1 (and only user): me. "Where One Becomes Many, and None Becomes All."

The Story Engine

Modular storytelling game with mix-and-match mechanics: Wordprocessor (syllable counting mod 3 with finger position memory), Luckflow (resource management with recursive luck gain), What If... (forced narrative pivots), Threadweaver (callback rewards for connections).

Designed to play in the mind palace amid invention reminders.

MindHex Navigator

Hex-grid mind palace navigation system using triangular number addressing. Words map to room numbers via dice code and directional snapping. Every non-negative integer has its own hex room.

Examples: spider=122, sphere=123, zelah=61

What I'm Working On

LoF Constraint Programming

Constraint programming on integers using my version of the Calculus of Indications. Uses explicit temporal ordering (temporal_order, bit_reference) instead of re-entry. Self-delimiting integer encoding with run-length compression for zeros.

Infinite logical bits (unbounded bit_reference)
No re-entry needed—time is explicit
Full-adder in LoF as the basis for integer constraints
Individual output bits computed in parallel by separately evolved programs

Fractran → Nanofuck Evolution

Evolving Fractran programs to compile to Nanofuck (reversible Turing-complete language) for massively parallel, near-zero energy computation. This is the really long game—massively parallel computation requiring next to no energy input. Fractran seems implementable on this and natural for evolution.

Nanofuck: Reversible = thermodynamically efficient (Landauer's principle)
Fractran: Number-theoretic, evolutionarily searchable
Per-bit evolution: Separate programs for each output bit, massively parallel
Goal: Landauer-limit computation through evolutionary programming

Mind Palace Development

Building a complete memory system combining:

MindHex navigation: Words → hex rooms via triangular calculation
Collatz mnemonics: Room number → Collatz sequence → dice code letters
Story Engine: Narrative fragments as mnemonic anchors
Invention reminders: Computational ideas embedded in stories

I don't need the mind palace, but it can't hurt and it's fun.

Philosophy & Practice

Maximum Influence

I release everything publicly (Puter, pastebin, personal site, archive.org) under CC0. The goal is to seed the noosphere with computational primitives—quality training data for future AIs and humans.

Distribution Strategy

Puter: Living, interactive artifacts
Pastebin: Raw code, easily discoverable
Personal site: Canonical home
Archive.org: Permanent record, survives link rot

The Long Game

I'm building artifacts that demonstrate:

Reversible computation paths (number theory → state machines)
Constraint logic as boundary operations
Evolutionary programming in minimal languages
Self-delimiting encodings and compression
Cloud-first architecture patterns

Technical Details

Dice Code Mapping

Letters map to two-digit codes for hex navigation:


1: 123456

2: 7890ab

3: cdefgh

4: ijklmn

5: opqrst

6: uvwxyz

Second digit becomes direction (1-6), snaps to allowed directions, rearranged for computation.

Hex Navigation Formula

room = direction_sum + 6×(T_n - m)

where:
  n = total_moves - 1
  m = (total_moves - count_of_1s) if snapped to 6 with at least one 1, else 0
  T_n = nth triangular number (1, 3, 6, 10, 15, 21...)

Example: "zelah" (snaps to 6 with 1s)

Letters: z(66) e(33) l(44) a(25) h(36)
Second digits: 6, 3, 4, 5, 6
After snapping to [6,1]: 6, 6, 1, 6, 6
Rearranged: 6, 6, 6, 6, 1
direction_sum = 6+6+6+6+1 = 25
n = 5-1 = 4, so T₄ = 10
m = 5-1 = 4 (snapped to 6 with one 1)
room = 25 + 6×(10-4) = 25 + 36 = 61

Example: "spider" (no 1s)

Letters: s(55) p(52) i(41) d(32) e(33) r(54)
Second digits: 5, 2, 1, 2, 3, 4
After snapping: 5, 5, 6, 5, 6, 5
Rearranged: 5, 5, 5, 5, 6, 6
direction_sum = 5+5+5+5+6+6 = 32
n = 6-1 = 5, so T₅ = 15
m = 0 (no 1s present)
room = 32 + 6×15 = 32 + 90 = 122

LoF Integer Encoding

Self-delimiting with run-length compression:

Count zeros → grab that many digits
Compression: 110 means "next 3 bits encode zero count"
Offset to avoid duplication: binary_value + (2¹ + 2² + ... + 2^(n-1))
Example: 1101111234567890123 encodes 13 zeros before the digits

Current Status

Starting deep work: Mon-Fri offline, programming on paper, developing mind palace

Journal: #1 of 40, radically unstructured

Projects: All released publicly, user #1 (me) for most of them

Next artifacts: LoF constraint language, Fractran evolution system, populated mind palace rooms