§ Platform / Reproducibility
Reproducible by URL.
Identity is a hash: workflows, models, datasets, checkpoints, and runs are named by their content, immutable by version. A committed result is citable by link — and the link re-resolves the same bytes, the same program, the same recorded engine and declared precision. Reproducibility is not a feature here; it is the naming scheme.
Named by content, not by location
Every artifact in Scellis — a workflow, a model, a dataset version, a checkpoint, a figure — is named by the SHA-256 of its bytes. Bytes at a hash never change, and a published version is immutable: a change is a new version that coexists with the old instead of overwriting it, so what you built on stays exactly what you built on. The naming scheme the catalog delivers content by is the same one your results are archived under.
That discipline runs deeper than convenience. The same content mints the same name on every device, offline or synced, because each kind of thing is written down in one canonical form before it is hashed. Identity, storage, sync, and citation all ride one database spine: the reason a link can promise what a filename never could.
Every run carries its own record
| Component | Pinned as | Why it matters |
|---|---|---|
| Program | every compiled stage | Not just the workflow you drew, but each stage it became on the way to the GPU — every one of them named by content, and open to inspection. |
| Data | dataset id@version | Exact dataset versions — including the train, validation, and test splits, which are versioned artifacts in their own right. |
| Weights | checkpoint hash | Weights, optimizer state, randomness state, epoch, step, metrics — one bundle; resuming is structural, not a feature. |
| Randomness | seed + counter | A counter-based generator with named streams — the same seed and counter give the same draw, anywhere. |
| Engine | engine 1.4.2 | The exact engine that executed the run — recorded so results outlive releases. |
| Precision | debug · prod · fast | The precision you chose is carried with the run — explicit at every stage, never a silent default. |
Every hash in the record verifies on fetch: anything that fails verification is treated as corruption and refetched — never silently substituted.
Every execution produces a record linking everything that determined it: the workflow you drew, every stage of the program it compiled to, the exact dataset versions, the checkpoints, the outputs — each named by content — plus the engine version and the precision it ran under. Cite the commit, and anyone you share it with can re-run the work, or verify that they did. A training run's identity is not a note in a margin; it is the record.
The details that usually escape are pinned with the same seriousness. Train, validation, and test splits are versioned artifacts referenced by hash — the exact split behind a metric is reproducible, not approximately remembered. Randomness is counter-based and part of every checkpoint, so a resumed run continues the same stream instead of starting a new one. And datasets themselves are versioned: same data, same hash, same run.
Ask the graph in both directions
Provenance here is not a log you scroll. It is a graph over content-addressed artifacts with produced-by and consumed-by edges you can query. Ask forward — everything ever derived from one dataset version. Ask backward — what data trained this model, through which program, on which engine. When a result surprises you two weeks later, the answer is a query, not an archaeology project.
Because the record is complete, experiment tracking is not a second system you have to remember to feed: the runs, artifacts, dataset versions, and checkpoints already are the record, and comparisons or dashboards are views over it. Run history is durable and survives the session, surfaced in your Workbench — and a shared model's card states its evaluation metrics together with the hash of the split they were computed on: a claim a reader can check rather than take on faith.
You collaborate on a draft; you cite a commit
Reproducibility survives multiplayer because identity refuses to look at it. In a live session — cursors, presence, half-finished edits, run telemetry streaming to the people you are working with — nothing is ever hashed. Identity begins at the commit, and everything before it is, honestly, a draft.
The hash depends on the committed content and on nothing else. A commit made alone and offline computes exactly the same name as one sequenced through a live session — the coordination server orders edits, it never owns identity. That is where this guarantee and local-first meet: the server can be down, the room can be empty, and a commit on your own device still mints the same citable name it would have minted in company.
What “bit-for-bit” means here
“Bit-for-bit” names the cited bytes: the URL re-resolves identical artifacts — the same weights, the same data, the same program — for as long as the reference exists. Running it again is a separate promise, calibrated rather than rounded up: bit-identical on the debug setting on the same device, and on the CPU reference path; across different GPUs, floating-point execution is not bit-exact, so a re-run agrees within the tolerance that was declared. Skipping that fact would be selling false comfort.
How exact a run is, is your explicit choice, recorded with it: debug for auditing, prod for deterministic work within a declared tolerance, fast where a freer ordering is declared safe — never a silent default, at compile time or at run time. The tolerances, the CPU reference that anchors them, and the conformance evidence that makes community kernels prove the same numbers all live with correctness.
A link a paper can stand on
Citation and embedding land through early access in exactly this shape — specified end to end, in development now.
| Surface | Carries | Guarantee |
|---|---|---|
| Repro deep link | the committed recipe | Opens the exact workflow in the Studio — the program, the pinned versions, everything it depends on — all validated before it opens. |
| Run snapshot link | a finished run's outputs | Metrics, figures, and what they were drawn from, as one committed artifact — durable, login-free, citable. |
| Embed | a read-only committed view | A hardened, isolated frame — no session, no writes, rate-limited; the identical response for every viewer. |
| “Cite this” | the citation record | Author, version, content hash, engine version, snapshot URL — projected to BibTeX, CFF, or CSL. |
| Remix (fork) | your own copy, lineage kept | The fork records where it came from; a reader without an account forks too, and claims the copy later. |
Every surface in this table resolves a committed, content-addressed version — never a live session, never a moving target.
Citation is designed in both directions. What you build carries the citations it stands on, and any committed result projects a citation record back out — author, name, version, content hash, engine version, snapshot URL — which a “Cite this” anchor renders to BibTeX, CFF, or CSL. DOI minting rides the connector system as a named forward path, and the architecture carries another: a “verified by re-execution” badge, earned when someone re-runs a result within its declared tolerance and countersigns it.
The loop closes where readers are. A committed snapshot renders read-only inside a hardened, login-free frame — no session, no writes, the identical response for every viewer — so a paper, a blog post, or a README shows the real figure resolved from the real record rather than a pasted screenshot. Two hatches keep it alive: “Open in Studio” and “Remix” — a reader without an account forks too, their copy staying on their device until they claim it. The guide walks the loop from the receiving end: reproduce a result, and from the authoring end: reproducibility.