§ Platform
Draw a workflow and it runs on the GPU already in your machine — through training, through collaboration, through publication. This page is the map; every stop on it goes one level deeper.
§ In short
01
The browser talks to the graphics card already in the machine in front of you — Apple, AMD, Intel or NVIDIA, laptop as readily as workstation. Nothing to install, no CUDA, no cloud meter: training runs where your data already is. On a device with no usable GPU the same work still runs, more slowly, and the app says so rather than pretending.
02
Colleagues open the same workflow and work on it live, each on their own machine — and when one machine is not enough, many devices can take the job together: your own laptop and desktop, a partner lab's workstations, or an open pool of volunteers lending idle GPUs. Nothing a device sends back counts until it has been checked.
03
Every saved result carries the exact workflow, inputs and settings that produced it, so a link is enough for a colleague — or a reviewer — to re-run it on their own hardware, with the tolerance stated instead of assumed.
Open a tab and the GPU already in your machine starts working. You draw a workflow; the Studio turns it into GPU code and runs it on the device in front of you, so your data never has to leave and training is a real workload rather than a demo. Everything you compute with — blocks, models, viewers, connectors — arrives from the catalog as you reach for it, which is why new capability shows up without an install.
Every result you commit gets a citable identity: the workflow, its inputs, the engine version, and the run, pinned together into a link you can put in a paper, a message, or a README. A colleague who opens that link does not see a screenshot — the same computation re-runs on their hardware. And because the whole platform is driven by one set of commands, what you click, what a script calls, and what an assistant does on your behalf are the same actions under the same guarantees.
And a workflow is not confined to one machine, or to one person. The same drawn workflow can be edited live by several people at once while each participant's data and computation stay on their own device — and when one machine is not enough, the work splits across a pool of devices: your own laptop and desktop, a partner lab's machines, or an open crowd lending idle GPUs, with every returned result verified before it counts. A pool of one is an ordinary solo run on the same path, so nothing you build depends on anyone else showing up.
Seven commitments hold everything else in place — each one built into the architecture, most of them checked automatically.
| Parameter | Value | Note |
|---|---|---|
| Compute | your own GPU | The GPU already in your machine does the work — whatever make it is, with nothing to install — and every result is checked against a reference within declared tolerances. |
| Together | one workflow, many devices | Your own devices, a partner lab's, or an open crowd can compute one job together — verified before any result counts — and a pool of one is simply a solo run. |
| Capability | arrives without an update | New blocks, models and viewers appear in your catalog as soon as they are published — nothing to install, and never a bulk download. |
| Identity | content-addressed | Work you commit carries an identity you can cite and re-run — a link, not a screenshot. |
| Training | first-class | Autograd, optimizers, schedulers, PEFT, mixed precision — in the tab, not beside it. |
| Access | click · script · assistant | Every capability is reachable all three ways, with no second-class route — one surface, full parity. |
| Cost of compute | never metered | Local computation is free on every plan — a rule of the architecture, not a limited offer. |
Draw, run, train, inspect — alone, at full power.
Everything one person needs to get from a blank canvas to a trained model and a result worth citing — with an assistant that holds exactly the tools you do, and nothing leaving the device unless you say so.
Where Scellis stops being a single-player tool.
Many people on one workflow, and many devices on one job — your own machines, a partner lab's, or an open crowd lending idle GPUs — while every participant's data and computation stay on their own device, and no returned result counts until it has been verified. It is not only for training: a parameter sweep, a Monte-Carlo run, or a batch analysis pools exactly the same way.
Not policies — construction.
Each promise below names the mechanism that keeps it — and it is the mechanism, not the promise, that gets checked. Where a guarantee has an edge, the edge is written down in the honest limits register rather than left for you to find.
The deepest bet: what you build here is not a second-class citizen.
Content you write runs through the same checks and the same dispatch as ours, down to GPU kernels and gradient rules — and the terms under which each layer is published, along with what the platform cannot do, are set out in plain language rather than in a footnote.
If you want the feel of it, the quickstart takes you from a blank tab to a committed first run. If you want the mechanics, the docs go from the core concepts all the way down to how a drawn workflow becomes GPU code. And if you want the terms, pricing is a single page with one rule at the top: local computation is never metered — on any plan, ever.