README.md

metadata

title: DaisyChain-Infer
emoji: ❄️
colorFrom: blue
colorTo: gray
sdk: docker
app_port: 7860
license: mit
short_description: One model split across your devices, P2P in the browser
hf_oauth: true
hf_oauth_scopes:
  - read-repos
hf_oauth_expiration_minutes: 480

❄ DaisyChain-Infer — one model, split across your devices

Part of DaisyChain → https://huggingface.co/DaisyChainAI

Pick a Hugging Face model, open this page on two or more of your devices, and each one takes a slice of the model's layers. A token is produced by passing the hidden state around the ring, peer-to-peer over WebRTC. Every multiply runs through verified INT8 units — WebGPU where available, the identical math on CPU where not.

The group can run a model that no single device could hold, because each device downloads only its own layers.

Project files, guide and test suites: https://huggingface.co/DaisyChainAI/DaisyChain-Infer

How to use it

1. Create a room and open the invite link on your other devices. You approve each device before it joins. (There is no automatic grouping here — see Privacy below.)
2. On one device, type a model repo id and press Load. That device becomes the head.
3. Press Generate. Each device fetches its own layers from the Hub, reports ready, and the ring starts.

Models it can run: any .safetensors repo that is Llama-style (Llama, Mistral, Qwen2/2.5, SmolLM, TinyLlama) or GPT-2-style. Try HuggingFaceTB/SmolLM-135M, openai-community/gpt2, or Qwen/Qwen2.5-0.5B.

Anything else is refused by name, not approximated — running an unknown block shape through these kernels would produce fluent, confident, wrong text.

Nothing is downloaded to this Space

This Space is a WebSocket signaling server and a static file host. It never sees a weight, an activation, your prompt, or the generated text. Weights go from the Hugging Face CDN straight to each browser, using HTTP range requests against the byte offsets in the safetensors header — so a device transfers only the layers it owns, and pressing Load costs a few tens of KB regardless of the model's size.

Signing in

Public models need no sign-in at all.

For gated or private models, use Sign in with Hugging Face. You are redirected to huggingface.co and back, and this page receives a scoped, expiring token (read access to repositories, nothing more) held in memory for that tab only — never written to storage, never logged, and never sent to another device. Each device signs in for itself, because each device downloads its own layers.

There is deliberately no box to paste a personal access token here. Typing a PAT into a page served by someone else is a bad habit even when the code is honest, because you cannot verify that it is. If you would rather not sign in at all, clone the project and run it locally — the local build accepts a token directly, because there the page is served from your own machine.

One honest caveat: the OAuth code exchange requires a client secret, so it happens on the server, which means this Space briefly handles your access token during that exchange. It is not stored or logged, and it is handed to your browser in the URL fragment (which browsers never send to servers) and stripped from history on arrival. That is the smallest exposure the flow allows — it is not zero.

Privacy and trust

• Rooms are private by invitation. This deployment disables the LAN auto-grouping the local build uses, because on a public URL two strangers behind the same CGNAT or on the same campus network share a public IP and would otherwise be placed in one ring together.
• Peers connect directly, so devices in your ring can see each other's IP addresses.
• A middle stage never receives the embedding table, so it never sees the vocabulary — it passes floats it cannot interpret. But it does see the hidden states going through it, and the head sees your prompt and output.
• Activations are not authenticated. A malicious stage that runs correct arithmetic but returns a crafted activation is not caught by anything here. The verification proves the computation is right on every honest device; trust in the participants is yours to establish.

Ring only with devices and people you trust. This is a proof of concept, not a hardened service.

Honest limits

• Latency, not bandwidth, is the cost. Every token pays one round trip per stage, so tokens/sec falls as you add devices. More stages buy capacity, not speed.
• No KV cache — every token re-runs the whole window, which is also what keeps a split run bit-comparable against an unsplit one.
• Weights are held as f32, so budget ~4 bytes per parameter across the group. The ring plan shows each device's cost before you start.
• Needs WebGPU or a patient CPU, and a secure context (this Space is HTTPS, so that is fine).
• The head is a single point of failure; a stage that drops stalls the ring. Press Generate again to re-plan around whoever is still connected.

---

License: MIT · Author: Dean Byrne (Quazim0t0) · Org: DaisyChainAI

Built on DaisyChain-Train and DaisyChain-Web — the verified INT8 units, the WGSL kernels and their exact gates, and the WebRTC mesh are carried over unchanged.