§ Platform / Local-first
Your data stays on your device.
Working locally is the default, not a mode: data loads into your browser's memory on your own machine, the computing runs on your own GPU, and nothing reaches the network unless a block asked for it and you allowed it. The server makes sharing and working together better; it is never needed to compute.
Nothing crosses without your say-so
Every workflow runs inside a boundary you can point at: the device in front of you. Datasets load through connectors into your browser's memory, transforms and training run on your own GPU, and results land in a database that lives on your machine — a complete scientific loop with no server inside it.
The engine is pure by default: a block that wants to reach the network has to say so, and you are asked at the moment it matters. There is no background telemetry, no quiet upload, no fine print. What leaves the device is exactly what you allowed — and nothing else.
One first visit, then as long as you like
| Activity | Network | Note |
|---|---|---|
| The first visit | once, seconds | Fills your local database with the engine and the content you use. |
| Computing & training | never | WebGPU on your device — no cloud GPU, no queue, no meter. |
| Everything you already have | never | It is read from the database on your own machine, for as long as you like. |
| Finding new published content | online | Fetched from the catalog when you ask for it — never a bulk download. |
| Sharing & working together | online, optional | The server coordinates sessions; it never runs your work. |
Offline is the tested default, not a degraded fallback — a missing connection is an ordinary working condition here.
The first visit fetches a minimal working set — the engine plus the content you actually use — and fills a complete database inside your browser, in seconds on an ordinary connection. From then on, everything you have runs fully offline, for as long as you like: draw, run, train, inspect, version.
Only finding new published content needs the network. Syncing takes whatever chance it gets — local changes wait locally and reconcile when a connection returns — so a train, a plane, or a locked-down lab network is a normal place to work rather than an error state.
Pure by default, explicit when not
Anything that reaches outside the device — fetch a URL, read a bucket, send a message — is an effect: the thing that uses it has to declare it, and the declaration is carried up through everything that calls it. Before a run you see the complete set of effects the whole workflow can produce, so a block that claims to be pure cannot smuggle a network call in through something it depends on.
What you allow is exactly what was asked for, and you can take it back afterwards. Workspace policies can pin stricter rules for a whole team — useful when the data in the room is not yours to improvise with. The same discipline covers everything users write themselves, because what you write and what we ship run through one identical path.
Keys that never leave your hands
Connector credentials — tokens, API keys, bucket secrets — are encrypted with a key bound to the device and stored only there. They are never synced, never written into the record of a run, never visible to us. Scellis cannot leak a token it never sees.
Even the way a service is connected is ordinary content: the sign-in providers are written specifications whose permissions are checked for minimalism before they reach the catalog — how data enters and leaves is part of the substrate you can read, not a black box. The details live with data and connectors.
Privacy you can check, not just believe
Scellis is built in Germany, under European privacy law, and the strongest property it has is structural: what never leaves the device never needs a processing agreement. Access, export, and erasure are product features rather than support tickets — personal artifacts are encrypted under a key belonging to the person, so erasing really erases.
We say precisely what we can and cannot see: the hosted parts — accounts, sharing, session relays — run on named infrastructure providers, and your raw data does not pass through them. Where a guarantee has a boundary — in pooled computation, model updates do leave the device by design — we publish the boundary in honest limits rather than rounding it up. The full posture lives on security.
Where local-first pays off
On managed fleets and locked-down institutional machines, a browser tab is often the only thing you are allowed to start. Scellis turns that constraint into the way it is delivered: no install, no admin rights, no data leaving the building — while training still runs on the machine's own GPU.
It changes what you can work on at all: data you may not upload becomes data you can still analyse. When several people edit one workflow, live collaboration shares the edits and who is where — not your datasets. And when devices pool their compute, exactly what a pool exchanges is stated, cohort by cohort. Because the work runs on hardware you already own, it is never metered — on every plan, including none at all.