Morphium Kernel

A post-silicon material platform for reconfigurable computing.
_{Layer contracts · physics simulators · reproducible, literature-calibrated champion recipes (simulation).}

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. Champions are GA/Monte-Carlo search outputs — not hand-picked — but the underlying physics models are calibrated to published literature (the calibration constants in config/phi.json are literature-anchored). The gatekeeper guarantees reproducibility and threshold-compliance in simulation, not physical correctness. See docs/DATA_PROVENANCE.md.

📋 Start here: docs/STATE_OF_MORPHIUM.md — the capstone synthesis: what's real, what's speculative, the system-level walls, the device verdicts, and what it would take to build the first one. Backed by two adversarial audit rounds (materials, system/device).

The Stack

Layer	Function	Material	Key Metric (simulation, lit-calibrated)
E	Logic / Memory	Hf0.49Zr0.49Al0.02O2	Pr $\approx 17.6$ µC/cm² (FTJ)
EM	Actuation	Sc0.34Al0.66N	Piezo $d_{33} \approx 22$ pC/N
PM	Photonics	Sb2Se3:Ge:Cl	Phase-change $\Delta n \approx 0.75$, low-loss
L	Oxide Logic	IGZO (In-rich)	Mobility $\mu \approx 21$ cm²/V·s
M	Modular / Foglet	HfO2:DLC (composite)	Foglet; mechanical latch (needs E/EM/PM)

Status & data honesty. These are simulation results from literature-calibrated physics models — not lab measurements. "Verified"/"blessed" here means the gatekeeper reproducibly re-derives a champion from the ledger and it passes the contract thresholds — a reproducibility guarantee, not a physical one. Per-layer trust varies (calibrated → literature-grounded → heuristic); see docs/DATA_PROVENANCE.md for the trust level behind every number, and docs/AUDIT_2026-06-03.md for the adversarial audit that corrected several of them.

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

Check Monolithic-Integration Feasibility

Can the five layers be co-fabricated into one stack, and in what order? The descending-thermal-budget model reports the viable fab sequences and the binding constraint (only 2 of 120 orderings survive; PM's ~250 °C ceiling pins it on top).

python3 tools/integration.py

See What Devices the Stack Becomes

Map the same stack onto a watch, phone, and desktop — derived capability and the binding wall for each (watch = battery, phone = thermal+clock, desktop = logic clock). Full write-up in docs/DEVICES.md.

python3 tools/devices.py

Get the Falsifiable Test-Chip Specs

Turn each champion into a single-layer test chip the simulation commits to predicting — recipe, process temp, predicted metrics with ± bands, metrology method, and the falsification criterion. This is the bridge to silicon (step 1 of docs/STATE_OF_MORPHIUM.md).

python3 tools/testchip.py            # all layers
python3 tools/testchip.py --layer E  # one layer

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
│   ├── integration.py      # thermal-budget co-integration / fab-order feasibility
│   ├── devices.py          # per-device (watch/phone/desktop) capability envelopes
│   ├── testchip.py         # single-layer falsifiable test-chip specs (predicted metric + band)
│   └── 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/              # Champion evidence per layer (simulation)
├── 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	Current state-of-the-art per layer (simulation)
Data Provenance	Trust level + source behind every number
Truthfulness Audit	Adversarial audit (2026-06-03) and its corrections
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}
}