§ Platform / Studio
Draw your computation.
In the Studio, the drawing **is** the program. Compose data preparation, statistics, simulation, and machine learning as one workflow whose wires carry real shapes and types — so a mistake is caught while you draw it, not forty minutes into a run. Press run, and it executes on your own device's GPU.
A drawing becomes real GPU code
What you draw is a real program, not a picture of one. The canvas compiles the same way every time — an ambiguity is rejected early, with a precise diagnostic instead of a surprise at runtime — and what comes out the other end is code running on your own device's GPU. No install, no cluster, no upload: the machine you already own does the work.
Nothing between the drawing and the GPU is a black box. You can open every stage in between — the plan your workflow became, the memory it was given, the code it dispatches — which is what makes training in a browser tab debuggable rather than magical. The vocabulary underneath it is laid out in core concepts, and the compile path itself in from canvas to WebGPU.
Blocks are the unit, wires carry the data
| What a block declares | Up front | Why it matters to you |
|---|---|---|
| Inputs & outputs | what it takes, what it returns | A wire only connects where the two sides agree. |
| Reproducibility | how exactly it repeats, and how it differentiates | Sameness is declared, never guessed. |
| What it touches | network, storage, other devices — nothing by default | Nothing reaches the network or your files unless it said so, and you agreed. Local-first. |
| Larger-than-memory data | streams in chunks, against a declared budget | A dataset bigger than your RAM is ordinary work, not a rewrite. |
| Version | an exact, immutable release | New versions coexist with old ones; nothing shifts underneath you. |
| Provenance | who made it · citations · license | Every card in the catalog is complete — for people and for the assistant alike. |
The same contract validates what we built and what you built — one check, one path, no privileged blocks.
Every node on the canvas is a block: a versioned contract that states, up front, what it takes in and gives back, how exactly it reproduces, how it behaves when the data outgrows memory, and whether it touches the network or your files at all. Wires carry the actual shape of the data, so a workflow either composes cleanly or tells you exactly why it cannot — while you are drawing it, not at minute forty of a run.
Blocks nest: any workflow can be packaged as a block and reused inside a larger one, and anything you or anyone else has built drops in like a library import — found in the catalog, pinned to the exact version you chose, and stable while its source moves on. A sketch grows into a system without ever being rewritten.
Control flow is drawn — and budgets come first
A workflow is not a straight pipe. Conditions, loops, and running sums are structures you draw, compiled like everything else — a training loop or an iterative solver is part of the picture, not a script wrapped around the edges of one. And when the data outgrows memory, the run streams: the work is cut into chunks against explicit memory and storage budgets.
Nothing is allocated until the planner has checked the whole memory plan against your actual device and returned a verdict — green runs, yellow runs with warnings, red is refused up front with concrete fixes attached. You never discover an hour in that the run was never going to fit. What that looks like for a real training run.
Four modes, one palette, zero dead ends
The Studio is an instrument panel around one canvas: the catalog on the left, the inspector on the right, output and the assistant below. Four modes cover the whole arc — the workflow you are drawing, Model View for a model's internals, browsing for what exists, and home, the shelf of everything you own. Double-click a model node and the canvas becomes the full-screen editor for it; press Escape and you are back where you were.
A Cmd-K palette holds every action the product has, in one searchable list — the same list the Copilot works from, so anything you can click you can also simply ask for, and the assistant can never lag behind what the product can do. Undo is first-class, and belongs to each person separately in a live session.
The Studio refuses to lose your work or strand you: drafts autosave to the device, so a tab crash never costs unsaved edits; every surface has a designed loading, empty, and error state; and one fault in one panel never takes the whole app down with it. A screen that spins forever, or dumps a stack trace at you, is treated here as a defect.
Seeing is computing
A chart here is not a picture — it is a viewer: a versioned entity bound to typed data, as forkable and as buildable-by-you as any block. The Studio's visualization system, being built into early access now, is specified down to its limits: chart windows that float, dock, pin, or pop out into their own browser tab; live channels that carry a run's metrics as it trains; and thinning that is never silent — a curve drawn from fewer points says so, instead of impersonating the full stream.
Figures are made to be cited, not merely admired: a snapshot pins the data it was drawn from, the viewer that drew it, and the engine version — so what you publish regenerates instead of surviving as a screenshot with a lost past. Live state, by contrast, is never pinned: you collaborate on a draft, and you cite a commit.
Prose stays with the graph. Notes anchor where they belong — to a node, a wire, a region, or nowhere in particular — travel with the document, and never change what the program is. Comment threads carry @mentions and a resolved flag, in a live session and offline alike; if the thing a note pointed at disappears, the note becomes a loose pin you can re-attach, never a deletion.
It keeps up with you on an ordinary laptop
| What you do | What it costs |
|---|---|
| Pan and zoom a 96-layer model | 60 fps |
| Click a node | < 1 ms |
| Change one node | < 5 ms |
| Redraw the whole canvas | < 16 ms |
| Edit a model and see it re-checked | < 100 ms |
Measured on an ordinary laptop, on every release — a target the canvas misses is a bug, not a footnote.
A model with ninety-six layers pans and zooms at full frame rate on a normal laptop, a click lands under a millisecond, and an edit re-checks itself before your hand leaves the mouse. These are targets the canvas is held to and tested against on every release — not aspirations — because an instrument you think with has to keep up with the thinking. How the canvas hits these numbers.