Release: SpikeWhale slider panel (HF dataset picker, stop/back), DaisyChain-Web (P2P WebRTC training, DaisyAdam, checkpoints, room host approval, verified-units-only)

README.md

@@ -3,22 +3,23 @@ license: mit
 tags:
   - distributed-training
   - old-hardware
-  - cluster
-  - verified-units
-  - pytorch
+  - int8
+  - webgpu
+  - webrtc
 ---
 
-# 🌼 DaisyChain — Old Hardware Training Pipeline
-
-> **Whats available is currently the template. The Main Core Update will be uploaded later on today 7/12**
+# 🌼 DaisyChain-Train — Old Hardware Training Pipeline
 
+**Part of DaisyChain on 🤗 Hugging Face → https://huggingface.co/DaisyChainAI**
+Model page (weights + card): https://huggingface.co/DaisyChainAI/DaisyChain-Train
 
+---
 
-> **In plain terms:** DaisyChain lets you use **old / spare machines** to train
-> neural networks. The training runs through **emulated GPU logic** — verified
-> INT8 units (GUDA-style) that stand in for a GPU's math — so machines *without*
-> a modern GPU can still do the work. Chain several together and they train one
-> shared model as a cluster.
+> **In plain terms:** DaisyChain-Train lets you use **old / spare machines** to
+> train neural networks. The training runs through **emulated GPU logic** —
+> verified INT8 units (GUDA-style) that stand in for a GPU's math — so machines
+> *without* a modern GPU can still do the work. Chain several together and they
+> train one shared model as a cluster.
 > Before you rely on it, see what it **can't** do → [Limitations](docs/LIMITS.md).
 
 **Use the hardware you already have to train.** Each machine runs the emulated
@@ -27,17 +28,12 @@ model, and DaisyChain pools the machines data-parallel: device selection,
 capacity-weighted sharding, gradient sync, a P2P setup, and a live dashboard.
 Two ways to run — **Docker** or **Python**.
 
