---
title: "DaisyChain-Web"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/ee3e8c0c-32b4-475a-bbf2-560e73294ec4"
updated: "2026-11-12"
---

# DaisyChain-Web

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Train a small shared model by opening one web page on two or more devices. Browsers link directly over WebRTC and average their gradients, with no install or account. A proof of concept.

DaisyChain-Web is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Quazim0t0

## About

### What it is

DaisyChain-Web is the browser version of the DaisyChain project. Open one page on a few devices and each becomes a training peer for the same model. The devices link directly to each other over WebRTC and average their gradients as they go.

The math runs through INT8 units that the project calls verified, as a lookup-table multiply on WebGPU. Older machines fall back to the CPU.

### Who it suits

It suits people who want to watch distributed training happen between browsers, and developers who want to read a small WebRTC and WebGPU project. The author calls it a proof of concept.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Machine learning research | Researchers | Join two devices into one training run and watch the shared loss | Testing gradient averaging between a phone and a laptop |
| Education | Students | Open two tabs and click Start training in each | Seeing distributed training with nothing to set up |
| Web development | Browser developers | Read server.js, app.js and webgpu.js | Learning how a WebRTC mesh and a WebGPU shader fit together |
| Embedded and edge AI | Hardware-minded engineers | Study the INT8 lookup-table units in the browser | Checking how quantize, multiply and dequantize are done |

Skip it if you need a hardened service for strangers, since the project says it is not built for that.

### Where to use it

The page runs in these places.

- A web browser, on the Space's page at Hugging Face
- A local Node server on Windows, macOS or Linux, opened in two tabs or on two devices
- A local Docker container on port 7860
- Hugging Face's cpu-basic hardware, where the online Space runs

| Use case | Who | What they get back |
| --- | --- | --- |
| Start a shared training run | Researchers | A shared loss that falls on every connected device |
| Check the training math without a browser | Developers | The result of a two-peer gradient averaging test |
| Study the INT8 units | Engineers | Browser code for the quantize, multiply and dequantize steps |

### How to set it up

Online you only need a browser. A local copy needs these.

- Node and npm for the direct route, or Docker for the container route
- Python and pip, for the hf download command
- Two browser tabs or two devices, to see the training connect

1. Install the huggingface\_hub package.
2. Download the Space's files into a folder with the hf command.
3. Move into that folder.
4. Either build and run the Docker image, or install the Node packages and start the server.

```sh
pip install -U huggingface_hub
hf download Quazim0t0/DaisyChain-Web --repo-type space --local-dir DaisyChain-Web
cd DaisyChain-Web
```

For the container route, continue with these two commands.

```sh
docker build -t daisychain-web .
docker run -it -p 7860:7860 daisychain-web
```

For the Node route, continue with these two commands instead.

```sh
npm install
npm start
```

### How to use it

Start the server, then open the page it serves in two browser tabs or on two devices. They find each other and connect directly. Click Start training on each one and watch the shared loss fall on both.

Only devices on the same network find each other on their own. To link people on other networks, everyone adds the same room code to the page address through the room parameter.

| Tool | What it does |
| --- | --- |
| npm start | Starts the signaling server that also serves the page |
| npm test | Runs a two-peer gradient averaging check without a browser |

### Example

You run npm start, open the page in two tabs and click Start training in each one. Both tabs show the same loss curve falling, and the two copies of the model stay identical.

### For newcomers and experts

If you are new, open the Space's page on two tabs of your own browser and click Start training in each. You do not need an account, and nothing is installed. Do this only with devices you trust.

If you know the field, every peer starts from the same seeded weights, trains on its own data shard and broadcasts its gradient each step. All peers average everyone's gradients, so they converge to one model. server.js only relays WebRTC handshakes and hosts the files, and the compute never passes through it.

Open the page on two or more devices → A small server introduces the peers → Peers connect directly over WebRTC → Each trains and shares its gradients → All peers average them and stay in sync

### Good to know

Each device links straight to the others, which exposes your IP address to every device in your group. Nothing verifies who sends a gradient, so a hostile peer could spoil the shared model. The run stops and keeps its weights when a gradient is malformed, meaning NaN, Inf or the wrong length. A bad gradient with ordinary numbers still gets averaged in.

- License: MIT
- Cost to run: none named. The project says there is no install and no account
- Data it reaches: the other peers' IP addresses and gradients, plus the signaling server that relays handshakes. The Space names the fineweb-edu dataset
- Not for: public use with strangers. WebGPU and cross-device WebRTC also need a secure context, such as localhost

## README

````markdown
# DaisyChain-Web

Train a small shared model by opening one web page on two or more devices. Browsers link directly over WebRTC and average their gradients, with no install or account. A proof of concept.

Made by Quazim0t0 on Hugging Face. These notes are Mindket's, written from its Space page and README; the app's own files and license are on Hugging Face.

## About

What it is: DaisyChain-Web is the browser version of the DaisyChain project. Open one page on a few devices and each becomes a training peer for the same model. The devices link directly to each other over WebRTC and average their gradients as they go.

The math runs through INT8 units that the project calls verified, as a lookup-table multiply on WebGPU. Older machines fall back to the CPU.

Who it suits: It suits people who want to watch distributed training happen between browsers, and developers who want to read a small WebRTC and WebGPU project. The author calls it a proof of concept.

