PyTorch's shape,
in a browser tab.

Embeddable · no server

Drop a live model into any page — one line

Everything you just ran can live on your blog, your docs, your course — an iframe, no server, no sign-up. It trains in the reader's browser, on their GPU. Like a Gradio demo, minus the server.

Press Run inside a frame above — it trains right there. The Copy button hands you the one line to paste; change nothing. A widget on a browser without WebGPU says so in a sentence rather than breaking. See all widgets →

Start here

Two doors in — by where you're starting from

New to machine learning, or arriving with PyTorch already in hand? Take the door that fits. Both run entirely in this tab, with nothing to install.

Or browse everything — six ways in, every one of them running in the page:

All four are the same runtime. A lesson block, a tutorial block and the playground editor run identical code — the difference is how much of the page is prose and how much is yours.

Start the lessons → Or build something Check your GPU

Why borch

What disappears when the browser is the runtime

Python ML charges you before you start — virtualenvs, version conflicts, CUDA and cuDNN, and one more server in front if you want it on the web. borch deletes that line.

How it works

Four hops become two

What your platform asks for before this will run — nothing on macOS, iOS or Android, two Chrome switches on Linux with an NVIDIA card, and two cells still marked not measured. The page that carries the measurements, and what to do in each case, is here.

Same kernels, Python surface

Run textbook code in the browser by changing one import

The playground has a Python mode. borch_webgpu on Pyodide calls the same WGSL kernels, so the losses match the JavaScript examples digit for digit. Pyodide and numpy are served from this repository — nothing leaves the page.

import borch_webgpu as torch

model = torch.nn.Linear(1, 1)
opt = torch.optim.SGD(model.parameters(), lr=0.1)
crit = torch.nn.MSELoss()

for step in range(201):
    with torch.scope():          # the one line the browser adds
        opt.zero_grad()
        loss = crit(model(x), y)
        loss.backward()
        opt.step()

The first run spends a few seconds loading Pyodide; after that it starts immediately. The Python page covers the surface in full — how it forwards names, what loading it costs, and where it stops. The playground carries five Python examples — tensors, autograd, linear regression, an MLP and a CNN — and lesson 6 runs the same training loop in both languages.

What exists · what does not

The long refusal list is the point

The goal is not "reproduce PyTorch" but equivalence within the range a curriculum uses. The table below is the current state, not a plan — what is missing is written as missing.

Four packages, one runtime

It is not one library any more

Each has a seat you already know, except the last one, which has no equivalent on the Python side.

The last row is the one with no counterpart. torch.hub fetches from repositories and keeps no catalog; timm has the catalog and does not publish manifests. Here a model arrives with a sample it has to reproduce, and your browser checks that before it says the model loaded.

Download a model and verify it →

It costs about ten megabytes and finishes in a couple of seconds. Nothing is installed.

Only what was measured

How fast · how correct

Measured 2026-09-22 with 0.6.0 as published: the training step is 4.5–10× faster than TF.js, 2.8–7.5× than jax-js and 14–18× than Burn — every library that trains in a browser on WebGPU — and the captured inference forward is ahead of ONNX Runtime Web on three adapters, for a ResNet and a ViT. The whole comparison, same page and same GPU with the adapter beside every number and the losing rows kept, is on the Compare page. Below: the earlier tables, kept as they were measured, and the matmul underneath within a whisker of torch on the same Metal GPU. The parity and golden runs are below in full; the speed tables — machine by machine, down to the dispatch — are folded so they do not wall the page.

Checked against real PyTorch

On top of that, 4764 golden cases hold all three implementations to the same expected values. Real torch cannot run in a browser, so the expectations are frozen natively and carried in. Golden matches on Apple Metal — agreeing 4753 / 4753 [apple / metal-3] — and on NVIDIA too: 3880 / 3880 [nvidia / blackwell] on an RTX 5080, in a real desktop session rather than a virtual framebuffer, measured on 2026-08-30 when the table held 3880 through the binding. The training agrees as well: thirty steps of a small ResNet, its per-layer gradients, its batch-norm buffers and its eval, against torch — 64 values, once through the Python binding and once through borch.ts's own API. The run that was read as a second vendor for months was not one. It passed 845 of 845 on a Linux GPU server whose adapter reported google / swiftshader — the CPU. The values were right and the vendor claim was not, which is why the runners now judge the adapter instead of printing it.

Five packages, and three of them share this name

Pick by where you intend to run

The first row said borch (PyPI) until it was checked. The distribution is named pyborch; borch is what you import. And it is not on PyPI — borch there is somebody else's package, a probabilistic-programming library, so pip install borch fetches a stranger's code. The wheel below is the install.

The npm row said borch too, and that package did not exist — the registry refused the name for being too close to borsh, batch and touch. It is published as borch-ts, which is what this repository has called it all along.

npm install borch-ts

import { init, Tensor, nn, optim, scope, keepAlive } from "borch-ts";
await init();

uv add ./pyborch-1.4.0-py3-none-any.whl

import borch as torch          # changing the import is the whole change
import borch_webgpu as torch   # on the GPU, inside Pyodide

Build AI where your users already are — in the browser.

No install, no server, no account. One tab is enough.