Warppool runs your WGSL compute kernel across thousands of browser GPUs. You hand the coordinator a kernel and a chunk plan; it returns the reduced result with a per-chunk audit trail. Free for researchers; commercial workloads pay per millisecond of completed compute.
That's it. There's no SDK to install, no SaaS account, no provisioning step. Anything you can do with curl works.
A shader that takes a chunk's parameters in a uniform buffer, writes its output to a storage buffer. Standard WebGPU compute. If you've written a CUDA kernel, the mental model is identical; the syntax is closer to Rust.
A JSON document describing how the job partitions into chunks. The basic form is "N chunks, here's the parameter vector for each one." The coordinator hands one entry to each worker.
How to combine per-chunk results into one answer. Built-ins: sum, concat, max, min, argmax, topk. Custom: a second tiny WGSL kernel the coordinator runs on the assembled chunk outputs.
Default k=2 with a third opinion on disagreement. Higher k for higher-stakes runs; k=1 with a public canary frequency for cheap exploratory sweeps.
By default the coordinator pulls from the cheapest workers it can find. Add a deadline if you need the job finished by a specific wall-clock time; the scheduler will spend more credits to recruit faster nodes.
What a real submission looks like end-to-end — kernel, manifest, and the REST call. About 60 lines including comments.
@group(0) @binding(0) var<uniform> params: Params; @group(0) @binding(1) var<storage, read_write> hits: atomic<u32>; struct Params { seed_start: u32, num_samples: u32, samples_per_thread: u32, } // PCG hash — fast, good statistical properties fn pcg(x: u32) -> u32 { var s = x * 747796405u + 2891336453u; var w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u; return (w >> 22u) ^ w; } @compute @workgroup_size(256) fn main(@builtin(global_invocation_id) gid: vec3<u32>) { let tid = gid.x; var state = pcg(pcg(params.seed_start + tid)); var local_hits: u32 = 0u; for (var i: u32 = 0u; i < params.samples_per_thread; i = i + 1u) { state = pcg(state); let x = f32(state) / 4294967296.0; state = pcg(state); let y = f32(state) / 4294967296.0; if (x*x + y*y < 1.0) { local_hits = local_hits + 1u; } } atomicAdd(&hits, local_hits); }
# 1. Upload the kernel $ curl https://warppool.tech/api/kernels \ -F "src=@monte_carlo_pi.wgsl" > { "kernel_id": "wgsl-pi-7f3" } # 2. Build a chunk manifest — 100 chunks of # 100M samples each, distinct seed ranges $ python -c " import json print(json.dumps({ 'chunks': [ {'seed_start': i * (1<<24), 'num_samples': 100_000_000, 'samples_per_thread': 256} for i in range(100) ], }))" > manifest.json # 3. Submit the job $ curl https://warppool.tech/api/jobs \ -H "Authorization: Bearer $WARPPOOL_TOKEN" \ -F "kernel_id=wgsl-pi-7f3" \ -F "manifest=@manifest.json" \ -F "reducer=sum" \ -F "redundancy=2" > { "job_id": "job-9a2c", "queued_at": "2026-05-27T14:02:11Z", "chunks": 100, "est_seconds": 38 } # 4. Stream results back $ curl https://warppool.tech/api/jobs/job-9a2c/stream event: chunk_done data: {"chunk":0,"hits":78539701,"by":["w-3f1a","w-92e0"]} event: chunk_done data: {"chunk":1,"hits":78540234,"by":["w-441e","w-2bf8"]} ... event: job_done data: {"pi":3.14159265,"hits":7853981633}
The submit protocol is HTTPS and JSON; the worker protocol is JSON over WebSocket. Anything that speaks REST can submit a job. Enterprise customers running on a private pool use the same API, unchanged.
Compute is billed in milliseconds of completed work — one ms equals one millisecond of GPU time on a calibrated mid-range device (the M-series benchmark). You only pay for chunks that returned a verified result. Failed chunks, timeouts, canary chunks, and redundant re-runs cost you nothing. Researchers run free.
Anyone with a verifiable institutional affiliation — university, public lab, K-12 school, registered research org — runs free. No monthly cap; the only ask is that you don't be silly with it. Class projects, replication studies, exploratory grad work all qualify.
Embed the worker tag on your own site and every completed millisecond of visitor compute lands in your account. Spend it on your own jobs, or push it into the researcher pool. 1 GPU-ms in, 1 GPU-ms out — no transfer fee, no cut.
For commercial workloads, compute is metered at the millisecond and billed only when the chunk returns a result that passes verification. Failed, retried, and canary chunks are absorbed by the network. Indicative rate works out to about $0.04 per GPU-hour.
For teams that need an isolated worker fleet, a dedicated coordinator, regional data residency, or contractual guarantees we don't offer on the public pool — talk to us about a private deployment. Same API, same kernels.
Who ran what. When they returned it. Whether their answer matched the redundant runs. The submitter sees a complete trail and can replay any of it. You choose whether to make your job's log public.
Two-line description of your project, an institutional email, and a sample kernel. We turn most grants around in 48 hours. Commercial workloads can submit any time.