-> Built by **DaisyChainAI**. Point it at your model + data and it trains across
-> whatever old machines you have, through the emulated GPU logic.
-
-**Repositories:** [GitHub](https://github.com/quzi93/DaisyChain-Train) · [🤗 HuggingFace](https://huggingface.co/DaisyChainAI/DaisyChain-Train)
-
 ---
 
 ## ⚠️ Read this first
-DaisyChain is for **small models on spare hardware**. It **pools compute, not
-memory** (the model must fit on one node), scaling is **sublinear**, and it is
-**not** a substitute for a real GPU on real models. Full envelope in
+DaisyChain-Train is for **small models on spare hardware**. It **pools compute,
+not memory** (the model must fit on one machine), scaling is **sublinear**, and
+it is **not** a substitute for a real GPU on large models. Full envelope in
 **[docs/LIMITS.md](docs/LIMITS.md)** — please read it before relying on it.
 
 ---
@@ -52,7 +48,7 @@ docker compose -f docker/docker-compose.yml up --build
 Brings up a 3-node demo cluster + dashboard on one machine.
 
 ### Python (real machines)
-On every machine (`pip install daisychain` or `pip install -e .`):
+On every machine (`pip install -e .`):
 ```bash
 export MASTER_ADDR=100.101.102.10   # coordinator IP (Tailscale 100.x recommended)
 export MASTER_PORT=29560
@@ -70,6 +66,33 @@ An interactive menu: Docker, Python node, or just install deps.
 
 Full walkthrough: **[docs/QUICKSTART.md](docs/QUICKSTART.md)**.
 
+### 🐋 SpikeWhale control panel (sliders → real training)
+```bash
+python -m daisychain.spikewhale_panel
+# open http://localhost:8899
+```
+A web control panel: pick model size / training settings with sliders, choose any
+HuggingFace dataset you have access to (default: streamed FineWeb-Edu), hit
+Start, and watch the live loss. Stop and re-adjust any time with
+**← Back to settings**. Launches the real DaisyChain training underneath.
+
+### 🌐 DaisyChain-Web (train by opening a browser tab)
+```bash
+cd web && npm install && node server.js
+# open http://localhost:8787 on every device
+```
+Zero-install browser training: devices on the same network auto-group
+(Snapdrop-style) and train a shared model **peer-to-peer over WebRTC**, computing
+through the same verified INT8 units (WebGPU, with the identical units on CPU
+for machines without it — there is no plain-float path). Private cross-network
+rooms via `?room=CODE` with **host approval** — the room creator accepts each
+device before it can join. Includes gradient averaging with a deterministic
+Adam optimizer (identical state on every peer, nothing extra over the wire),
+checkpoint **download** (.pt) and **upload → broadcast** so one device can
+restore the whole group after a failure.
+
+**Live demo:** https://huggingface.co/spaces/DaisyChainAI/DaisyChain-Web
+
 ---
 
 ## How it works
@@ -79,8 +102,8 @@ model. Two things happen:
 
 1. **The compute runs through the emulated GPU logic.** By default the model is
    built from `VerifiedLinear` layers, so every forward multiply / requantize /
-   ReLU is done by the **bundled verified INT8 units** (`daisychain/verified/`)
-   — the emulated GPU math. Rank 0 prints **cluster-wide unit-invocation counts**
+   ReLU is done by the **bundled verified INT8 units** (`daisychain/verified/`) —
+   the emulated GPU math. Rank 0 prints **cluster-wide unit-invocation counts**
    so you can see the emulated logic doing the work.
 2. **The machines are pooled data-parallel.** Each node trains on its own shard;
    gradients are capacity-weighted and combined into the exact full-batch
@@ -94,42 +117,45 @@ model. Two things happen:
 ```
 
 ## Bring your own model
-DaisyChain trains any **Task** (`build_model` / `sample` / `loss`). Copy
+DaisyChain-Train trains any **Task** (`build_model` / `sample` / `loss`). Copy
 `examples/my_task_template.py`, set `DAISY_TASK=your_module:YourTask`. Use
 `VerifiedLinear` (see `daisychain/verified_task.py`) to run your model's compute
 through the emulated units. See **[docs/CUSTOM_TASK.md](docs/CUSTOM_TASK.md)**.
 
 ## Plain-float alternative
-If you'd rather skip the emulated units and just train with normal float math on
-each machine, set `DAISY_TASK=daisychain.example_task:ExampleTask`. Same cluster,
-same pooling — the model math just runs as ordinary float instead of through the
-verified units.
+To skip the emulated units and train with normal float math on each machine, set
+`DAISY_TASK=daisychain.example_task:ExampleTask`. Same cluster, same pooling —
+the model math just runs as ordinary float instead of through the verified units.
 
 ## The dashboard
-`daisychain-dashboard` (or the Docker service) serves a Tailwind page at
-`:8080` — readiness banner, P2P connectivity scan, pooled cores/RAM + capacity
-plan (per-node device, weight, batch), and live training loss.
+`daisychain-dashboard` (or the Docker service) serves a Tailwind page at `:8080`
+— readiness banner, P2P connectivity scan, pooled cores/RAM + capacity plan
+(per-node device, weight, batch), and live training loss.
 
 ## Networking
-Use **Tailscale** for a P2P mesh so machines on different networks get stable
-IPs on one interface — **[docs/TAILSCALE.md](docs/TAILSCALE.md)**.
+Use **Tailscale** for a P2P mesh so machines on different networks get stable IPs
+on one interface — **[docs/TAILSCALE.md](docs/TAILSCALE.md)**.
 
 ---
 
 ## Layout
 ```
 daisychain/cluster.py        capacity-weighted CPU/GPU data-parallel trainer
-daisychain/task.py           the Task interface + loader
 daisychain/train.py          entry point (daisychain-train)
-daisychain/example_task.py   default runnable task (plain float)
 daisychain/verified/         bundled trained N/N units + VerifiedLinear (train through them)
-daisychain/verified_task.py  example task whose forward runs on the verified units
+daisychain/verified_task.py  default task: forward runs on the verified units
+daisychain/example_task.py   plain-float alternative task
+daisychain/task.py           the Task interface + loader
 daisychain/dashboard/        agent + P2P scanner + Tailwind server
 docker/                      Dockerfile, dashboard image, compose (demo cluster)
 scripts/setup.bat / setup.sh interactive setup helpers
 config/                      nodes + cluster env examples
 examples/my_task_template.py starting point for your own model
 docs/                        QUICKSTART, LIMITS, CUSTOM_TASK, TAILSCALE
+daisychain/spikewhale_task.py   trains the real SpikeWhale on streamed HF datasets
+daisychain/spikewhale_panel.py  slider control panel (localhost:8899)
+web/                         DaisyChain-Web: P2P browser training (WebRTC + WebGPU)
+export_luts_web.py           regenerates web/public LUTs from the trained units
 ```
 
 ## Install
@@ -137,19 +163,21 @@ docs/                        QUICKSTART, LIMITS, CUSTOM_TASK, TAILSCALE
 pip install torch numpy psutil
 pip install -e .          # exposes: daisychain-train, daisychain-agent, daisychain-dashboard
 ```
-
 Requires Python ≥ 3.9, PyTorch ≥ 2.0. Multi-node is reliable on **Linux/macOS**;
-on **Windows use Docker/WSL** (see LIMITS).
+on **Windows use Docker/WSL** (see [Limitations](docs/LIMITS.md)).
 
 ---
 
+## Links
+- **DaisyChain on Hugging Face:** https://huggingface.co/DaisyChainAI
+- **This model:** https://huggingface.co/DaisyChainAI/DaisyChain-Train
+
 **License:** MIT · **Author:** Dean Byrne (Quazim0t0) · **Org:** DaisyChainAI
 
 ## Citation
-
 ```bibtex
 @misc{byrne2026daisychain,
-  title        = {DaisyChain: An Old Hardware Training Pipeline},
+  title        = {DaisyChain-Train: An Old Hardware Training Pipeline},
   author       = {Byrne, Dean (Quazim0t0)},
   year         = {2026},
   howpublished = {\url{https://huggingface.co/DaisyChainAI/DaisyChain-Train}},

daisychain/spikewhale_panel.py

@@ -0,0 +1,185 @@
+"""SpikeWhale training control panel (CLI: python -m daisychain.spikewhale_panel).
+
+A web page with sliders for the SpikeWhale config. Pick a size your hardware can
+handle, hit Start, and it launches the real DaisyChain training (SpikeWhale +
+FineWeb-Edu) and streams the live loss. The exact env is shown so you can run the
+same command on other machines to train distributed.
+"""
+import json
+import os
+import subprocess
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+PORT = int(os.environ.get("SW_PANEL_PORT", "8899"))
+_proc = None
+_log = []          # rolling training log
+_lock = threading.Lock()
+
+
+def _pump(proc):
+    for line in iter(proc.stdout.readline, ""):
+        with _lock:
+            _log.append(line.rstrip("\n"))
+            if len(_log) > 400:
+                del _log[:200]
+    proc.stdout.close()
+
+
+def start_training(cfg):
+    global _proc
+    if _proc and _proc.poll() is None:
+        return False, "already running"
+    env = dict(os.environ)
+    env.update({
+        "MASTER_ADDR": "127.0.0.1", "MASTER_PORT": "29610", "WORLD_SIZE": "1",
+        "RANK": "0", "USE_LIBUV": "0", "PYTHONUNBUFFERED": "1",
+        "DAISY_TASK": "daisychain.spikewhale_task:SpikeWhaleTask",
+        "DAISY_SW_HIDDEN": str(cfg["hidden"]), "DAISY_SW_LAYERS": str(cfg["layers"]),
+        "DAISY_SW_HEADS": str(cfg["heads"]), "DAISY_SW_EXPERTS": str(cfg["experts"]),
+        "DAISY_SW_SEQLEN": str(cfg["seqlen"]),
+        "DAISY_STEPS": str(cfg["steps"]), "DAISY_LR": str(cfg["lr"]),
+        "DAISY_OPTIMIZER": "adam", "DAISY_BASE_BATCH": str(cfg["batch"]),
+    })
+    if cfg.get("dataset"):
+        env["DAISY_SW_DATASET"] = cfg["dataset"]
+        # blank subset means the dataset's default config; unset any inherited one
+        if cfg.get("subset"):
+            env["DAISY_SW_SUBSET"] = cfg["subset"]
+        else:
+            env.pop("DAISY_SW_SUBSET", None)
+    with _lock:
+        _log.clear()
+        _log.append(f"launching training: hidden={cfg['hidden']} layers={cfg['layers']} "
+                    f"experts={cfg['experts']} seqlen={cfg['seqlen']} steps={cfg['steps']} "
+                    f"dataset={env.get('DAISY_SW_DATASET', 'HuggingFaceFW/fineweb-edu')}"
+                    + (f":{env['DAISY_SW_SUBSET']}" if env.get("DAISY_SW_SUBSET") else ""))
+    _proc = subprocess.Popen([sys.executable, "-u", "-m", "daisychain.train"],
+                             env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                             text=True, bufsize=1)
+    threading.Thread(target=_pump, args=(_proc,), daemon=True).start()
+    return True, "started"
+
+
+PAGE = """<!doctype html><html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SpikeWhale · DaisyChain trainer</title>
+<style>
+ body{font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;max-width:720px;margin:0 auto;
+      padding:22px;background:#efe4c9;color:#2a1d0a}
+ @media(prefers-color-scheme:dark){body{background:#14100a;color:#ede1c3}}
+ h1{margin:0 0 2px}.sub{color:#6b4423;margin:0 0 16px}
+ @media(prefers-color-scheme:dark){.sub{color:#c9b072}}
+ .card{background:#fbf6e8;border:1px solid rgba(139,111,71,.3);border-radius:10px;padding:16px;margin:12px 0}
+ @media(prefers-color-scheme:dark){.card{background:#1f1a12;border-color:rgba(201,176,114,.35)}}
+ label{display:flex;justify-content:space-between;font-size:.92rem;margin:10px 0 4px;font-weight:600}
+ input[type=range]{width:100%;accent-color:#4a7c2e}
+ input[type=text]{width:100%;padding:8px 10px;border-radius:8px;border:1px solid rgba(139,111,71,.4);
+        background:rgba(255,255,255,.5);color:inherit;font-family:'Courier New',monospace;font-size:.9rem}
+ @media(prefers-color-scheme:dark){input[type=text]{background:rgba(0,0,0,.25);border-color:rgba(201,176,114,.35)}}
+ .val{font-family:'Courier New',monospace;color:#4a7c2e;font-weight:700}
+ @media(prefers-color-scheme:dark){.val{color:#9bc466}}
+ button{background:linear-gradient(135deg,#4a7c2e,#2d5016);color:#f5ecd9;border:0;border-radius:8px;
+        padding:12px 26px;font-weight:800;font-size:1rem;cursor:pointer}
+ .num{font-family:'Courier New',monospace;font-size:2rem;font-weight:700;text-align:center;
+      color:#f5ecd9;background:linear-gradient(135deg,#2d5016,#1f3a0f);border-radius:10px;padding:14px}
+ pre{background:rgba(0,0,0,.06);border-radius:8px;padding:10px;max-height:220px;overflow:auto;
+     font-size:.78rem;white-space:pre-wrap;font-family:'Courier New',monospace}
+ @media(prefers-color-scheme:dark){pre{background:rgba(0,0,0,.3)}}
+ .lbl{font-size:11px;font-weight:800;letter-spacing:1.5px;text-transform:uppercase;color:#6b4423;margin-bottom:8px}
+ @media(prefers-color-scheme:dark){.lbl{color:#c9b072}}
+</style></head><body>
+<h1>🐋 SpikeWhale · DaisyChain</h1>
+<p class="sub">Pick a size your hardware can train, then start. Trains the real SpikeWhale on streamed FineWeb-Edu, distributed by DaisyChain. Smaller = faster on old hardware.</p>
+<div id="settings">
+<div class="card"><div class="lbl">Model size</div>
+ <label>Hidden size <span class="val" id="vhidden">256</span></label><input type="range" id="hidden" min="64" max="768" step="64" value="256">
+ <label>Layers <span class="val" id="vlayers">4</span></label><input type="range" id="layers" min="1" max="12" step="1" value="4">
+ <label>Attention heads <span class="val" id="vheads">4</span></label><input type="range" id="heads" min="1" max="8" step="1" value="4">
+ <label>MoE experts <span class="val" id="vexperts">4</span></label><input type="range" id="experts" min="1" max="8" step="1" value="4">
+ <label>Sequence length <span class="val" id="vseqlen">128</span></label><input type="range" id="seqlen" min="32" max="512" step="32" value="128">
+</div>
+<div class="card"><div class="lbl">Training</div>
+ <label>Learning rate ×1e-4 <span class="val" id="vlr">30</span></label><input type="range" id="lr" min="1" max="100" step="1" value="30">
+ <label>Batch (per step) <span class="val" id="vbatch">4</span></label><input type="range" id="batch" min="1" max="16" step="1" value="4">
+ <label>Steps <span class="val" id="vsteps">200</span></label><input type="range" id="steps" min="20" max="2000" step="20" value="200">
+</div>
+<div class="card"><div class="lbl">Data</div>
+ <label for="dataset">HuggingFace dataset</label>
+ <input type="text" id="dataset" value="HuggingFaceFW/fineweb-edu" spellcheck="false">
+ <label for="subset">Config / subset <span style="font-weight:400">(blank = default)</span></label>
+ <input type="text" id="subset" value="sample-10BT" spellcheck="false">
+ <p class="sub" style="margin:.6rem 0 0;font-size:.82rem">Any streamable text dataset with a <code>text</code> column works. For gated/private datasets, log in first with <code>huggingface-cli login</code> on this machine — the trainer inherits your token.</p>
+</div>
+</div>
+<div class="card" style="text-align:center">
+ <button id="startbtn" onclick="start()">Start training</button>
+ <button id="backbtn" onclick="goBack()" style="display:none;background:linear-gradient(135deg,#6b4423,#4a2f18)">&#8592; Back to settings</button>
+ <p class="sub" style="margin:.6rem 0 0" id="status">idle</p></div>
+<div class="card"><div class="lbl">Live loss</div><div class="num" id="loss">—</div></div>
+<div class="card"><div class="lbl">Log</div><pre id="log"></pre></div>
+<script>
+const ids=["hidden","layers","heads","experts","seqlen","lr","batch","steps"];
+ids.forEach(k=>{const el=document.getElementById(k);const v=document.getElementById("v"+k);
+  el.oninput=()=>v.textContent=el.value;});
+function cfg(){const c={};ids.forEach(k=>c[k]=+document.getElementById(k).value);c.lr=c.lr/1e4;
+  c.dataset=document.getElementById("dataset").value.trim();
+  c.subset=document.getElementById("subset").value.trim();return c;}
+function showSettings(on){document.getElementById("settings").style.display=on?"":"none";
+  document.getElementById("startbtn").style.display=on?"":"none";
+  document.getElementById("backbtn").style.display=on?"none":"";}
+async function start(){document.getElementById("status").textContent="starting…";
+  showSettings(false);
+  await fetch("/start",{method:"POST",body:JSON.stringify(cfg())});}
+async function goBack(){await fetch("/stop",{method:"POST"});
+  showSettings(true);document.getElementById("status").textContent="stopped — adjust and start again";}
+async function poll(){try{const r=await fetch("/log");const d=await r.json();
+  document.getElementById("log").textContent=d.log.slice().reverse().join("\\n");
+  let last="—";for(const l of d.log){const m=l.match(/cluster-avg loss ([0-9.]+)/);if(m)last=m[1];}
+  document.getElementById("loss").textContent=last;
+  if(document.getElementById("backbtn").style.display!=="none")
+    document.getElementById("status").textContent=d.running?"training…":"idle / done";}catch(e){}}
+setInterval(poll,1000);poll();
+</script></body></html>"""
+
+
+class H(BaseHTTPRequestHandler):
+    def _send(self, body, ctype="text/html; charset=utf-8", code=200):
+        b = body.encode() if isinstance(body, str) else body
+        self.send_response(code); self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
+
+    def do_GET(self):
+        if self.path.startswith("/log"):
+            with _lock:
+                running = _proc is not None and _proc.poll() is None
+                self._send(json.dumps({"log": list(_log), "running": running}), "application/json")
+        else:
+            self._send(PAGE)
+
+    def do_POST(self):
+        if self.path.startswith("/start"):
+            n = int(self.headers.get("Content-Length", 0))
+            cfg = json.loads(self.rfile.read(n) or "{}")
+            ok, msg = start_training(cfg)
+            self._send(json.dumps({"ok": ok, "msg": msg}), "application/json")
+        elif self.path.startswith("/stop"):
+            global _proc
+            if _proc and _proc.poll() is None:
+                _proc.terminate()
+                with _lock:
+                    _log.append("training stopped from the panel")
+            self._send(json.dumps({"ok": True}), "application/json")
+
+    def log_message(self, *a):
+        pass
+
+
+def main():
+    print(f"[spikewhale-panel] http://localhost:{PORT}", flush=True)
+    ThreadingHTTPServer(("0.0.0.0", PORT), H).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

daisychain/spikewhale_task.py

@@ -0,0 +1,132 @@
+"""DaisyChain Task that trains the REAL SpikeWhale model on streamed FineWeb-Edu.
+
+No reimplementation: it imports your actual `model_v2.SpikeWhaleLM` + `config.
+SpikeWhaleConfig` + `spike_tokenizer.SpikeTokenizer`, builds a size chosen by the
+sliders (env vars), and streams FineWeb-Edu for data. DaisyChain then distributes
+it across machines; matmuls can be routed through the verified/GUDA units.
+
+Point DaisyChain at it:
+    DAISY_TASK=daisychain.spikewhale_task:SpikeWhaleTask  daisychain-train
+
+Sliders (env):
+  DAISY_SW_PATH     folder holding model_v2.py/config.py/tokenizer.json
+  DAISY_SW_HIDDEN   hidden_size            (default 256)
+  DAISY_SW_LAYERS   num_hidden_layers      (default 4)
+  DAISY_SW_HEADS    num_attention_heads    (default 4)
+  DAISY_SW_EXPERTS  n_routed_experts       (default 4)
+  DAISY_SW_SEQLEN   sequence length        (default 128)
+  DAISY_SW_MTP      MTP heads (0=off)      (default 0)
+  DAISY_SW_DATASET  HF dataset             (default HuggingFaceFW/fineweb-edu)
+  DAISY_SW_SUBSET   dataset config name    (default sample-10BT)
+"""
+import os
+import sys
+
+import torch
+
+_DEF_PATH = os.environ.get("DAISY_SW_PATH", r"C:\Users\quaz\Desktop\Spikewhale")
+
+
+def _import_spikewhale():
+    if _DEF_PATH not in sys.path:
+        sys.path.insert(0, _DEF_PATH)
+    from config import SpikeWhaleConfig
+    from model_v2 import SpikeWhaleLM
+    from spike_tokenizer import SpikeTokenizer
+    return SpikeWhaleConfig, SpikeWhaleLM, SpikeTokenizer
+
+
+def _envi(k, d):
+    return int(os.environ.get(k, d))
+
+
+def build_config():
+    SpikeWhaleConfig, _, _ = _import_spikewhale()
+    hidden = _envi("DAISY_SW_HIDDEN", 256)
+    return SpikeWhaleConfig(
+        hidden_size=hidden,
+        num_hidden_layers=_envi("DAISY_SW_LAYERS", 4),
+        num_attention_heads=_envi("DAISY_SW_HEADS", 4),
+        head_dim=32, qk_rope_head_dim=16,
+        q_lora_rank=max(32, hidden // 4), o_lora_rank=max(32, hidden // 8),
+        num_key_value_heads=1,
+        max_position_embeddings=max(256, _envi("DAISY_SW_SEQLEN", 128)),
+        moe_intermediate_size=hidden,
+        n_routed_experts=_envi("DAISY_SW_EXPERTS", 4), n_shared_experts=1,
+        num_experts_per_tok=min(2, _envi("DAISY_SW_EXPERTS", 4)),
+        num_hash_layers=1, hc_mult=2,
+        num_nextn_predict_layers=_envi("DAISY_SW_MTP", 0),
+        engram_table_size=4096, engram_compress_dim=48, engram_num_heads=2,
+    )
+
+
+class _FineWebStream:
+    """Streams FineWeb-Edu, tokenizes, yields fixed-length token windows."""
+
+    def __init__(self, tokenizer, seqlen, rank=0, world=1):
+        self.tok, self.seqlen = tokenizer, seqlen
+        self.buf = []
+        ds_path = os.environ.get("DAISY_SW_DATASET", "HuggingFaceFW/fineweb-edu")
+        # empty string = "use the dataset's default config" (custom datasets
+        # usually have no named config; the sample-10BT default only fits fineweb-edu)
+        default_subset = "sample-10BT" if ds_path == "HuggingFaceFW/fineweb-edu" else ""
+        subset = os.environ.get("DAISY_SW_SUBSET", default_subset)
+        self.eos = getattr(tokenizer, "eos_token_id", 1) or 1
+        try:
+            from datasets import load_dataset
+            ds = load_dataset(ds_path, name=subset or None, split="train", streaming=True)
+            ds = ds.shard(num_shards=world, index=rank) if world > 1 else ds
+            self.it = iter(ds)
+            self.source = f"{ds_path}:{subset or 'default'}"
+        except Exception as e:
+            print(f"[spikewhale] FineWeb stream unavailable ({e}); using local fallback text", flush=True)
+            self.it = None
+            self.source = "local-fallback"
+
+    def _more_tokens(self):
+        if self.it is not None:
+            row = next(self.it)
+            text = row.get("text", "") or ""
+        else:
+            text = ("Education is the process of learning and acquiring knowledge. "
+                    "Small models can still learn useful patterns from good data. ")
+        ids = self.tok.encode(text, add_special_tokens=False)
+        self.buf.extend(ids + [self.eos])
+
+    def next_window(self):
+        while len(self.buf) < self.seqlen + 1:
+            self._more_tokens()
+        w = self.buf[: self.seqlen + 1]
+        self.buf = self.buf[self.seqlen:]
+        return w
+
+
+class SpikeWhaleTask:
+    def __init__(self):
+        SpikeWhaleConfig, SpikeWhaleLM, SpikeTokenizer = _import_spikewhale()
+        self.cfg = build_config()
+        tok_file = os.path.join(_DEF_PATH, "tokenizer.json")
+        self.tok = SpikeTokenizer(vocab_file=tok_file)
+        self.seqlen = _envi("DAISY_SW_SEQLEN", 128)
+        rank = _envi("RANK", 0); world = _envi("WORLD_SIZE", 1)
+        self.stream = _FineWebStream(self.tok, self.seqlen, rank, world)
+        self._SpikeWhaleLM = SpikeWhaleLM
+        n = None
+        print(f"[spikewhale] data source: {self.stream.source}", flush=True)
+
+    def build_model(self):
+        torch.manual_seed(0)                       # identical init on every node
+        m = self._SpikeWhaleLM(self.cfg)
+        n = sum(p.numel() for p in m.parameters())
+        print(f"[spikewhale] model built: {n:,} params "
+              f"(hidden={self.cfg.hidden_size}, layers={self.cfg.num_hidden_layers}, "
+              f"experts={self.cfg.n_routed_experts}, seqlen={self.seqlen})", flush=True)
+        return m
+
+    def sample(self, n):
+        rows = [self.stream.next_window()[:self.seqlen] for _ in range(n)]
+        t = torch.tensor(rows, dtype=torch.long)   # (n, seqlen)
+        return t, t                                # labels == input_ids; model shifts internally
+
+    def loss(self, model, X, y):
+        return model(input_ids=X, labels=y).loss

export_luts_web.py

@@ -0,0 +1,44 @@
+"""Export the bundled verified units to lookup tables for the browser
+(DaisyChain-Web). These are the emulated GPU logic, materialized: the browser
+computes through THESE, not plain float.
+
+Writes three little binaries into daisychain-web/public/:
+  mul_lut.bin      int16[65536]  signed 8x8 product,  indexed [au*256 + bu]
+  requant_lut.bin  int8 [65536]  int16->int8 requant, indexed [acc & 0xFFFF]
+  relu_lut.bin     int8 [256]    int8 ReLU,           indexed [byte]
+  luts_meta.json   dims + requant shift (for dequant)
+"""
+import json
+import os
+import numpy as np
+
+from daisychain.verified.qat import load_units
+from daisychain.verified.lut import build_mul8_lut, build_requant16_lut, build_relu8_lut
+
+OUT = os.path.join(os.path.dirname(__file__), "..", "daisychain-web", "public")
+
+
+def main():
+    mul, rq, relu = load_units()
+    mul_lut = build_mul8_lut(mul).astype(np.int16)          # (256,256) -> flat 65536
+    req_lut = build_requant16_lut(rq).astype(np.int8)       # 65536
+    relu_lut = build_relu8_lut(relu).astype(np.int8)        # 256
+
+    os.makedirs(OUT, exist_ok=True)
+    mul_lut.reshape(-1).tofile(os.path.join(OUT, "mul_lut.bin"))
+    req_lut.tofile(os.path.join(OUT, "requant_lut.bin"))
+    relu_lut.tofile(os.path.join(OUT, "relu_lut.bin"))
+    meta = {"mul": [256, 256], "requant": 65536, "relu": 256, "shift": rq.shift}
+    with open(os.path.join(OUT, "luts_meta.json"), "w") as f:
+        json.dump(meta, f)
+
+    # sanity: LUT must equal the true signed product (verified units are exact)
+    a, b = 37, -19
+    au, bu = a & 0xFF, b & 0xFF
+    assert int(mul_lut[au, bu]) == a * b, "mul LUT mismatch"
+    print("exported mul_lut(int16 65536), requant_lut(int8 65536), relu_lut(int8 256)")
+    print("shift =", rq.shift, "| sanity 37*-19 =", int(mul_lut[au, bu]))
+
+
+if __name__ == "__main__":
+    main()

web/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+*.log
+.DS_Store

web/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dean Byrne (Quazim0t0) / DaisyChainAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/README.md

@@ -0,0 +1,92 @@
+# 🌼 DaisyChain-Web — train by opening a page
+
+Part of **DaisyChain** → https://huggingface.co/DaisyChainAI
+
+Open a link on two or more devices and they **train a shared model together,
+peer-to-peer, right in the browser** — no install, no accounts. Devices connect
+over **WebRTC** (like Snapdrop); each one computes **through the verified INT8
+units** — the same emulated GPU logic as the rest of DaisyChain, run as a
+**WebGPU** lookup-table matmul (with a CPU fallback for old machines) — and they
+average gradients directly between peers.
+
+> This is the browser-native version of DaisyChain: instead of setting up nodes,
+> people join a training run by opening a URL.
+
+## Run it
+
+```bash
+npm install
+npm start           # serves on http://localhost:8787
+```
+
+Open `http://localhost:8787` in two tabs (or two devices — see HTTPS note). They
+find each other, connect P2P, and you click **Start training** on each. Watch the
+shared loss fall on both.
+
+Quick self-check of the training math (no browser):
+```bash
+npm test            # 2-peer gradient averaging: converges, replicas bit-identical
+```
+
+## How it works
+
+| Piece | Role |
+|-------|------|
+| `server.js` | tiny **WebSocket signaling** server (introduces peers, relays WebRTC offers/ICE) + static host. It never sees the compute. |
+| WebRTC data channels | **P2P** gradient exchange between browsers (STUN for NAT). |
+| `public/verified_core.js` | the **verified INT8 units** in the browser — quantize → LUT multiply → dequant, STE backward. The emulated GPU logic doing the training compute. |
+| `public/webgpu.js` | runs the verified multiply as a **WebGPU** LUT-matmul compute shader, with an automatic **CPU/JS fallback**. |
+| `public/*.bin` | the units as lookup tables (`mul_lut`, `requant_lut`, `relu_lut`), exported from the trained weights by `daisychain/export_luts_web.py`. |
+| `public/app.js` | the WebRTC mesh + the training loop + gradient averaging. |
+
+Each peer starts from the **same** deterministically-seeded weights (no weight
+broadcast needed), trains on its own data shard **through the verified units**,
+and every step broadcasts its gradient and averages everyone's — so all peers
+converge to the **same** model.
+
+## What's verified
+- **Through the units** (`node test_verified.js`): 2 peers training through the
+  verified INT8 multiply converge and stay **bit-identical** (0.0 param diff).
+- **Signaling** (`node -e ...`): peer discovery + relay works.
+- **End-to-end in-browser**: two tabs connected over **real WebRTC**, both on
+  **WebGPU running the verified INT8 units**, trained a shared model together —
+  loss fell steadily, peers in sync. (`node test_core.js` also checks the plain
+  float loop.)
+
+## Regenerate the unit LUTs
+The `.bin` tables are exported from the trained DaisyChain units:
+```bash
+cd ../daisychain && python export_luts_web.py     # writes mul/requant/relu LUTs into ../daisychain-web/public
+```
+
+## Who connects to whom (Snapdrop-style)
+
+Peers are grouped by their **public IP**, so **only devices on the same network
+auto-connect** — open the page on your phone and laptop at home and they find
+each other, but a stranger viewing the same URL from another network does **not**
+join your group. To connect across networks with people you invite, everyone
+opens `?room=YOUR-CODE` (a shared private room). The server only relays WebRTC
+handshakes; it never sees the training.
+
+**Safety note:** WebRTC peers connect directly, so devices in your group can see
+each other's IP address, and there's no gradient authentication — a malicious
+peer could poison the shared model. Train only with devices/people you trust.
+This is a proof of concept, not a hardened public service.
+
+## Honest limits
+- **Secure context required.** WebGPU and cross-device WebRTC need **localhost or
+  HTTPS**. For real multi-device use, serve over HTTPS (a tunnel, a host, or a HF
+  Space) — plain `http://192.168.x.x` won't get WebGPU.
+- **No WebGPU? It falls back to CPU** — slower, but old machines (e.g. Windows XP/7
+  via **Supermium**, old Macs via a compatibility browser) can still join at the
+  CPU tier. WebGPU itself needs a GPU/driver with a modern backend, which very old
+  hardware usually lacks.
+- **Synchronous barrier**: the slowest peer paces each step. Peer-dropout handling
+  is minimal (a timeout, then it proceeds) — this is a proof of concept, not
+  hardened.
+- **Small models only** — WebRTC bandwidth and browser compute cap the size. Same
+  envelope as the rest of DaisyChain: pools compute, not memory.
+
+---
+
+**License:** MIT · **Author:** Dean Byrne (Quazim0t0) · **Org:** DaisyChainAI

web/package-lock.json

@@ -0,0 +1,37 @@
+{
+  "name": "daisychain-web",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "daisychain-web",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "ws": "^8.21.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

web/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "daisychain-web",
+  "version": "0.1.0",
+  "description": "Train a shared model P2P in the browser — WebRTC mesh + WebGPU compute. Open a page, become a node.",
+  "license": "MIT",
+  "author": "Dean Byrne (Quazim0t0) / DaisyChainAI",
+  "scripts": {
+    "start": "node server.js",
+    "test": "node test_core.js"
+  },
+  "dependencies": {
+    "ws": "^8.21.0"
+  }
+}

web/public/app.js

@@ -0,0 +1,334 @@
+// DaisyChain-Web client: connect P2P (WebRTC), compute (WebGPU or CPU), and
+// train a shared model together — averaging gradients over the data channels.
+"use strict";
+
+const DIN = 16, H = 16, DOUT = 4, NPER = 128, LR = 0.03, DEFAULT_STEPS = 300;
+const D = { n: NPER, din: DIN, h: H, dout: DOUT };
+const STUN = [{ urls: "stun:stun.l.google.com:19302" }];
+
+const ui = {
+  status: document.getElementById("status"),
+  backend: document.getElementById("backend"),
+  me: document.getElementById("me"),
+  peers: document.getElementById("peers"),
+  loss: document.getElementById("loss"),
+  step: document.getElementById("step"),
+  bar: document.getElementById("bar"),
+  diff: document.getElementById("diff"),
+  log: document.getElementById("log"),
+  start: document.getElementById("start"),
+  save: document.getElementById("save"),
+  load: document.getElementById("load"),
+  loadBtn: document.getElementById("loadBtn"),
+  requests: document.getElementById("requests"),
+};
+function log(m) { ui.log.textContent = `${new Date().toLocaleTimeString()}  ${m}\n` + ui.log.textContent; }
+function setStatus(s) { ui.status.textContent = s; }
+
+// ---- deterministic RNG so every peer agrees on W_true and W0 (no broadcast) --
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+
+// ---- state -----------------------------------------------------------------
+// friendly device name (cottagecore, Snapdrop-style)
+const ADJ = ["Mossy", "Golden", "Amber", "Fern", "Hazel", "Cozy", "Wandering", "Little",
+             "Sunny", "Misty", "Wild", "Quiet", "Brave", "Dusty", "Merry"];
+const NOUN = ["Fox", "Hare", "Owl", "Badger", "Toad", "Sparrow", "Otter", "Deer",
+              "Hedgehog", "Mushroom", "Acorn", "Willow", "Robin", "Fawn", "Moth"];
+const deviceName = ADJ[Math.floor(Math.random() * ADJ.length)] + " " +
+                   NOUN[Math.floor(Math.random() * NOUN.length)];
+
+let myId = null, compute = null, ws = null, L = null, wasDenied = false;
+const pcs = new Map(), chans = new Map();      // peerId -> RTCPeerConnection / DataChannel
+const names = new Map();                       // peerId -> device name
+const incoming = new Map();                    // step -> Map(peerId -> Float32Array)
+let W1, W2, Xdata, Ydata, training = false;    // 2-layer verified model
+let trainedSteps = 0;                          // steps baked into the current weights
+function nmeOf(id) { return names.get(id) || id; }
+
+function room() { return new URLSearchParams(location.search).get("room"); }   // null -> group by network
+function updatePeers() { ui.peers.textContent = chans.size ? [...chans.keys()].map(nmeOf).join(", ") : "(none yet)"; }
+
+// ---- signaling + WebRTC ----------------------------------------------------
+function connectSignaling() {
+  const proto = location.protocol === "https:" ? "wss" : "ws";
+  const params = new URLSearchParams();
+  params.set("name", deviceName);
+  if (room()) params.set("room", room());                             // no code -> group by network
+  ws = new WebSocket(`${proto}://${location.host}/?${params}`);
+  ws.onopen = () => setStatus(room() ? `connected — private room "${room()}"` : "connected — grouping with devices on your network");
+  ws.onclose = () => { if (!wasDenied) setStatus("signaling disconnected"); };
+  ws.onmessage = async (ev) => {
+    const msg = JSON.parse(ev.data);
+    if (msg.type === "welcome") {
+      myId = msg.id;
+      if (msg.room) log(`group: ${msg.room.startsWith("net:") ? "your network" : "private room " + msg.room.replace("room:", "")}`);
+      if (msg.host) { log("you host this room — joiners wait for your approval"); setStatus(`hosting private room "${room()}"`); }
+      else if (room()) setStatus(`accepted into private room "${room()}"`);
+      // I'm newest: initiate to everyone already here
+      for (const p of msg.peers) { names.set(p.id, p.name); initiatePeer(p.id); }
+    } else if (msg.type === "waiting") {
+      setStatus("knocking — waiting for the room's host to let you in…");
+    } else if (msg.type === "denied") {
+      wasDenied = true;
+      setStatus("the host declined your request to join");
+      log("join request declined by the host");
+    } else if (msg.type === "host") {
+      log("the host left — you are now the host of this room");
+      setStatus(`hosting private room "${room()}"`);
+    } else if (msg.type === "join-request") {
+      addJoinRequest(msg.id, msg.name);
+    } else if (msg.type === "peer-joined") {
+      names.set(msg.id, msg.name);
+      log(`${msg.name} joined (they will connect to me)`);
+    } else if (msg.type === "peer-left") {
+      log(`${nmeOf(msg.id)} left`); cleanupPeer(msg.id); names.delete(msg.id); updatePeers();
+    } else if (msg.type === "signal") {
+      await onSignal(msg.from, msg.data);
+    }
+  };
+}
+function signal(to, data) { ws.send(JSON.stringify({ type: "signal", to, data })); }
+
+// host-side Accept/Deny row for a knocking device (textContent only — the name
+// comes off the wire and must never be parsed as HTML)
+function addJoinRequest(id, name) {
+  const row = document.createElement("div");
+  row.style.cssText = "display:flex;gap:8px;align-items:center;justify-content:space-between;margin-top:10px;flex-wrap:wrap";
+  const who = document.createElement("span");
+  who.textContent = `🚪 ${name} wants to join`;
+  const btn = (label, allow) => {
+    const b = document.createElement("button");
+    b.textContent = label;
+    b.style.cssText = "padding:6px 14px;font-size:.85rem" + (allow ? "" : ";background:#8b2e25");
+    b.onclick = () => {
+      ws.send(JSON.stringify({ type: "admit", id, allow }));
+      row.remove();
+      log(allow ? `you let ${name} in` : `you declined ${name}`);
+    };
+    return b;
+  };
+  row.append(who, btn("Accept", true), btn("Deny", false));
+  ui.requests.appendChild(row);
+}
+
+function newPC(peerId) {
+  const pc = new RTCPeerConnection({ iceServers: STUN });
+  pc.onicecandidate = (e) => { if (e.candidate) signal(peerId, { candidate: e.candidate }); };
+  pc.onconnectionstatechange = () => { if (pc.connectionState === "failed") cleanupPeer(peerId); };
+  pcs.set(peerId, pc);
+  return pc;
+}
+function initiatePeer(peerId) {
+  const pc = newPC(peerId);
+  const dc = pc.createDataChannel("daisy");
+  setupChannel(peerId, dc);
+  pc.createOffer().then(o => pc.setLocalDescription(o)).then(() => signal(peerId, { sdp: pc.localDescription }));
+}
+async function onSignal(from, data) {
+  let pc = pcs.get(from);
+  if (data.sdp) {
+    if (!pc) { pc = newPC(from); pc.ondatachannel = (e) => setupChannel(from, e.channel); }
+    await pc.setRemoteDescription(data.sdp);
+    if (data.sdp.type === "offer") {
+      const ans = await pc.createAnswer(); await pc.setLocalDescription(ans);
+      signal(from, { sdp: pc.localDescription });
+    }
+  } else if (data.candidate && pc) {
+    try { await pc.addIceCandidate(data.candidate); } catch (e) {}
+  }
+}
+function setupChannel(peerId, dc) {
+  dc.binaryType = "arraybuffer";
+  dc.onopen = () => { chans.set(peerId, dc); updatePeers(); log(`connected to ${nmeOf(peerId)}`); ui.start.disabled = false; };
+  dc.onclose = () => { chans.delete(peerId); updatePeers(); wake(); };
+  dc.onmessage = (e) => onGrad(peerId, e.data);
+}
+function cleanupPeer(id) { const pc = pcs.get(id); if (pc) pc.close(); pcs.delete(id); chans.delete(id); wake(); }
+
+// ---- checkpoints ------------------------------------------------------------
+// File layout (also the broadcast payload after the sentinel):
+//   8 bytes magic "DAISYPT1" | int32 din,h,dout,steps | f32 W1 | f32 W2
+// DaisyChain's own format (not torch-pickle) — .pt extension for familiarity.
+const CKPT_MAGIC = "DAISYPT1";
+const CKPT_SENTINEL = -2;                      // wire: [int32 -2][checkpoint bytes]
+
+function packCheckpoint() {
+  const buf = new ArrayBuffer(8 + 16 + (W1.length + W2.length) * 4);
+  new Uint8Array(buf, 0, 8).set([...CKPT_MAGIC].map(c => c.charCodeAt(0)));
+  new Int32Array(buf, 8, 4).set([DIN, H, DOUT, trainedSteps]);
+  new Float32Array(buf, 24, W1.length).set(W1);
+  new Float32Array(buf, 24 + W1.length * 4, W2.length).set(W2);
+  return buf;
+}
+function parseCheckpoint(buf) {
+  const magic = String.fromCharCode(...new Uint8Array(buf, 0, 8));
+  if (magic !== CKPT_MAGIC) throw new Error("not a DaisyChain checkpoint");
+  const [din, h, dout, steps] = new Int32Array(buf, 8, 4);
+  if (din !== DIN || h !== H || dout !== DOUT)
+    throw new Error(`shape mismatch: file is ${din}×${h}×${dout}, this build is ${DIN}×${H}×${DOUT}`);
+  if (buf.byteLength !== 24 + (din * h + h * dout) * 4) throw new Error("truncated checkpoint");
+  return { steps, w1: new Float32Array(buf.slice(24, 24 + din * h * 4)),
+           w2: new Float32Array(buf.slice(24 + din * h * 4)) };
+}
+function applyCheckpoint(ck, from) {
+  W1.set(ck.w1); W2.set(ck.w2); trainedSteps = ck.steps;
+  ui.save.disabled = false;
+  ui.step.textContent = `${ck.steps} baked in`;
+  log(`checkpoint loaded (${ck.steps} steps) ${from ? "from " + from : "from file"} — all set to resume`);
+}
+function broadcastCheckpoint() {
+  const ck = packCheckpoint();
+  const msg = new ArrayBuffer(4 + ck.byteLength);
+  new Int32Array(msg, 0, 1)[0] = CKPT_SENTINEL;
+  new Uint8Array(msg, 4).set(new Uint8Array(ck));
+  let n = 0;
+  for (const dc of chans.values()) if (dc.readyState === "open") { dc.send(msg); n++; }
+  log(`checkpoint pushed to ${n} device(s)`);
+}
+function saveCheckpoint() {
+  const blob = new Blob([packCheckpoint()], { type: "application/octet-stream" });
+  const a = document.createElement("a");
+  a.href = URL.createObjectURL(blob);
+  a.download = `daisychain-${DIN}x${H}x${DOUT}-step${trainedSteps}.pt`;
+  a.click();
+  URL.revokeObjectURL(a.href);
+}
+
+// ---- gradient wire format:  [int32 step][float32 grad...] -----------------
+function packGrad(step, grad) {
+  const buf = new ArrayBuffer(4 + grad.byteLength);
+  new Int32Array(buf, 0, 1)[0] = step;
+  new Float32Array(buf, 4).set(grad);
+  return buf;
+}
+const waiters = new Set();                       // pending waitForGrads checkers
+function wake() { for (const w of waiters) w(); }
+function onGrad(peerId, buf) {
+  const step = new Int32Array(buf, 0, 1)[0];
+  if (step === CKPT_SENTINEL) {                  // a peer pushed a checkpoint
+    if (training) { log(`ignored checkpoint from ${nmeOf(peerId)} (training in progress)`); return; }
+    try { applyCheckpoint(parseCheckpoint(buf.slice(4)), nmeOf(peerId)); }
+    catch (e) { log(`bad checkpoint from ${nmeOf(peerId)}: ${e.message}`); }
+    return;
+  }
+  const grad = new Float32Array(buf.slice(4));
+  if (!incoming.has(step)) incoming.set(step, new Map());
+  incoming.get(step).set(peerId, grad);
+  wake();                                        // resolve waits immediately (no polling)
+}
+function broadcastGrad(step, grad) { const b = packGrad(step, grad); for (const dc of chans.values()) if (dc.readyState === "open") dc.send(b); }
+// Event-driven: re-checked on every gradient arrival and peer departure, plus a
+// coarse fallback timer (background tabs throttle timers to ~1s, so the old
+// 15ms poll was the bottleneck there). Peers that left are dropped from the
+// wait — a device dying no longer costs the full timeout every step.
+function waitForGrads(step, cohort, timeoutMs = 8000) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    let timer = null;
+    const check = () => {
+      const live = cohort.filter(id => chans.has(id));   // prune departed peers
+      const got = incoming.get(step) || new Map();
+      const have = live.filter(id => got.has(id));
+      if (have.length === live.length || Date.now() - t0 > timeoutMs) {
+        waiters.delete(check); clearInterval(timer);
+        resolve(have.map(id => got.get(id)));
+      }
+    };
+    waiters.add(check);
+    timer = setInterval(check, 500);                     // safety net only
+    check();
+  });
+}
+
+// ---- compute: one async training step THROUGH the verified units -----------
+async function localStep() {
+  // forward runs through the verified INT8 multiply (WebGPU or CPU); STE backward
+  const fwd = await Verified.forward(Xdata, Ydata, W1, W2, D, L, compute.matmulInt8);
+  const grad = Verified.backward(Xdata, W1, W2, fwd, D);          // flat [gW1, gW2]
+  return { loss: fwd.loss, grad };
+}
+
+// ---- the training loop -----------------------------------------------------
+async function train() {
+  if (training) return; training = true; ui.start.disabled = true;
+  const cohort = [...chans.keys()];                    // lock the cohort (departed peers are pruned per-step)
+  const steps = DEFAULT_STEPS;
+  const opt = TrainCore.makeAdam(W1.length + W2.length, { lr: 0.2 });   // swept: best on the verified-unit STE grads
+  log(`training started — cohort ${cohort.length} peer(s), world ${cohort.length + 1}, optimizer ${opt.name}`);
+  for (let s = 0; s < steps; s++) {
+    const { loss, grad } = await localStep();
+    broadcastGrad(s, grad);
+    const remote = cohort.length ? await waitForGrads(s, cohort) : [];
+    const all = [grad, ...remote];
+    const avg = TrainCore.averageGrads(all);
+    const upd = opt.step(avg);                      // DaisyAdam on the cluster-avg grad
+    Verified.splitApply(W1, W2, upd, 1);            // W -= 1 * upd (lr folded into upd)
+    incoming.delete(s);
+    trainedSteps++;
+    if (s % 10 === 0 || s === steps - 1) {
+      ui.loss.textContent = loss.toFixed(5);
+      ui.step.textContent = `${s + 1} / ${steps}`;
+      ui.bar.style.width = `${Math.round(100 * (s + 1) / steps)}%`;
+      await new Promise(r => setTimeout(r, 0));         // yield to UI
+    }
+  }
+  ui.diff.textContent = `done — trained through the verified units; all peers share one model.`;
+  log(`training done — final loss ${ui.loss.textContent}`);
+  training = false;
+  ui.save.disabled = false;
+  ui.start.disabled = false;
+}
+
+// 2-layer float target (matches the model shape) for a learnable task
+function target(X) {
+  const Wt1 = randn(DIN * H, mulberry32(42)), Wt2 = randn(H * DOUT, mulberry32(43));
+  const hpre = TrainCore.matmul(X, Wt1, NPER, DIN, H);
+  for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]);
+  return TrainCore.matmul(hpre, Wt2, NPER, H, DOUT);
+}
+
+// ---- boot ------------------------------------------------------------------
+(async function () {
+  // Neural Units are mandatory: no LUTs -> no training, period. There is no
+  // float fallback path anywhere in this app; both backends (WebGPU shader and
+  // CPU JS) compute every product through the verified mul8 LUT.
+  try {
+    L = await Compute.loadLUTs();                        // the verified units, as tables
+    if (!(L.mul instanceof Int16Array) || L.mul.length !== 65536)
+      throw new Error("mul8 LUT malformed");
+    // self-test: the unit must reproduce a known product before we trust it
+    if (L.mul[((7 & 0xFF) * 256) + (-3 & 0xFF)] !== -21)
+      throw new Error("mul8 LUT self-test failed (7 × -3 ≠ -21)");
+    compute = await Compute.initCompute(L);
+  } catch (e) {
+    setStatus("NEURAL UNITS UNAVAILABLE — training disabled");
+    ui.backend.textContent = "unavailable";
+    log(`FATAL: verified neural units failed to load (${e.message}). ` +
+        `This build only trains through the units — there is no fallback.`);
+    ui.start.disabled = true;
+    return;                                              // no signaling, no training
+  }
+  ui.backend.textContent = `${compute.backend.toUpperCase()} — ${compute.label} · through verified INT8 units`;
+  // deterministic shared init (no weight broadcast); per-peer random data shard
+  W1 = randn(DIN * H, mulberry32(7));
+  W2 = randn(H * DOUT, mulberry32(8));
+  Xdata = randn(NPER * DIN);
+  Ydata = target(Xdata);
+  ui.me.textContent = deviceName;
+  updatePeers();
+  connectSignaling();
+  ui.start.onclick = train;
+  ui.save.onclick = saveCheckpoint;
+  ui.loadBtn.onclick = () => { if (training) { log("can't load a checkpoint mid-training"); return; } ui.load.click(); };
+  ui.load.onchange = async () => {
+    const f = ui.load.files[0]; ui.load.value = "";
+    if (!f) return;
+    try {
+      const ck = parseCheckpoint(await f.arrayBuffer());
+      applyCheckpoint(ck, null);
+      broadcastCheckpoint();                             // every device resumes from this
+    } catch (e) { log(`checkpoint rejected: ${e.message}`); }
+  };
+  log(`ready — this device is "${deviceName}", computing through verified units on ${compute.backend.toUpperCase()}`);
+})();

