Morphium Kernel

A post-silicon material platform for reconfigurable computing.
_{Layer contracts · physics simulators · cryptographically-verified champion recipes.}

Quick Start · The Stack · How It Works · Docs · Cite

---

Overview

Morphium is a unified material platform that replaces the fragmented stack of modern computing (Silicon Logic + DRAM + Flash + PCB + Display + Case) with a single monolithic, reconfigurable substrate. This repository ships the executable artifacts behind that claim: layer contracts, physics simulators, an immutable discovery ledger, and a cryptographic gatekeeper that verifies the champion materials against the kernel.

Every champion in artifacts/GOLDEN_IMAGE.json is reproducible from ledger/recipes.ndjson via tools/gatekeeper.py. Nothing is hand-tuned — if the gatekeeper does not bless it, it is not a champion.

The Stack

Layer	Function	Material	Key Metric
E	Logic / Memory	Hf0.5Zr0.5O2	Non-volatile, W-bit FTJ
EM	Actuation	Sc0.38Al0.62N	Piezo $d_{33} \approx 18$ pC/N
PM	Photonics	Sb2Se3:Ge:Cl	Phase-change FOM $> 1{,}700$
L	Oxide Logic	IGZO	Mobility $\mu > 10$ cm²/V·s
M	Modular / Foglet	HfO2:DLC	Electrostatic latch, 551 mN

See docs/CHAMPIONS.md for the full champion table and papers/MORPHIUM_MASTER_PAPER.md for the full physics write-up.

Quick Start

Requirements

• Python 3.10+
• PyYAML (only runtime dependency)

pip install pyyaml

Verify the Champions

Run the Gatekeeper to cryptographically re-derive GOLDEN_IMAGE.json from the discovery ledger and verify it against the simulation kernel.

python3 tools/gatekeeper.py \
    --ledger ledger/recipes.ndjson \
    --out    artifacts/GOLDEN_IMAGE.json

Run a Search

Use the Loop Adapter to discover optimised compositions for any layer.

python3 tools/loop_kernel_adapter.py --layer L --budget 100

Stress-Test a Champion

python3 tools/stress_test.py --layer EM

Repository Structure

.
├── src/morphium_kernel/   # Core kernel: simulator + per-layer contracts and APIs
│   ├── kernel.py
│   └── layers/{E,EM,PM,L,M}/
├── tools/                 # Discovery loop, gatekeeper, simulators, analysis
│   ├── gatekeeper.py
│   ├── loop_kernel_adapter.py
│   ├── multi_radix_sim.py
│   ├── healing_sim.py
│   ├── sensitivity_analysis.py
│   └── stress_test.py
├── ledger/                # Immutable discovery history (append-only NDJSON)
├── artifacts/             # Blessed state — GOLDEN_IMAGE.json
├── config/                # phi calibration constants
├── papers/                # Master paper, recipes, cost analysis
├── docs/                  # Architecture, risk register, defense, metrology
├── evidence/              # Verified champion evidence per layer
├── hardware/              # Mask sets and latch designs (placeholders)
├── lab/                   # Bench scripts, notebooks, raw data (placeholders)
└── tests/

Documentation

Document	Purpose
Architecture Freeze	Locked design decisions for v1.0
Champions	Verified state-of-the-art per layer
Risk Register	Known risks and mitigations
Fabrication Plan	Path from kernel to silicon
Metrology Plan	Measurement protocols
Final Defense	Argument against red-team objections
Master Paper	Full project write-up

How It Works

┌──────────────────┐     ┌──────────────────┐     ┌─────────────────────┐
│  loop_kernel_    │ ──▶ │   morphium_      │ ──▶ │  ledger/            │
│  adapter.py      │     │   kernel (sim)   │     │  recipes.ndjson     │
│  (GA + MC)       │     │                  │     │  (append-only)      │
└──────────────────┘     └──────────────────┘     └──────────┬──────────┘
                                                             │
                                                             ▼
                                                  ┌─────────────────────┐
                                                  │  gatekeeper.py      │
                                                  │  (canonical hash +  │
                                                  │  threshold check)   │
                                                  └──────────┬──────────┘
                                                             │
                                                             ▼
                                                  ┌─────────────────────┐
                                                  │  artifacts/         │
                                                  │  GOLDEN_IMAGE.json  │
                                                  └─────────────────────┘

1. Search. The Loop Adapter explores composition space with a Genetic Algorithm + Monte Carlo yield analysis.
2. Record. Every trial is appended — never edited — to the NDJSON ledger.
3. Bless. The Gatekeeper canonicalises each top trial, hashes it, checks contract thresholds, and emits the Golden Image.
4. Verify. Anyone can re-run the Gatekeeper and reproduce the same hashes bit-for-bit.

Contributing

Contributions that extend the kernel, add new layer contracts, or improve calibration are welcome.

1. Fork and create a feature branch.
2. Add or modify layer APIs under src/morphium_kernel/layers/<LAYER>/ with an updated contract.yaml.
3. Run the gatekeeper locally and confirm the Golden Image still verifies.
4. Open a PR describing the contract change, the new champion (if any), and the calibration evidence.

Please do not commit edits to ledger/*.ndjson — append only, via the loop adapter.

License

• Code — MIT
• Data (recipes, ledgers, golden image) — CC BY 4.0

Citation

If you reference this work, please cite the master paper:

@misc{morphium_kernel_2026,
  title  = {Morphium Kernel: A Reconfigurable Material Stack},
  author = {Pantelis Christou},
  year   = {2026},
  url    = {https://github.com/Pantelis23/Morphium-Kernel}
}