SpawnDev.WebTorrent 2.3.1

SpawnDev.WebTorrent

Pure C# BitTorrent/WebTorrent client and server. No JavaScript dependencies. Runs on desktop (.NET) and browser (Blazor WASM). 461+ tests. 15 BEPs implemented.

Features

• Pure C# — No JavaScript interop, no Node.js, no npm. 100% .NET.
• Desktop + Browser — Same library, same API. WPF, console, Blazor WebAssembly.
• DI Singleton Services — WebTorrentClient and ServiceWorkerStreamHandler implement IAsyncBackgroundService. Register once, start with the app, inject anywhere.
• Real WebRTC P2P — Browser (SpawnDev.BlazorJS) and desktop (SIPSorcery) peers interop seamlessly via the same tracker.
• 15 BEPs — Full wire protocol, DHT, Fast Extension, ut_metadata, ut_pex, private torrents, magnet file selection, and more.
• 3 Tracker Types — WebSocket (browser+desktop), HTTP/HTTPS, UDP (desktop).
• Web Seed Download — HTTP range requests with multi-file piece assembly (BEP 17/19).
• Persistent Storage — Torrents and pieces persist in OPFS (browser) or filesystem (desktop). Survive page reloads. Resume downloading automatically.
• Media Streaming with Seeking — Service worker intercepts video/audio range requests and serves pieces on demand. file.StreamURL, file.StreamTo(elem), file.CreateReadStream(). True seeking — pieces download as the video plays.
• Service Worker — webtorrent-sw.js ships with the library. Handles Cross-Origin-Isolation headers, Blazor loading, and torrent streaming via MessageChannel. One <script> tag and your app streams.
• System.IO.Stream — file.CreateReadStream() returns a seekable .NET Stream backed by torrent pieces. Use with any API that takes a Stream.
• Random-Access Streaming — Read any byte range from a torrent file as it downloads. Pieces download on demand. Perfect for ML model weight streaming.
• Seeding — Upload pieces to requesting peers with configurable rate limiting.
• Speed Tracking — Real-time download/upload bytes/sec per torrent.
• AI Agent Communication — BEP 46 DHT mutable items with real ECDSA-P256 signing via SpawnDev.BlazorJS.Cryptography. AgentChannel pub/sub for shared AI state.
• HuggingFace Integration — Optional server extension that proxies HuggingFace model CDN with local caching and automatic torrent generation.
• Custom Wire Extensions — UseExtension() factory pattern (same as JS WebTorrent wire.use()). Build custom P2P protocols on top of the BitTorrent wire — distributed compute, AI agents, anything. Extensions negotiate via BEP 10.
• .torrent Creation — Create and parse .torrent files. Complete Bencode encoder/decoder.
• 452+ Unit Tests — Every BEP tested, ECDSA crypto verified in browser, service worker streaming verified end-to-end, security tests for signature verification.

Packages

Quick Start — Blazor WebAssembly (DI)

// Program.cs
using SpawnDev.AsyncFileSystem;
using SpawnDev.AsyncFileSystem.BrowserWASM;
using SpawnDev.BlazorJS;
using SpawnDev.BlazorJS.Cryptography;
using SpawnDev.WebTorrent;

var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.Services.AddBlazorJSRuntime();

// Cross-platform crypto for BEP 46 signing
if (OperatingSystem.IsBrowser())
    builder.Services.AddSingleton<IPortableCrypto, BrowserWASMCrypto>();
else
    builder.Services.AddSingleton<IPortableCrypto, DotNetCrypto>();

// Persistent file system (OPFS in browser)
builder.Services.AddSingleton<IAsyncFS, AsyncFSFileSystemDirectoryHandle>();

// WebTorrent services — start with the app via IAsyncBackgroundService
builder.Services.AddSingleton<ServiceWorkerStreamHandler>();
builder.Services.AddSingleton<WebTorrentClient>();

await builder.Build().BlazorJSRunAsync();

<script src="webtorrent-sw.js"></script>

// Any page or service — inject the singleton
@inject WebTorrentClient Client

// Download a torrent
var torrent = await Client.AddAsync("magnet:?xt=urn:btih:...");

// Stream a video with seeking
var url = torrent.Files[0].StreamURL;
// <video src="@url" controls></video>

// Or set directly on an element
torrent.Files[0].StreamTo(videoElement);

// Get a .NET Stream
using var stream = torrent.Files[0].CreateReadStream();
var buffer = new byte[4096];
var bytesRead = await stream.ReadAsync(buffer);
stream.Position = 1000000; // seek
bytesRead = await stream.ReadAsync(buffer);