```table
Industry | Who uses it | How they use it | Example
Machine learning research | Researchers | Join two devices into one training run and watch the shared loss | Testing gradient averaging between a phone and a laptop
Education | Students | Open two tabs and click Start training in each | Seeing distributed training with nothing to set up
Web development | Browser developers | Read server.js, app.js and webgpu.js | Learning how a WebRTC mesh and a WebGPU shader fit together
Embedded and edge AI | Hardware-minded engineers | Study the INT8 lookup-table units in the browser | Checking how quantize, multiply and dequantize are done
```

Skip it if you need a hardened service for strangers, since the project says it is not built for that.

Where to use it: The page runs in these places.

- A web browser, on the Space's page at Hugging Face
- A local Node server on Windows, macOS or Linux, opened in two tabs or on two devices
- A local Docker container on port 7860
- Hugging Face's cpu-basic hardware, where the online Space runs

```table
Use case | Who | What they get back
Start a shared training run | Researchers | A shared loss that falls on every connected device
Check the training math without a browser | Developers | The result of a two-peer gradient averaging test
Study the INT8 units | Engineers | Browser code for the quantize, multiply and dequantize steps
```

How to set it up: Online you only need a browser. A local copy needs these.

- Node and npm for the direct route, or Docker for the container route
- Python and pip, for the hf download command
- Two browser tabs or two devices, to see the training connect

1. Install the huggingface_hub package.
2. Download the Space's files into a folder with the hf command.
3. Move into that folder.
4. Either build and run the Docker image, or install the Node packages and start the server.

```sh
pip install -U huggingface_hub
hf download Quazim0t0/DaisyChain-Web --repo-type space --local-dir DaisyChain-Web
cd DaisyChain-Web
```

For the container route, continue with these two commands.

```sh
docker build -t daisychain-web .
docker run -it -p 7860:7860 daisychain-web
```

For the Node route, continue with these two commands instead.

```sh
npm install
npm start
```

How to use it: Start the server, then open the page it serves in two browser tabs or on two devices. They find each other and connect directly. Click Start training on each one and watch the shared loss fall on both.

Only devices on the same network find each other on their own. To link people on other networks, everyone adds the same room code to the page address through the room parameter.

```table
Tool | What it does
npm start | Starts the signaling server that also serves the page
npm test | Runs a two-peer gradient averaging check without a browser
```

Example: You run npm start, open the page in two tabs and click Start training in each one. Both tabs show the same loss curve falling, and the two copies of the model stay identical.

For newcomers and experts: If you are new, open the Space's page on two tabs of your own browser and click Start training in each. You do not need an account, and nothing is installed. Do this only with devices you trust.

If you know the field, every peer starts from the same seeded weights, trains on its own data shard and broadcasts its gradient each step. All peers average everyone's gradients, so they converge to one model. server.js only relays WebRTC handshakes and hosts the files, and the compute never passes through it.

```flow
Open the page on two or more devices
A small server introduces the peers
Peers connect directly over WebRTC
Each trains and shares its gradients
All peers average them and stay in sync
```

Good to know: Each device links straight to the others, which exposes your IP address to every device in your group. Nothing verifies who sends a gradient, so a hostile peer could spoil the shared model. The run stops and keeps its weights when a gradient is malformed, meaning NaN, Inf or the wrong length. A bad gradient with ordinary numbers still gets averaged in.

- License: MIT
- Cost to run: none named. The project says there is no install and no account
- Data it reaches: the other peers' IP addresses and gradients, plus the signaling server that relays handshakes. The Space names the fineweb-edu dataset
- Not for: public use with strangers. WebGPU and cross-device WebRTC also need a secure context, such as localhost

## On Hugging Face, 13 November 2026

- Likes: 18
- Built with: docker
- License: mit

## Links

- Space: https://huggingface.co/spaces/Quazim0t0/DaisyChain-Web
- Files: https://huggingface.co/spaces/Quazim0t0/DaisyChain-Web/tree/main

## Try it

Open the Space in your browser, or copy it to your own Hugging Face account from its page. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[Quazim0t0/DaisyChain-Web on Hugging Face](https://huggingface.co/spaces/Quazim0t0/DaisyChain-Web)

## Compare with similar

Listed Hugging Face Spaces in the same category that share the most tags with this one.

| Product | Likes | Built with | License | Last change |
| --- | --- | --- | --- | --- |
| DaisyChain-Web (this page) | 18 | docker | mit | 2026-11-05 |
| [Zero GPU Spaces](https://mindket.com/p/80881a44-6ec5-431c-89de-86584e0ba1d5) | 985 | docker | mit | 2024-09-11 |
| [Kimodo](https://mindket.com/p/e6fe5336-403a-4328-92dc-77d41137a8bc) | 340 | docker | apache-2.0 | 2026-03-16 |
| [Harness Leaderboard](https://mindket.com/p/d0e92765-2a63-4ae5-9ba0-42dbfedd56a6) | 323 | docker | apache-2.0 | 2026-11-12 |
| [Flowise](https://mindket.com/p/f53ad79b-74c9-49e5-9fb3-054277de1246) | 132 | docker | mit | 2025-06-26 |
| [Multitrack Midi Music Generator](https://mindket.com/p/9bd48c41-e4a7-4576-be7e-da51b041b39f) | 130 | docker | mit | 2025-07-07 |

Numbers as Mindket last read them, on 2026-11-12.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-05
- First published: 2026-07-12
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Quazim0t0/DaisyChain-Web on Hugging Face](https://huggingface.co/spaces/Quazim0t0/DaisyChain-Web)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/ee3e8c0c-32b4-475a-bbf2-560e73294ec4)
- [Its page on Mindket](https://mindket.com/p/ee3e8c0c-32b4-475a-bbf2-560e73294ec4)
