§ FAQ
Frequently asked questions
The questions people ask before they trust a new instrument — answered straight, limits included.
Availability
Can I use Scellis today?
Not yet. The engine — the part that does the computing — is built and verified on real hardware; the studio around it is still in development, and no public release has shipped. There is no waiting list to game and no beta key to chase: write to us and you will be among the first to hear when the doors open. Everything else on this page describes the platform as it is built to work — and where a surface is still being built, the page that describes it says so.
What already works, and what is still being built?
Working and exercised on real hardware: workflows, training on the GPU you already own, the reference-checked correctness regime, the local database, versioned and citable results, workspaces, live sessions and pooled compute across devices. Still being built: charts and viewers, access for external AI agents, the connector inbox and triggers, the first-run template gallery, and the embed-and-cite surfaces. The roadmap puts them in order; honest limits names what will still be true after all of it.
Getting started
Do I need to install anything or create an account?
No. Scellis runs in a browser tab — there is nothing to install, and you can author and run any computation without an account. An account adds the platform services on top: syncing, sharing, collaboration.
What hardware and browser do I need?
A browser with WebGPU support — the current major browsers ship it — and the GPU you already own: Apple, AMD, Intel or NVIDIA, on a laptop as readily as on a workstation. No CUDA, no drivers, nothing to install. On a device with no usable GPU the same work still runs, on a slower CPU path, behind a banner that says exactly that instead of hiding it — with large-model training honestly limited there.
Does it work offline?
Yes. Your first visit seeds a local database in seconds; after that one-time bootstrap, everything you have runs fully offline — authoring, compute, training, commits. Only discovering new content needs a connection.
Data & privacy
Where does my data live?
On your device. Scellis is local-first: computation runs on your hardware, and your data lands in a local database in the browser. Nothing is uploaded by default — network access is a declared effect you approve in advance.
What reaches your servers at all?
Only what you explicitly choose to sync or share — a workspace you join, a workflow you publish. Credentials for your own data sources never leave the device: encrypted locally, never synced. Data leaving the device is always a separate, named consent — never a side effect.
Is this GDPR-serious?
Yes — Scellis is built from an EU posture: data-subject rights are honored, and commerce ships with proper invoices and EU consumer rights. In the studio itself there are no third-party analytics at all, and product telemetry is opt-in and carries no personal data. (This marketing website is the one exception, and it says so in its privacy policy: it uses Google Analytics with every advertising feature off — decline once and measurement stops for good.) The larger point is structural: because your data stays on your device unless you say otherwise, most of the question never arises.
Pricing & tiers
What stays free forever?
The computation itself — unbounded, on your own device, with or without an account. It is a structural rule of the platform, not a promotional period, and pricing opens with it.
What exactly do paid tiers buy?
Only what runs on servers: hosted sync, sharing, live collaboration sessions, compute-pool coordination, team workspaces, priority support. Never the math — a tier changes what the platform does for you, not what your device may compute. The three rules that decide every price are on one page.
What happens to purchased content if I cancel — or if it is de-listed?
You keep it. Marketplace content is bought once and owned: the bytes are on your device and keep running like everything else you have. Cancelling a tier ends the services, not your content — and a pack that is later de-listed keeps working for everyone who bought it.
Compute & correctness
How do results stay correct on consumer GPUs?
Every GPU compute path is paired with a reference implementation and checked against it within declared tolerances; gradients are verified the same way. The honest limit: results from different devices agree within those declared bounds — they are not bit-identical across GPUs, and Scellis tells you which guarantee you are getting instead of pretending otherwise. How the reference and the GPU path fit together is in the docs.
Can I extend it — author my own compute?
Yes. Blocks, ops, kernels, optimizers, losses, viewers, models — all authorable from the interface, and structurally identical to the built-ins: what you write is looked up, validated and executed by exactly the same path a built-in is. Your GPU code is checked against a reference before it is trusted, exactly like the built-ins. The authoring walkthrough takes you through one end to end.
How does sharing and reproducing results work?
You commit a version, and the commit is content-addressed: its identity is a hash of what it contains. Share the link and it re-resolves the same program, the same inputs, the same declared precision — so a cited result can be re-run and verified, not just admired.
Working together
Do my collaborators need accounts?
A shared result opens with no login at all — a snapshot link resolves a frozen, verifiable version. Joining a live editing session needs an identity so edits stay attributable, but even a login-free visitor gets a stable anonymous handle and can co-edit. Accounts add services; they never gate reading.
What happens when the collaboration server is unreachable?
If you are working alone: nothing — composing, running, and committing never wait on a server. In a live session, ordering pauses gracefully: your edits keep landing locally and reconcile when the connection returns. No spinner, no lost work — collaboration is an enhancement, never a dependency.
Does pooling ten devices make training ten times faster?
Not in general, and Scellis says so. Work that splits into independent pieces — parameter sweeps, Monte-Carlo runs, batch analysis — scales close to linearly. Synchronized training is held back by the slowest participant, so it holds to roughly tens of stable devices. And federated learning scales statistical power — more participating sites, better models — not wall-clock speed. The table on the distributed-compute page states this per workload.
Marketplace & selling
Can I sell what I build?
The machinery is built for it: a listing prices one immutable release, a purchase unlocks delivery, and a "become a seller" application is reachable from inside the app. At launch, selling through the platform starts with the owner as the only seller — not because of the engine's licence (the exact licence terms are here), but because selling through us carries operational duties: identity checks, payout rails, VAT liability, refund exposure. Payouts arrive together with those checks and escrow. Opening it wider is a policy decision on a mechanism that is already seller-agnostic.
Can the Copilot spend my money?
Never. Money-moving actions are admitted by the server only from a human gesture in the interface, bound to a fresh single-use token — so a prompt-injected Copilot, a leaked API key, or a headless script still cannot buy, tip, refund, or raise a budget. The Copilot may browse, recommend, and install free content with your consent. This is structure, not a setting.
Is buying here EU-serious — invoices, VAT, my rights?
Yes — commerce is built from a German/EU posture: proper invoices, correct VAT treatment, strong-authentication checkout, an always-reachable cancellation button for subscriptions, and a buyer-initiated refund path. And what you bought is unlocked only once the payment actually settles — decided on the server, where no client can talk its way around it.
The Copilot
What can the Copilot actually do?
Everything the interface can do, through the same commands: search and explain, compose and edit workflows and models, launch and watch runs, write and resolve notes, summarize what happened while you were away. Reads are free; writes ask first; destructive actions ask twice. The exceptions are structural: it never touches money or your stored credentials.
Whose AI key does it run on?
It works from your first minute on an included starter quota — no setup. The steady state is your own key for the provider you prefer: it lives encrypted on your device, never on Scellis servers, and every model call is an explicit, consent-visible network effect. A workspace policy can block those calls entirely.
Can it keep working while my tab is closed?
No — and that is stated, not hidden: local compute lives in your tab, so unattended or scheduled runs are a deliberate non-goal of the local engine. What you get instead is an honest account of the gap: notifications collect what happened — a finished pool job, a comment, a new version — and the Copilot summarizes them when you return.