// Seed data
var seeded = await Client.SeedAsync(myBytes, "model.onnx");
Console.WriteLine(seeded.MagnetURI);

Torrents persist across page reloads — pieces stored in OPFS, metadata restored on startup.

File API

Feature parity with the WebTorrent JS File API:

Wire Extensions (BEP 10)

Register custom wire protocol extensions that participate in BEP 10 negotiation — same pattern as JS WebTorrent's wire.use():

// Register before adding torrents — factory receives (swarm, wire), creates one per peer
client.UseExtension((swarm, wire) => new MyComputeExtension());

// Or on a specific swarm
swarm.UseExtension((swarm, wire) => new MyComputeExtension());

Create custom extensions by extending WireExtension:

public class MyComputeExtension : WireExtension
{
    public override string Name => "sd_compute";

    public override Task HandleMessageAsync(byte[] payload)
    {
        // Handle incoming messages from peers
        var msg = ParseMessage(payload);
        return Task.CompletedTask;
    }

    public override Dictionary<string, object>? GetHandshakeData()
    {
        // Include data in BEP 10 handshake (optional)
        return new() { ["capabilities"] = new List<object> { "gpu", "wasm" } };
    }

    public override void ProcessHandshakeData(Dictionary<string, object> data)
    {
        // Process peer's handshake data
    }

    public async Task SendComputeData(byte[] data)
    {
        if (!IsSupported) return; // peer doesn't have this extension
        await SendAsync(data); // sends directly through the wire
    }
}

Extensions are created per-peer via factory, registered before the BEP 10 handshake so IsSupported and RemoteId are set correctly. Use this for custom P2P protocols on top of the BitTorrent wire (e.g., distributed compute, AI agent communication).

Service Worker — Media Streaming with Seeking

webtorrent-sw.js ships with the NuGet package and deploys to your app root automatically. It:

1. Registers itself as a service worker
2. Adds Cross-Origin-Isolation headers (COOP/COEP) for SharedArrayBuffer
3. Waits for the SW to be ready, then loads Blazor
4. Intercepts /webtorrent/{infoHash}/{fileIndex} requests
5. Forwards range requests to the ServiceWorkerStreamHandler singleton via MessageChannel
6. Streams piece data back as a ReadableStream with proper 206 Partial Content headers

Health check: fetch /webtorrent-sw-check to verify the SW is active.

Quick Start — Server

using SpawnDev.WebTorrent.Server;

var tracker = new TorrentTracker();
var webSeed = new WebSeedServer("seed-data");

var app = WebApplication.CreateBuilder(args).Build();
app.UseWebSockets();
app.MapWebTorrentServer(tracker, webSeed);
app.Run();

Quick Start — HuggingFace Proxy

using SpawnDev.WebTorrent.Server.HuggingFace;

var proxy = new HuggingFaceProxy(new HuggingFaceProxyOptions
{
    CacheDirectory = "hf-cache",
});
app.MapHuggingFaceProxy(proxy);

// Clients access: https://your-server/hf/{repoId}/{filePath}
// Auto-caches from HuggingFace CDN on first request
// Generates .torrent files for P2P distribution

Demo Apps

Both demos connect to the same trackers and can P2P with each other.

BEP Support

15 BitTorrent Enhancement Proposals implemented:

See Docs/bep-support.md for full details.

Why This Exists

AI models are big. CDNs can't scale when every user downloads the same 2GB model. SpawnDev.WebTorrent turns every browser into a peer — the more users, the faster delivery. Built for SpawnDev.ILGPU.ML, the GPU-accelerated ML library for Blazor WebAssembly.

Architecture

Browser Client                    Desktop Client
+---------------+                 +------------------+
| WebTorrent    |                 | WebTorrent       |
| Client        |                 | Client           |
|               |                 |                  |
| WebRTC (P2P)<-+------+-------->+ SIPSorcery (P2P) |
| BlazorJS      |      |         | RTCPeerConnection|
|               |      |         |                  |
| OPFS Storage  |      |         | FileChunkStore   |
+---------------+      |         +------------------+
        |               |                |
        v               v                v
+-------------------------------------------+
| hub.spawndev.com                          |
| TorrentTracker (WebSocket signaling)      |
| WebSeedServer (HTTP range fallback)       |
| HuggingFaceProxy (model CDN cache)        |
+-------------------------------------------+

Documentation

Credits

Built by Todd Tanner (@LostBeard) and the SpawnDev team.

License

MIT