web/README.md

🌼 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

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):

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:

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