§ Docs
Docs
Everything you need to compose workflows, author extensions, and ship reproducible science.
Getting started
- QuickstartOpen a tab, compose a typed workflow, preflight the memory plan against your real device, train on your own GPU, and share a link that reproduces the result — six steps, no install, no account.
- Core conceptsThe load-bearing ideas: blocks and workflows, models in Model View, the IR ladder, declared effects and determinism tiers, hash identity, the database as the runtime — and the five grouping concepts, one axis each.
- Reproduce a resultSomeone shares a Scellis link. Open it and the run reproduces on your own device — inspect exactly what produced it, fork it, and commit your own version. The reproducible-by-URL claim, walked end to end.
Building
- Authoring extensionsAuthor ops, WGSL kernels, gradients, optimizers, viewers, connectors — the same author-check as the built-ins, trust earned per artifact via ConformanceReceipts, and reuse through a lockfile-pinned dependency closure.
- Training a model in the browserConfigure the full pipeline in Model View, get a memory plan and verdict before the first step, train on your own GPU via WebGPU — and resume exactly from content-addressed checkpoints, RNG state included.
- Data: files, connectors, and datasetsLocal files stream straight from disk; connectors are content that pull in everything else under credentials that never leave your device; ingress and egress are separate consents; datasets and their splits are versioned, content-addressed, and citable by hash.
- Packs, publishing, and trustThe whole shipping path: one envelope, a lockfile-pinned closure, a publication gate that names what is missing, device-held signatures, immutable versions, and delivery at the speed of a sync.
- ReproducibilityContent-addressed identity, dataset and split hashes, the provenance record every run writes, declared determinism tiers — and exactly what “reproducible by URL” promises, stated honestly.
- Scripting Scellis: the API and the CopilotOne typed API under the interface, the Copilot, your scripts, and external agents over MCP — full power behind consent, the caller class server-derived, and money structurally out of reach of every machine.
Together
- Live collaborationLive cursors, co-editing, shared runs, and comment threads — collaboration on Scellis is strictly additive: solo work is never blocked, offline edits reconcile, and only a committed version is citable.
- Workspaces, repositories, and sharingRoles and policies that bind server-side, curated version-pinned shelves, grants, share links, seat-pooled entitlements, and change proposals — one instrument per axis, never conflated.
- Distributed compute: pools, jobs, and trustOne mechanism — content-addressed jobs partitioned into shards, executed by a pool, combined by a declared reduction, verified before acceptance — under three trust regimes, with the scaling limits stated plainly.
- The marketplace: buying, owning, sellingThree layers — the Catalog is what you have, the Registry what exists, the Marketplace what to get. Buying that settles server-side, ownership that survives de-listing, and honesty about bytes on your device.
Under the hood
- The engine is a microkernelWhy the app ships only a small engine and every capability arrives as content — dependencies that point one way, a versioned compatibility contract, loud refusal, back-compat guaranteed by a re-executed corpus, and atomic offline-safe updates.
- From canvas to WebGPU: the IR ladderHow a drawn workflow lowers rung by rung to WGSL running in your tab — memory settled before a run, three declared determinism tiers, honest cross-GPU tolerances, and trust earned against a CPU reference.
- The database replaces the filesystemOne delivery path, four conceptual layers, content identity by hash, git-as-truth for built-ins, demand-fetch at scale, offline-first writes that sync in the background — and why a shared link resolves the same bytes anywhere.
- Local-first, verifiable, and honest about itConsent-gated egress, a derived CSP allowlist, client-side credentials, signed Packs, crypto-shredded erasure, an accounted federated privacy budget, and the consent tiers every caller is measured against.
- One API, three kinds of callerThe API-first verb surface behind the UI: one typed service the UI, the Copilot, and external agents all call; server-enforced consent tiers and an unforgeable caller_class; the MCP projection derived from the verb registry (in development); money barred at two layers.