Home

CTMM

Church-Turing Meta-Machine

A Capability-Based Security Simulator

Kenneth J Hamer-Hodges

Kenneth J Hamer-Hodges

Author & CTMM Architect

Industrial Strength Computer Science

Welcome to the CTMM Simulator

The Church-Turing Meta-Machine (CTMM) is a 32-bit clean-start architecture devised by Kenneth J Hamer-Hodges, FIEE. It enforces failsafe security through Golden Tokens β€” capability keys that govern all access control.

This simulator combines Alonzo Church's Lambda Calculus with Alan Turing's computational model to demonstrate how capability-based security can eliminate entire classes of vulnerabilities, including buffer overflows, privilege escalation, and unauthorised access.

This is not computation on the dangerous, centralised von Neumann architecture where any flaw can compromise everything. Instead, Lambda Calculus abstractions, when built with CLOOMC, are anchored to the real world through capability-based hardware enforcement, creating a solid foundation as trustworthy as mathematics itself.

Malware thrives on today's vulnerable systems, enabling mass surveillance and paving the way for government dictatorship. In contrast, CLOOMC and Lambda Calculus are distributed atomically, supporting democracy and individual sovereignty for the endless future of civilisation.

πŸ”
Golden Tokens

Every access requires a valid capability token with explicit permissions

Ξ»
Lambda Calculus

Church's mathematical foundation for computation and recursion

βš™οΈ
Turing Machine

Complete instruction set for arithmetic, logic, and control flow

CLOOMC: Computing on Solid Ground

CLOOMC (Capability-Limited / Object-Oriented / Machine-Code) is a high-level machine programming language that enables media-tight computation - where both data and functions are protected by Golden Tokens at every level.

Unlike traditional systems built on the soft surface of sand - vulnerable to buffer overflows, injection attacks, ROP attacks, confused deputy attacks, and privilege escalation - CLOOMC abstractions are rooted in the hard surface of universal cyberspace.

CLOOMC is designed for the 32-bit clean-start CTMM β€” an architecture that replaces the legacy von Neumann model with eleven hardware-enforced Church instructions, each operating exclusively on Golden Tokens rather than raw memory addresses.

Lambda Calculus Examples

Y-Combinator (Fixed-Point Recursion)

Church Numerals

Church Booleans

HP-35 Calculator (RPN via Lambda Calculus)

GitHub
Boot Sequence:

Church Registers

Lambda Registers

CR15 (Namespace): NULL
CR8 (Thread): NULL
CR6 (C-List): NULL
CR7 (Nucleus): NULL
NIA: 0
Stack: 0 words

Turing Registers

0-7

Flags & Stack (0 words)

Turing:
N Negative
Z Zero
C Carry
V Overflow
Church:
P Perm OK
B Bounds OK
Stack is empty
Selected: None

Namespace Objects

Click to select, then use toolbar buttons above

Boot system to view namespace

C-List Hierarchy

Tree structure from C-List connections

Boot system to view hierarchy
Introduction to Capabilities ▾
Informational
Introduction to Capabilities
Golden Token Structure
Context & Data Registers
Security Boundaries
Performance Benefits
Remote Golden Tokens
Failsafe Security
Simulator
The Boot Sequence
Capability Operations
Lambda Combinators
Assembly Editor
Church Instructions Deep Dive
Branch Instructions
Church Indicators & TPERM
Capability Manager
Mint: The Capability Forge
Examples
Example Programs
Atomic Operations (LOADX/SAVEX)
Multiple Register Operations (LDM/STM)
LDI and TPERM Presets
Hello Mum: The Holy Grail
Step 1 of 5
Step 1 of 5

Instruction Visualizer

Watch data flow through registers as instructions execute

Source Registers

DR?
-
DR?
-
?
-

Destination

DR?
-

Condition Flags

N
Negative
Z
Zero
C
Carry
V
Overflow

Step-by-Step

Select an instruction and click Setup to begin

Context Register

C-List

Select a Golden Token

Click on any capability token to view its details

Click an abstraction with E permission in the Namespace hierarchy or Capabilities view to zoom in.
Select an abstraction to view its C-List entries
docs/instruction-set.md ↗ raw

Loading hardware reference…

Boot/Nucleus/program.asm [RX]
NIA: 0 Stack: 0 Ready
Line 1
1

Church Registers

Turing Registers

Flags

N Z C V
CTMM Assembly Editor Ready
Write code and click Run or Step to execute

Source Files

πŸ“ web/
πŸ“„ app.js ~430KB
πŸ“„ simulator.js ~26KB
πŸ“„ index.html ~44KB
πŸ“„ styles.css ~98KB
🐍 server.py ~2KB
πŸ“ docs/
πŸ“ figures/
Select a file to view

CTMM Simulator Source Code

Click on a file in the left panel to browse the source code.

~10,000 Lines in app.js
5 Source Files
~600KB Total Code
app.js - Main application: namespace objects, boot C-List, abstraction C-Lists, tutorials, examples, UI
simulator.js - Execution engine: instruction parsing, register operations, CALL/RETURN stack
index.html - Page structure: all views, modals, context menus
styles.css - Visual styling: dark theme, panels, animations
server.py - Simple HTTP server for local development
+ Add Child Object
✎ Edit Object
βœ• Remove Object
Insert Instruction
+ Arithmetic β–Ά
ADD dest src
SUB dest src
MUL dest src
NEG dest src
ADDI dest imm
SUBI dest imm
& Logic β–Ά
AND dest src
ORR dest src
EOR dest src
BIC dest src
NOT dest src
β†’ Move β–Ά
MOV dest src
MVN dest src
⟷ Shift β–Ά
LSL dest src amt
LSR dest src amt
ASR dest src amt
ROR dest src amt
= Compare β–Ά
CMP r1 r2
CMN r1 r2
TST r1 r2
TEQ r1 r2
β†· Branch β–Ά
B offset
B EQ offset
B NE offset
B GT offset
B LT offset
BL offset
πŸ”‘ Capability β–Ά
LOAD destCR srcCR idx
SAVE destCR srcDR
CALL cr
RETURN
CHANGE offset
SWITCH cr
TPERM cr mask
Ξ» Templates β–Ά
Y-Combinator (GT)
Factorial (recursive)
Church Booleans
Church Numerals
Pair (CONS/CAR/CDR)
Circle (PI constant)
Omega (non-termination)
Capability Check