Device Dyno
shippedA single page that dyno-tests your own browser's silicon with real WASM/WebGPU compute loops and reports your "AI horsepower" in a tok/s-equivalent score, no model weights, no server, no account.
Approach
A hand-assembled WASM module (a tight f32 multiply-accumulate loop over a large buffer, written once in WAT and compiled offline to bytecode) is embedded as a numeric byte-array literal directly in index.html and instantiated with WebAssembly.instantiate at load, so there is no runtime build step. The CPU score comes from timing many iterations of that WASM loop over a fixed-size array and computing sustained GFLOPS. If navigator.gpu exists, a short WGSL compute shader runs a sizable buffer multiply-add on the GPU and is timed with queue.onSubmittedWorkDone(); if WebGPU is unavailable the GPU column honestly reads 'not supported' instead of a fabricated number. Both raw throughput numbers are converted into a 'tok/s-equivalent' using a stated, visible assumption (FLOPs-per-token for a reference dense 7B-parameter model: tokens/sec = sustained FLOPs / (2 * 7e9)), so the page never claims to be running a real model. A single index.html with inline CSS/JS is the only artifact because the whole point is that the measurement runs client-side with zero network calls; a bundler would add moving parts for no benefit here.
The source post
https://x.com/dev_yodev61400/status/2105809374086087088
Scoring
Pick
| surprise | 3 |
|---|---|
| demonstrability | 5 |
| self_containedness | 5 |
| honesty | 4 |
Magnitude's pitch is a local inference engine that profiles your hardware and auto-tunes kernels for it. We can't ship the real engine (it's a native CLI, needs compiled kernels we can't download in this sandbox), but the profiling idea converts cleanly into a client-only page: run real matrix-multiply and memory-bandwidth microbenchmarks in WASM/WebGPU, no model weights or network calls involved, and turn the raw numbers into a readable 'tok/s-equivalent' score with a short explanation of what was actually measured versus estimated. Every other candidate either fails outright on the stated rules (iCode is a terminal app) or fails self-containedness the moment you ask how the one interesting bit actually ships: Clef and Lev need real model weights or a hosted 27B/9B model we can't call without a paid key; WebBrain's whole premise is loading models client-side, which means a build- or load-time binary fetch that this sandbox's network restrictions will kill; Dots, OvermindLab and the DeepSeek runtime are all backend/training/harness products that can only be faked as a scripted mockup in a single page, which fails the honesty bar outright. Device Dyno is the only one left where the demonstrated capability is the literal thing running in the visitor's browser.
Review
| shipped | 5 |
|---|---|
| honest | 4 |
| worth_it | 3 |
| efficient | 5 |
No change: the gate passed on the first attempt, the build executor (codex) continued its clean streak, and NOTES.md's one real objection — navigator.gpu existing without a working adapter — was already handled correctly in-build (page shows 'unavailable' with an explanation rather than fabricating a GPU number), not left as an unresolved failure. Nothing here recurs across the available history, so there is no evidence-backed lesson or routing change to make.
Cost
| total | $0.1202 |
|---|---|
| xai | $0.1202 |
What it looked at
Overlayio open-sourced Dots** (long-horizon proactive agents) as a model-agnostic harness anyone can run locally or in-browser.
OvermindLab open-sourced** a full pipeline to train specialized agents on your own data and own the weights (smaller, cheaper, private).
iCode** – fully offline Apache-2.0 AI dev platform that turns your terminal into a live agent OS with memory, tools, rollback, and model switching.
DeepSeek released** its entire agent runtime open-source (MIT) where every part (model adapter, sandbox, loop) is a swappable plugin.
Cloudflare open-sourced Clef** (27B/9B decision model) that outputs structured probabilities from typed questions; 209 ms median latency with browser demo.
Magnitude** – open-source local inference engine that profiles your hardware first, then auto-tunes kernels for fastest model choice (up to 57 tok/s on M4).
Lev** – 4B-parameter open-source “tiny Jev” model released with Hugging Face weights and ready-to-run examples.
WebBrain** – self-contained browser demo that loads and runs multiple AI models entirely client-side with zero backend.
Gate
| pass | project directory exists — /Users/artax/code/builds/2026-10-02/project |
|---|---|
| pass | no build step needed — static project |
| pass | build output with index.html — /Users/artax/code/builds/2026-10-02/project |
| pass | index.html is a document — 28320 bytes |
| pass | local asset references resolve |
| pass | page loads without console errors |
Stages
| scout | grok · ok · 19.1s |
|---|---|
| pick | claude · ok · 109.0s |
| plan | claude · ok · 62.1s |
| build | codex · ok · 437.9s |
| gate | local · ok · 2.9s |
| publish | local · ok · 14.5s |
| review | claude · ok · 52.2s |
Notes
Omitted for lack of
None within the requested scope. A shared leaderboard and downloading or running real model weights remain explicitly out of scope.