web/public/index.html

@@ -0,0 +1,123 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DaisyChain-Web — train by opening a page</title>
+<style>
+  :root {
+    --page-bg: #efe4c9;
+    --card-bg: #fbf6e8;
+    --card-border: rgba(139, 111, 71, 0.30);
+    --text: #2a1d0a;
+    --text-soft: #6b4423;
+    --accent: #4a7c2e;
+    --accent-deep: #2d5016;
+    --counter-bg: linear-gradient(135deg, #2d5016 0%, #1f3a0f 100%);
+    --counter-num: #f5ecd9;
+    --counter-label: #c9b072;
+    --btn: linear-gradient(135deg, #4a7c2e 0%, #2d5016 100%);
+    --btn-hover: linear-gradient(135deg, #5a8c3e 0%, #3d6020 100%);
+    --warn: #8b2e25;
+    --link: #4a7c2e;
+    --track: rgba(139, 111, 71, 0.22);
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --page-bg: #14100a; --card-bg: #1f1a12; --card-border: rgba(201, 176, 114, 0.35);
+      --text: #ede1c3; --text-soft: #c9b072; --accent: #9bc466; --accent-deep: #6b9039;
+      --counter-bg: linear-gradient(135deg, #1a2e0d 0%, #0c1606 100%);
+      --counter-label: #c9b072; --warn: #ff9b8e; --link: #9bc466; --track: rgba(201,176,114,0.20);
+    }
+  }
+  * { box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+         max-width: 720px; margin: 0 auto; padding: 24px 18px 40px; line-height: 1.5;
+         background: var(--page-bg); color: var(--text); }
+  h1 { margin: 0 0 2px; font-size: 1.7rem; letter-spacing: .3px; }
+  .sub { color: var(--text-soft); margin: 0 0 18px; font-size: .92rem; }
+  .sub code { background: rgba(74,124,46,.12); padding: 1px 5px; border-radius: 4px; }
+  .card { background: var(--card-bg); border: 1px solid var(--card-border);
+          border-radius: 10px; padding: 14px 16px; margin: 12px 0;
+          box-shadow: 0 2px 10px rgba(0,0,0,0.06); }
+  .lbl { color: var(--text-soft); font-size: 11px; font-weight: 800; letter-spacing: 1.5px;
+         text-transform: uppercase; margin-bottom: 8px; }
+  .row { display: flex; justify-content: space-between; gap: 12px; padding: 3px 0; font-size: .95rem; }
+  .k { color: var(--text-soft); } .v { font-weight: 700; text-align: right; }
+  .device { font-family: 'Courier New', monospace; font-size: 1.5rem; font-weight: 700;
+            color: var(--accent-deep); }
+  @media (prefers-color-scheme: dark) { .device { color: var(--accent); } }
+  .counter { background: var(--counter-bg); border-radius: 10px; padding: 14px 16px; text-align: center; }
+  .counter .num { font-family: 'Courier New', monospace; font-size: 2.2rem; font-weight: 700; color: var(--counter-num); }
+  .counter .cl { color: var(--counter-label); font-size: 11px; text-transform: uppercase; letter-spacing: 1.5px; }
+  .track { width: 100%; height: 10px; border-radius: 6px; background: var(--track); overflow: hidden; margin-top: 12px; }
+  #bar { height: 10px; width: 0; background: linear-gradient(90deg, #6b9039, #9bc466); transition: width .25s; }
+  button { background: var(--btn); color: #f5ecd9; border: 0; border-radius: 8px;
+           padding: 12px 26px; font-weight: 800; font-size: 1rem; letter-spacing: .5px; cursor: pointer;
+           box-shadow: 0 3px 10px rgba(74,49,16,0.18); transition: .15s; }
+  button:hover:not(:disabled) { background: var(--btn-hover); box-shadow: 0 5px 14px rgba(74,49,16,0.28); }
+  button:disabled { background: #8b7d5e; opacity: .55; cursor: not-allowed; box-shadow: none; }
+  pre { background: rgba(0,0,0,0.05); border-radius: 8px; padding: 10px; max-height: 150px;
+        overflow: auto; font-size: .78rem; color: var(--text-soft); white-space: pre-wrap; margin: 0;
+        font-family: 'Courier New', monospace; }
+  @media (prefers-color-scheme: dark) { pre { background: rgba(0,0,0,0.25); } }
+  .note { color: var(--text-soft); font-size: .82rem; }
+  .note b { color: var(--warn); }
+  .diff { color: var(--accent-deep); font-weight: 600; font-size: .88rem; }
+  @media (prefers-color-scheme: dark) { .diff { color: var(--accent); } }
+</style>
+</head>
+<body>
+  <h1>🌼 DaisyChain-Web</h1>
+  <p class="sub">Open this on your other devices <b>on the same network</b> and they train a shared model together — peer-to-peer, right in the browser, through the emulated GPU logic. Only devices on your network are grouped (like Snapdrop). To invite people across networks, everyone opens <code>?room=YOUR-CODE</code> — the person who created the room approves each device before it can join.</p>
+
+  <div class="card">
+    <div class="lbl">🌲 This device</div>
+    <div class="device" id="me">—</div>
+    <div class="row" style="margin-top:8px"><span class="k">Status</span><span class="v" id="status">starting…</span></div>
+    <div class="row"><span class="k">Compute</span><span class="v" id="backend">detecting…</span></div>
+  </div>
+
+  <div class="card">
+    <div class="lbl">🍄 Devices in your group</div>
+    <div class="row"><span class="v" id="peers" style="text-align:left">(none yet)</span></div>
+    <div id="requests"></div>
+  </div>
+
+  <div class="card" style="text-align:center">
+    <button id="start" disabled>Start training</button>
+    <p class="note" style="margin:.6rem 0 0">Enabled once another device joins. (Or open a second tab to try it.)</p>
+  </div>
+
+  <div class="card">
+    <div class="lbl">✦ Training</div>
+    <div class="row"><span class="k">Step</span><span class="v" id="step">— / —</span></div>
+    <div class="counter" style="margin:10px 0"><div class="num" id="loss">—</div><div class="cl">cluster-avg loss · lower is better</div></div>
+    <div class="track"><div id="bar"></div></div>
+    <div class="row" style="margin-top:10px"><span class="diff" id="diff"></span></div>
+  </div>
+
+  <div class="card">
+    <div class="lbl">💾 Model checkpoint</div>
+    <div style="display:flex;gap:10px;flex-wrap:wrap;justify-content:center">
+      <button id="save" disabled>Download model (.pt)</button>
+      <button id="loadBtn">Load checkpoint…</button>
+      <input type="file" id="load" accept=".pt" style="display:none">
+    </div>
+    <p class="note" style="margin:.6rem 0 0;text-align:center">Loading a checkpoint applies it here <b>and</b> pushes it to every connected device — use it to recover the group after a failure.</p>
+  </div>
+
+  <div class="card">
+    <div class="lbl">❋ Log</div>
+    <pre id="log"></pre>
+  </div>
+
+  <p class="note">Needs a secure context (localhost or HTTPS) for WebGPU + cross-device WebRTC. No WebGPU? The same verified INT8 units run on CPU — old machines (e.g. via Supermium) still join, just slower. Every training step goes through the Neural Units; there is no plain-float path, and if the units fail to load, training is disabled.</p>
+  <p class="note"><b>Heads up:</b> peers connect directly (WebRTC), so devices in your group can see each other's IP address, and there's no gradient authentication — only train with devices/people you trust. Proof of concept.</p>
+
+  <script src="traincore.js"></script>
+  <script src="verified_core.js"></script>
+  <script src="webgpu.js"></script>
+  <script src="app.js"></script>
+</body>
+</html>

web/public/luts_meta.json

@@ -0,0 +1 @@
+{"mul": [256, 256], "requant": 65536, "relu": 256, "shift": 8}

web/public/mul_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cecff7e22049d0083ad9ee36dcf0695222c61621bacfd5a401c7b133abe892d
+size 131072

web/public/relu_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2acb03ba7520467636273208563f8e733494748f4aa5ac2dba89d9560050da79
+size 256

web/public/requant_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:173444ecfa293433329a333289983a665c481d913e9fd1c2778b55380ca4dd31
+size 65536

web/public/traincore.js

@@ -0,0 +1,91 @@
+// Shared training math — pure JS. Used as the WebGPU fallback in the browser,
+// and unit-tested directly in Node. Model: linear regression Y = X @ W (MSE).
+// The GEMMs here are exactly what the WebGPU compute shader replaces.
+(function (root) {
+  "use strict";
+
+  // C(m×n) = A(m×k) @ B(k×n), all Float32Array row-major
+  function matmul(A, B, m, k, n) {
+    const C = new Float32Array(m * n);
+    for (let i = 0; i < m; i++) {
+      for (let p = 0; p < k; p++) {
+        const a = A[i * k + p];
+        if (a === 0) continue;
+        const bo = p * n, co = i * n;
+        for (let j = 0; j < n; j++) C[co + j] += a * B[bo + j];
+      }
+    }
+    return C;
+  }
+
+  function transpose(A, rows, cols) {
+    const T = new Float32Array(rows * cols);
+    for (let i = 0; i < rows; i++)
+      for (let j = 0; j < cols; j++) T[j * rows + i] = A[i * cols + j];
+    return T;
+  }
+
+  // Forward + loss + gradient for one shard.
+  //   X: n×din,  W: din×dout,  y: n×dout
+  //   gradW = (2/n) * Xᵀ @ (X@W - y)   (din×dout)
+  // matmulFn lets the browser swap in the WebGPU GEMM (same signature as matmul).
+  function forwardLossGrad(X, y, W, n, din, dout, matmulFn) {
+    const mm = matmulFn || matmul;
+    const pred = mm(X, W, n, din, dout);          // n×dout   (GEMM)
+    const resid = new Float32Array(n * dout);
+    let loss = 0;
+    for (let i = 0; i < n * dout; i++) {
+      const r = pred[i] - y[i];
+      resid[i] = r; loss += r * r;
+    }
+    loss /= (n * dout);
+    const Xt = transpose(X, n, din);              // din×n
+    const g = mm(Xt, resid, din, n, dout);        // din×dout (GEMM)
+    const scale = 2 / n;
+    for (let i = 0; i < g.length; i++) g[i] *= scale;
+    return { pred, loss, gradW: g };
+  }
+
+  function applyGrad(W, gradAvg, lr) {
+    for (let i = 0; i < W.length; i++) W[i] -= lr * gradAvg[i];
+  }
+
+  // average a list of gradient Float32Arrays (equal weight)
+  function averageGrads(grads) {
+    const out = new Float32Array(grads[0].length);
+    for (const g of grads) for (let i = 0; i < g.length; i++) out[i] += g[i];
+    for (let i = 0; i < out.length; i++) out[i] /= grads.length;
+    return out;
+  }
+
+  // DaisyAdam — Adam with bias correction, applied to the cluster-averaged
+  // gradient. State is a pure function of the gradient sequence, so every peer
+  // that averages the same gradients keeps bit-identical moments: no optimizer
+  // state ever crosses the wire. Momentum also smooths the noisy STE gradients
+  // coming out of the verified INT8 units.
+  function makeAdam(dim, opts) {
+    const o = opts || {};
+    const lr = o.lr ?? 0.02, b1 = o.beta1 ?? 0.9, b2 = o.beta2 ?? 0.999, eps = o.eps ?? 1e-8;
+    const m = new Float32Array(dim), v = new Float32Array(dim);
+    let t = 0;
+    return {
+      name: `adam(lr=${lr})`,
+      // returns the update u; caller does W[i] -= u[i]
+      step(g) {
+        t++;
+        const c1 = 1 - Math.pow(b1, t), c2 = 1 - Math.pow(b2, t);
+        const u = new Float32Array(dim);
+        for (let i = 0; i < dim; i++) {
+          m[i] = b1 * m[i] + (1 - b1) * g[i];
+          v[i] = b2 * v[i] + (1 - b2) * g[i] * g[i];
+          u[i] = lr * (m[i] / c1) / (Math.sqrt(v[i] / c2) + eps);
+        }
+        return u;
+      },
+    };
+  }
+
+  const api = { matmul, transpose, forwardLossGrad, applyGrad, averageGrads, makeAdam };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  else root.TrainCore = api;
+})(typeof self !== "undefined" ? self : this);

web/public/verified_core.js

@@ -0,0 +1,84 @@
+// Verified INT8 compute — the emulated GPU logic, in the browser.
+// A layer's forward runs THROUGH the units: quantize -> LUT multiply -> requant
+// -> optional ReLU -> dequant. Backward is a straight-through estimator (the
+// integer path has no gradient), so ordinary float weights still learn.
+// Same units as the Python/Docker DaisyChain; here they're lookup tables.
+(function (root) {
+  "use strict";
+
+  let TC;   // TrainCore (matmul/transpose) — resolved per environment at the end
+
+  function quantize(X) {
+    let mx = 0; for (let i = 0; i < X.length; i++) { const a = Math.abs(X[i]); if (a > mx) mx = a; }
+    const scale = Math.max(mx / 127, 1e-8);
+    const q = new Int8Array(X.length);
+    for (let i = 0; i < X.length; i++) { let v = Math.round(X[i] / scale); q[i] = v < -128 ? -128 : v > 127 ? 127 : v; }
+    return { q, scale };
+  }
+
+  // int8 matmul via the verified multiply LUT: acc(m×n) = sum_k mulLUT[Xq,Wq]
+  function lutMatmulJS(Xq, Wq, m, k, n, L) {
+    const C = new Int32Array(m * n), mul = L.mul;
+    for (let i = 0; i < m; i++) {
+      for (let p = 0; p < k; p++) {
+        const au = (Xq[i * k + p] & 0xFF) * 256, wo = p * n, co = i * n;
+        for (let j = 0; j < n; j++) C[co + j] += mul[au + (Wq[wo + j] & 0xFF)];
+      }
+    }
+    return C;
+  }
+
+  // one verified layer forward; returns float out (+ cache for STE backward).
+  // Every product goes through the verified INT8 multiply (mul8 LUT) with exact
+  // int32 accumulation — i.e. an emulated INT8 tensor-core GEMM — then dequant.
+  async function linearFwd(X, W, m, k, n, L, useRelu, matmulInt8) {
+    const xq = quantize(X), wq = quantize(W);
+    const acc = await (matmulInt8 || lutMatmulJS)(xq.q, wq.q, m, k, n, L);  // verified multiply
+    const dq = xq.scale * wq.scale;
+    const out = new Float32Array(m * n);
+    const mask = useRelu ? new Uint8Array(m * n) : null;
+    for (let i = 0; i < m * n; i++) {
+      let v = acc[i] * dq;
+      if (useRelu) { if (v > 0) mask[i] = 1; else v = 0; }
+      out[i] = v;
+    }
+    return { out, mask };
+  }
+
+  // 2-layer MLP: X→H (relu) →dout. Forward through verified units, MSE loss.
+  async function forward(X, y, W1, W2, D, L, matmulInt8) {
+    const { n, din, h, dout } = D;
+    const l1 = await linearFwd(X, W1, n, din, h, L, true, matmulInt8);
+    const l2 = await linearFwd(l1.out, W2, n, h, dout, L, false, matmulInt8);
+    const resid = new Float32Array(n * dout); let loss = 0;
+    for (let i = 0; i < resid.length; i++) { const r = l2.out[i] - y[i]; resid[i] = r; loss += r * r; }
+    loss /= resid.length;
+    return { loss, resid, z1: l1.out, mask1: l1.mask };
+  }
+
+  // STE backward (verified matmul treated as float X@W). Returns flat [gW1, gW2].
+  function backward(X, W1, W2, fwd, D) {
+    const { n, din, h, dout } = D;
+    const { resid, z1, mask1 } = fwd;
+    const s = 2 / n;
+    const dout_ = new Float32Array(resid.length);
+    for (let i = 0; i < resid.length; i++) dout_[i] = resid[i] * s;
+    const mm = TC.matmul, tr = TC.transpose;
+    const gW2 = mm(tr(z1, n, h), dout_, h, n, dout);          // z1ᵀ @ dout
+    const dz1 = mm(dout_, tr(W2, h, dout), n, dout, h);        // dout @ W2ᵀ
+    for (let i = 0; i < dz1.length; i++) if (!mask1[i]) dz1[i] = 0;  // relu grad
+    const gW1 = mm(tr(X, n, din), dz1, din, n, h);            // Xᵀ @ dz1
+    const g = new Float32Array(gW1.length + gW2.length);
+    g.set(gW1, 0); g.set(gW2, gW1.length);
+    return g;
+  }
+
+  function splitApply(W1, W2, gAvg, lr) {
+    for (let i = 0; i < W1.length; i++) W1[i] -= lr * gAvg[i];
+    for (let j = 0; j < W2.length; j++) W2[j] -= lr * gAvg[W1.length + j];
+  }
+
+  const api = { quantize, lutMatmulJS, linearFwd, forward, backward, splitApply };
+  if (typeof module !== "undefined" && module.exports) { TC = require("./traincore.js"); module.exports = api; }
+  else { TC = root.TrainCore; root.Verified = api; }
+})(typeof self !== "undefined" ? self : this);

web/public/webgpu.js

@@ -0,0 +1,91 @@
+// WebGPU INT8 matmul via the verified multiply LUT — the emulated GPU logic
+// running on the browser's GPU. Automatic CPU fallback (same LUT) for machines
+// without WebGPU (e.g. old PCs via Supermium). initCompute() returns
+//   { backend, label, matmulInt8(Xq, Wq, m, k, n, L) -> Int32Array }
+// matching Verified.lutMatmulJS, so the trainer is device-blind.
+(function (root) {
+  "use strict";
+
+  const WGSL = `
+    @group(0) @binding(0) var<storage, read> Xq  : array<i32>;   // int8 byte per elem
+    @group(0) @binding(1) var<storage, read> Wq  : array<i32>;
+    @group(0) @binding(2) var<storage, read> lut : array<i32>;   // 65536 signed products
+    @group(0) @binding(3) var<storage, read_write> C : array<i32>;
+    @group(0) @binding(4) var<uniform> dims : vec3<u32>;         // m, k, n
+    @compute @workgroup_size(8, 8)
+    fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+      let m = dims.x; let k = dims.y; let n = dims.z;
+      let row = gid.x; let col = gid.y;
+      if (row >= m || col >= n) { return; }
+      var s : i32 = 0;
+      for (var p = 0u; p < k; p = p + 1u) {
+        let au = u32(Xq[row * k + p] & 255);
+        let bu = u32(Wq[p * n + col] & 255);
+        s = s + lut[au * 256u + bu];
+      }
+      C[row * n + col] = s;
+    }`;
+
+  async function loadLUTs(base) {
+    base = base || "";
+    const [mulB, reqB, reluB, meta] = await Promise.all([
+      fetch(base + "mul_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "requant_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "relu_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "luts_meta.json").then(r => r.json()),
+    ]);
+    return { mul: new Int16Array(mulB), requant: new Int8Array(reqB),
+             relu: new Int8Array(reluB), shift: meta.shift };
+  }
+
+  async function initCompute(L) {
+    const cpu = { backend: "cpu", label: "CPU (JS)",
+                  matmulInt8: (Xq, Wq, m, k, n, LL) => root.Verified.lutMatmulJS(Xq, Wq, m, k, n, LL) };
+    if (!(root.navigator && navigator.gpu)) return cpu;
+    try {
+      const adapter = await navigator.gpu.requestAdapter();
+      if (!adapter) return cpu;
+      const device = await adapter.requestDevice();
+      const module = device.createShaderModule({ code: WGSL });
+      const pipeline = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main" } });
+      // upload the multiply LUT once (as i32)
+      const lut32 = new Int32Array(L.mul);   // widen int16 -> int32
+      const lutBuf = device.createBuffer({ size: lut32.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+      device.queue.writeBuffer(lutBuf, 0, lut32);
+      const info = adapter.info || {};
+      return { backend: "webgpu", label: info.description || info.vendor || "WebGPU",
+               matmulInt8: (Xq, Wq, m, k, n) => gpuMatmul(device, pipeline, lutBuf, Xq, Wq, m, k, n) };
+    } catch (e) { console.warn("WebGPU init failed, CPU fallback:", e); return cpu; }
+  }
+
+  async function gpuMatmul(device, pipeline, lutBuf, Xq, Wq, m, k, n) {
+    const X32 = Int32Array.from(Xq), W32 = Int32Array.from(Wq);   // byte -> i32
+    const bufX = mk(device, X32.byteLength, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const bufW = mk(device, W32.byteLength, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const bytesC = m * n * 4;
+    const bufC = mk(device, bytesC, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC);
+    const bufD = mk(device, 16, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+    device.queue.writeBuffer(bufX, 0, X32);
+    device.queue.writeBuffer(bufW, 0, W32);
+    device.queue.writeBuffer(bufD, 0, new Uint32Array([m, k, n]));
+    const bind = device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries: [
+      { binding: 0, resource: { buffer: bufX } }, { binding: 1, resource: { buffer: bufW } },
+      { binding: 2, resource: { buffer: lutBuf } }, { binding: 3, resource: { buffer: bufC } },
+      { binding: 4, resource: { buffer: bufD } } ] });
+    const enc = device.createCommandEncoder();
+    const pass = enc.beginComputePass();
+    pass.setPipeline(pipeline); pass.setBindGroup(0, bind);
+    pass.dispatchWorkgroups(Math.ceil(m / 8), Math.ceil(n / 8)); pass.end();
+    const read = mk(device, bytesC, GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ);
+    enc.copyBufferToBuffer(bufC, 0, read, 0, bytesC);
+    device.queue.submit([enc.finish()]);
+    await read.mapAsync(GPUMapMode.READ);
+    const out = new Int32Array(read.getMappedRange().slice(0));
+    read.unmap();
+    [bufX, bufW, bufC, bufD, read].forEach(b => b.destroy());
+    return out;
+  }
+  function mk(device, size, usage) { return device.createBuffer({ size, usage }); }
+
+  root.Compute = { initCompute, loadLUTs };
+})(self);

web/server.js

@@ -0,0 +1,111 @@
+// DaisyChain-Web signaling + static host.
+// - Serves public/ (the page users open).
+// - WebSocket signaling: introduces peers in a room and relays WebRTC
+//   offers/answers/ICE. It never sees the compute — that's P2P over WebRTC.
+// Only dependency: `ws`.  Run:  npm install && node server.js
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { WebSocketServer } = require("ws");
+
+// Snapdrop-style: peers are grouped by their PUBLIC IP, so only devices on the
+// same network auto-discover each other. An explicit ?room=CODE overrides this
+// to connect across networks (share the code with people you invite).
+function clientIP(req) {
+  const xff = req.headers["x-forwarded-for"];
+  if (xff) return xff.split(",")[0].trim();
+  return (req.socket.remoteAddress || "unknown").replace(/^::ffff:/, "");
+}
+function roomFor(req) {
+  const u = new URL(req.url, "http://x");
+  const code = u.searchParams.get("room");
+  if (code) return "room:" + code;
+  const h = crypto.createHash("sha256").update(clientIP(req)).digest("hex").slice(0, 10);
+  return "net:" + h;               // same network -> same room (IP not exposed in the id)
+}
+
+const PORT = process.env.PORT || 8787;
+const PUB = path.join(__dirname, "public");
+const TYPES = { ".html": "text/html", ".js": "text/javascript",
+                ".css": "text/css", ".json": "application/json" };
+
+const server = http.createServer((req, res) => {
+  let p = decodeURIComponent(req.url.split("?")[0]);
+  if (p === "/") p = "/index.html";
+  const file = path.join(PUB, path.normalize(p));
+  if (!file.startsWith(PUB)) { res.writeHead(403); return res.end(); }
+  fs.readFile(file, (err, data) => {
+    if (err) { res.writeHead(404); return res.end("not found"); }
+    res.writeHead(200, { "Content-Type": TYPES[path.extname(file)] || "application/octet-stream" });
+    res.end(data);
+  });
+});
+
+const wss = new WebSocketServer({ server });
+// roomId -> { peers: Map(id -> {ws,name}), host: id|null, pending: Map(id -> {ws,name}) }
+// Private rooms (room:CODE) are gated: the creator is the host, and everyone
+// arriving later waits until the host accepts them — knowing the code is not
+// enough. Network rooms (net:) keep auto-join (same LAN, Snapdrop-style).
+const rooms = new Map();
+let nextId = 1;
+
+function send(ws, obj) { if (ws.readyState === 1) ws.send(JSON.stringify(obj)); }
+
+wss.on("connection", (ws, req) => {
+  const roomId = roomFor(req);
+  const name = (new URL(req.url, "http://x").searchParams.get("name") || "").slice(0, 40) || ("p" + nextId);
+  const id = "p" + (nextId++);
+  ws.peerId = id; ws.roomId = roomId;
+  if (!rooms.has(roomId)) rooms.set(roomId, { peers: new Map(), host: null, pending: new Map() });
+  const room = rooms.get(roomId);
+  const isPrivate = roomId.startsWith("room:");
+
+  function admit(pid, peer) {
+    const roster = [...room.peers.entries()].map(([qid, v]) => ({ id: qid, name: v.name }));
+    send(peer.ws, { type: "welcome", id: pid, room: roomId, peers: roster, host: room.host === pid });
+    for (const [, v] of room.peers) send(v.ws, { type: "peer-joined", id: pid, name: peer.name });
+    room.peers.set(pid, peer);
+  }
+
+  if (isPrivate && room.peers.size === 0) room.host = id;   // creator hosts
+  if (isPrivate && room.host !== id) {
+    room.pending.set(id, { ws, name });
+    send(ws, { type: "waiting" });
+    const h = room.peers.get(room.host);
+    if (h) send(h.ws, { type: "join-request", id, name });
+  } else {
+    admit(id, { ws, name });
+  }
+
+  ws.on("message", (buf) => {
+    let msg; try { msg = JSON.parse(buf); } catch { return; }
+    if (msg.type === "signal" && msg.to && room.peers.has(id)) {   // relay WebRTC signaling
+      const target = room.peers.get(msg.to);
+      if (target) send(target.ws, { type: "signal", from: id, data: msg.data });
+    } else if (msg.type === "admit" && id === room.host) {         // host verdict on a joiner
+      const p = room.pending.get(msg.id);
+      if (!p) return;
+      room.pending.delete(msg.id);
+      if (msg.allow) admit(msg.id, p);
+      else { send(p.ws, { type: "denied" }); p.ws.close(); }
+    }
+  });
+
+  ws.on("close", () => {
+    room.pending.delete(id);
+    if (room.peers.delete(id))
+      for (const [, v] of room.peers) send(v.ws, { type: "peer-left", id });
+    if (room.host === id) {                                        // host left: promote oldest
+      room.host = room.peers.keys().next().value ?? null;
+      const h = room.peers.get(room.host);
+      if (h) {
+        send(h.ws, { type: "host" });
+        for (const [pid, p] of room.pending) send(h.ws, { type: "join-request", id: pid, name: p.name });
+      }
+    }
+    if (room.peers.size === 0 && room.pending.size === 0) rooms.delete(roomId);
+  });
+});
+
+server.listen(PORT, () => console.log(`DaisyChain-Web on http://localhost:${PORT}`));

web/test_core.js

@@ -0,0 +1,54 @@
+// Verifies the training loop + 2-peer gradient averaging in pure Node (no
+// browser). Simulates two peers each holding half the data; they average
+// gradients every step. Proves: (a) it converges, (b) both replicas stay
+// identical — the same guarantees the browser P2P version needs.
+const T = require("./public/traincore.js");
+
+function randn(n) {
+  const a = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    let u = 0, v = 0;
+    while (u === 0) u = Math.random();
+    while (v === 0) v = Math.random();
+    a[i] = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  }
+  return a;
+}
+
+const din = 16, dout = 4, nPer = 128, steps = 400, lr = 0.05;
+
+// ground-truth weights
+const Wtrue = randn(din * dout);
+function makeShard() {
+  const X = randn(nPer * din);
+  const y = T.matmul(X, Wtrue, nPer, din, dout);   // clean targets
+  return { X, y };
+}
+const A = makeShard(), B = makeShard();
+
+// both peers start from the SAME W0 (initiator broadcasts it)
+const W0 = randn(din * dout);
+const Wa = Float32Array.from(W0), Wb = Float32Array.from(W0);
+
+let loss = 0;
+for (let s = 0; s < steps; s++) {
+  const ra = T.forwardLossGrad(A.X, A.y, Wa, nPer, din, dout);
+  const rb = T.forwardLossGrad(B.X, B.y, Wb, nPer, din, dout);
+  const avg = T.averageGrads([ra.gradW, rb.gradW]);   // <-- exchanged P2P
+  T.applyGrad(Wa, avg, lr);
+  T.applyGrad(Wb, avg, lr);
+  loss = (ra.loss + rb.loss) / 2;
+  if (s % 80 === 0 || s === steps - 1)
+    console.log(`  step ${s}  cluster-avg loss ${loss.toFixed(6)}`);
+}
+
+let maxDiff = 0;
+for (let i = 0; i < Wa.length; i++) maxDiff = Math.max(maxDiff, Math.abs(Wa[i] - Wb[i]));
+let recovery = 0;
+for (let i = 0; i < Wtrue.length; i++) recovery = Math.max(recovery, Math.abs(Wa[i] - Wtrue[i]));
+
+console.log(`\nreplica max param diff: ${maxDiff.toExponential(3)}`);
+console.log(`max |W - W_true|:       ${recovery.toExponential(3)}`);
+const ok = loss < 1e-3 && maxDiff < 1e-9 && recovery < 0.05;
+console.log(ok ? "\nCORE TEST PASSED — converged, replicas in sync." : "\nCORE TEST FAILED");
+process.exit(ok ? 0 : 1);

web/test_optimizer.js

@@ -0,0 +1,63 @@
+// Verifies DaisyAdam (TrainCore.makeAdam) on the path that matters: training
+// THROUGH the verified INT8 units, where STE gradients are noisy and plain SGD
+// plateaus. Checks (a) two replicas fed the same averaged gradients stay
+// bit-identical, (b) Adam reaches a lower loss than SGD in the same steps.
+const fs = require("fs");
+const path = require("path");
+const T = require("./public/traincore.js");
+const V = require("./public/verified_core.js");
+
+function loadLUTs() {
+  const p = (f) => path.join(__dirname, "public", f);
+  return {
+    mul: new Int16Array(fs.readFileSync(p("mul_lut.bin")).buffer.slice(0)),
+    requant: new Int8Array(fs.readFileSync(p("requant_lut.bin")).buffer.slice(0)),
+    relu: new Int8Array(fs.readFileSync(p("relu_lut.bin")).buffer.slice(0)),
+  };
+}
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+
+const L = loadLUTs();
+const D = { n: 128, din: 16, h: 16, dout: 4 }, steps = 300;
+
+const Wtrue1 = randn(D.din * D.h, mulberry32(42)), Wtrue2 = randn(D.h * D.dout, mulberry32(43));
+function target(X) { const hpre = T.matmul(X, Wtrue1, D.n, D.din, D.h); for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]); return T.matmul(hpre, Wtrue2, D.n, D.h, D.dout); }
+const XA = randn(D.n * D.din, mulberry32(11)), yA = target(XA);
+const XB = randn(D.n * D.din, mulberry32(12)), yB = target(XB);
+
+async function run(useAdam) {
+  const W1a = randn(D.din * D.h, mulberry32(7)), W2a = randn(D.h * D.dout, mulberry32(8));
+  const W1b = Float32Array.from(W1a), W2b = Float32Array.from(W2a);
+  const dim = W1a.length + W2a.length;
+  const oa = T.makeAdam(dim, { lr: 0.2 }), ob = T.makeAdam(dim, { lr: 0.2 });
+  let loss = 0;
+  for (let s = 0; s < steps; s++) {
+    const fa = await V.forward(XA, yA, W1a, W2a, D, L), ga = V.backward(XA, W1a, W2a, fa, D);
+    const fb = await V.forward(XB, yB, W1b, W2b, D, L), gb = V.backward(XB, W1b, W2b, fb, D);
+    const avg = T.averageGrads([ga, gb]);
+    if (useAdam) {
+      V.splitApply(W1a, W2a, oa.step(avg), 1);
+      V.splitApply(W1b, W2b, ob.step(avg), 1);
+    } else {
+      V.splitApply(W1a, W2a, avg, 0.03);
+      V.splitApply(W1b, W2b, avg, 0.03);
+    }
+    loss = (fa.loss + fb.loss) / 2;
+  }
+  let diff = 0;
+  for (let i = 0; i < W1a.length; i++) diff = Math.max(diff, Math.abs(W1a[i] - W1b[i]));
+  for (let i = 0; i < W2a.length; i++) diff = Math.max(diff, Math.abs(W2a[i] - W2b[i]));
+  return { loss, diff };
+}
+
+(async function () {
+  const sgd = await run(false);
+  const adam = await run(true);
+  console.log(`SGD(lr=0.03)      final loss ${sgd.loss.toFixed(5)}`);
+  console.log(`DaisyAdam(lr=0.2) final loss ${adam.loss.toFixed(5)}  replica diff ${adam.diff.toExponential(3)}`);
+  const ok = adam.diff === 0 && adam.loss < sgd.loss;
+  console.log(ok ? "\nOPTIMIZER TEST PASSED — deterministic replicas, beats SGD through the verified units."
+                 : "\nOPTIMIZER TEST FAILED");
+  process.exit(ok ? 0 : 1);
+})();

web/test_verified.js

@@ -0,0 +1,48 @@
+// Proves 2-peer training THROUGH the verified units (LUTs) converges and stays
+// in sync — the browser will do exactly this, with the matmul on WebGPU.
+const fs = require("fs");
+const path = require("path");
+const T = require("./public/traincore.js");
+const V = require("./public/verified_core.js");
+
+function loadLUTs() {
+  const p = (f) => path.join(__dirname, "public", f);
+  const mul = new Int16Array(fs.readFileSync(p("mul_lut.bin")).buffer.slice(0));
+  const requant = new Int8Array(fs.readFileSync(p("requant_lut.bin")).buffer.slice(0));
+  const relu = new Int8Array(fs.readFileSync(p("relu_lut.bin")).buffer.slice(0));
+  return { mul, requant, relu };
+}
+
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+
+const L = loadLUTs();
+const D = { n: 128, din: 16, h: 16, dout: 4 }, lr = 0.03, steps = 300;
+
+// shared deterministic truth + init; per-peer data shard
+const Wtrue1 = randn(D.din * D.h, mulberry32(42)), Wtrue2 = randn(D.h * D.dout, mulberry32(43));
+function target(X) { const hpre = T.matmul(X, Wtrue1, D.n, D.din, D.h); for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]); return T.matmul(hpre, Wtrue2, D.n, D.h, D.dout); }
+const XA = randn(D.n * D.din), yA = target(XA);
+const XB = randn(D.n * D.din), yB = target(XB);
+
+const W1a = randn(D.din * D.h, mulberry32(7)), W2a = randn(D.h * D.dout, mulberry32(8));
+const W1b = Float32Array.from(W1a), W2b = Float32Array.from(W2a);
+
+(async function () {
+  let loss = 0, loss0 = 0;
+  for (let s = 0; s < steps; s++) {
+    const fa = await V.forward(XA, yA, W1a, W2a, D, L), ga = V.backward(XA, W1a, W2a, fa, D);
+    const fb = await V.forward(XB, yB, W1b, W2b, D, L), gb = V.backward(XB, W1b, W2b, fb, D);
+    const avg = T.averageGrads([ga, gb]);               // <-- exchanged P2P
+    V.splitApply(W1a, W2a, avg, lr);
+    V.splitApply(W1b, W2b, avg, lr);
+    loss = (fa.loss + fb.loss) / 2; if (s === 0) loss0 = loss;
+    if (s % 60 === 0 || s === steps - 1) console.log(`  step ${s}  cluster-avg loss ${loss.toFixed(5)}`);
+  }
+  let diff = 0; for (let i = 0; i < W1a.length; i++) diff = Math.max(diff, Math.abs(W1a[i] - W1b[i]));
+  for (let i = 0; i < W2a.length; i++) diff = Math.max(diff, Math.abs(W2a[i] - W2b[i]));
+  console.log(`\nreplica max param diff: ${diff.toExponential(3)}`);
+  const ok = loss < loss0 * 0.3 && diff < 1e-9;
+  console.log(ok ? "VERIFIED TEST PASSED — trained through the units, converged, replicas in sync." : "FAILED");
+  process.exit(ok ? 0 : 1);
+})();