§ Investors
Science that computes in the browser — on your own GPU, on your own data, with your colleagues.
Statistical and scientific computing is a multi-billion-dollar market whose incumbents change hands for tens of billions — Siemens alone spent about $15.7B on two of them in fifteen months. Separately, browser-native collaborative software has repeatedly earned a premium. Scellis sits where neither set does: a full training stack on the user's own GPU inside an ordinary tab, data that never has to leave the device, every result re-runnable from a link, and many people and devices computing on one workflow together. Each of those exists somewhere. The combination, delivered as one verified substrate, does not.
§ 01 · Thesis
The combination, not the trick
Training a model inside a browser is not new. TensorFlow.js has done it since 2018, on the older graphics path, and it has shipped no release in about twenty months; Teachable Machine trains three fixed toy tasks. What has not existed is a full training stack on the modern GPU path — automatic gradients, optimizers, schedulers, mixed precision, checkpointing, fine-tuning — running inside an ordinary tab on the machine in front of the user, as part of a substrate that user can extend.
Three properties complete it, and none of them is decoration. Because the computation runs on the user's own device, raw data never has to leave it. Because every committed result is addressed by its content, a run is reproducible from a link: a colleague who opens it re-resolves the exact workflow, inputs, and engine version — not a screenshot. And because work can be split, sent, and checked, many people and devices compute on one workflow together, from a pair of laptops to an institutional consortium.
This is a scoped claim, and it is meant to be checked. Each condition on its own is met by someone: browser runtimes run models, cloud notebooks train on a server, desktop frameworks train on your machine after an install. As of mid-2026, nothing meets all of them at once — and the window is fresh, because the browser GPU standard that makes any of this possible only became available in every major browser in late 2025. Being first into that intersection is the thesis. It is not a permanent guarantee, and the risks section below says so plainly.
| Corner | What it means for the person using it | What it removes |
|---|---|---|
| Trains on your own GPU, in a tab | Open a link and train — the laptop you already own is the compute | A rented cloud GPU, an install, a driver toolchain |
| Your data stays on your device | Sensitive data can be analysed where it already lives, offline, with no account | Uploading a dataset to someone else's machine to compute on it |
| Every result re-runs from a link | A reviewer clicks the link and gets the run back — workflow, inputs, engine version | A screenshot, a methods paragraph, and an environment nobody can rebuild |
| Many people and devices, one workflow | Colleagues edit and run together; idle machines take a share of the work | Shipping the data to a central server — or not collaborating at all |
§ 02 · Why now
Five things that just became true
The browser got a GPU
In late 2025 WebGPU shipped in every major browser — roughly 84% of users now have a GPU compute interface by default. The capability that makes training in a tab possible only just became a safe assumption to build on.
The laptop is the workstation
Consumer GPUs — integrated and discrete — now carry real training workloads. The machine a researcher or a student already owns is capable enough to be the compute, not merely the client that talks to it.
Agents need an instrument, not a sandbox
As assistants generate and run code, checking the result becomes the bottleneck — and regulated or private data cannot enter a vendor's hosted sandbox at all. Scellis is driven end to end through one typed interface with named, consented effects: the auditable local instrument that layer is missing. This is also the section's sharpest threat, and it is in the risks below.
European data law is manufacturing the demand
Rules increasingly require sensitive data to be analysed without moving it, and the European Health Data Space sets a secondary-use clock for 2029–2031. That makes demand for computing where the data already sits a matter of policy rather than fashion — which is a more durable reason for it to exist.
Reproducibility is required but unequipped
Funders and journals now require analysis to be available and repeatable, while surveys show most researchers still have no tool for it. The obligation exists; the instrument is what is missing. Reproducibility is rarely bought on its own, though — it sells bundled into the compute, which is exactly how it ships here.
A window this fresh is also contested. Browser inference is commoditising quickly, and the teams that own it are one product decision away from adding training. The honest read: the timing is real, and it decays month by month.
§ 03 · The product
What is already built
Scellis is not a concept deck. The compiled application ships a small engine, and everything else arrives as content from a database: the blocks, the models, the GPU code. On that engine, five things are built and running today — the training stack; the compiler that turns a workflow you drew into code your GPU executes; live collaboration on one document; pooled and federated compute across many devices; and one typed interface through which the whole platform is driven, so the screen and the assistant have exactly the same powers. On top of all of it, what a user writes is held to the same bar as what we wrote — the engine cannot tell the difference at execution time.
The honesty is structural. Every piece of GPU code is paired with a reference implementation and must agree with it inside declared tolerances — including code a user wrote — so correctness is something a stranger can audit rather than something we assert. Two things follow, and both are stated rather than buried. First: Scellis has not launched — it is pre-launch, with no live users. Second: the surface that lets an outside AI agent drive the platform is a named next step, not something that ships today — the roadmap below is the single place its status is recorded, and no other sentence on this page may contradict it.
§ 04 · The field
Who else is on this ground
A moat argument without a named opponent is not an argument. Here is the field, and the point at which each of them stops.
| Who | What they do well | Where they stop |
|---|---|---|
| transformers.js · ONNX Runtime Web · WebLLM | Run large models in a browser tab, on the GPU, at real scale | They run models. Where a training path exists at all it is CPU-only and unmaintained — never on the GPU. Hugging Face is the most credible fast-follower here. |
| TensorFlow.js · Teachable Machine · DISCO | Genuinely train inside a browser tab — this has been possible since 2018 | A library or a fixed task, on the older graphics path; TensorFlow.js has had no release in about twenty months. |
| Google Colab · Kaggle | A browser front end onto free GPUs — how most classrooms train today | The GPU is Google's: an account, a quota that can end mid-lesson, an upload, and no offline. |
| MATLAB Online · jamovi Cloud | Full scientific and statistical tools, in a browser tab, for a decade | The compute runs on the vendor's server. This is exactly why 'browser-based' on its own is not the claim. |
| PyTorch · R · SPSS · Prism | The training and statistics that scientists actually use every day | An install, your own machine, one person at a time — and no run identity a link can resolve. |
| Flower · NVFLARE · TRE vendors | Federated learning and secure analysis rooms for institutions | Server-side frameworks built for engineers, not something a scientist opens in a tab. A channel to work with, more than a rival. |
The fast-follow question is the right one to ask, and the answer is not comfortable. A well-resourced team could add GPU fine-tuning to a browser runtime in months — Hugging Face most plausibly. Two things stand between that and this: reaching the breadth Scellis already has is a multi-year job, not a feature; and for anyone who rents GPUs, training that runs free on the user's own machine cannibalises revenue they already collect. Neither is a wall. Both buy time — and time is what the compound below is built with.
§ 05 · Market
The size of the ground, in public numbers
Only third-party public figures appear here — the markets this serves, what comparable companies sold for, and how much each number can be trusted.
The measurable markets
| Signal | Figure | Source, and how far to trust it |
|---|---|---|
| Statistical-software market | $8–9.5B (2024) | Analyst estimates. Reports on this market disagree by about 2× — directional only. Per-seat prices, which are knowable, corroborate the order of magnitude. |
| Lab and research-informatics software | ≈$4B (2025) | Industry analysts, anchored bottom-up: Dotmatics disclosed more than $200M of revenue in 2022 before its $5.1B sale. |
| People starting machine learning each year | ~10–20M / year | Bottom-up from course and higher-education enrolment; a proxy, not a census. |
| European sensitive-data obligation | 2029 / 2031 | The European Health Data Space secondary-use timeline — a legal date, not a forecast. |
| Users whose browser has a GPU interface | ~84% (Nov 2025) | Browser-support trackers — measured, and the single hardest fact on this page. |
What this class of company sells for
| Transaction | Value | What it was, and what it teaches |
|---|---|---|
| Ansys → Synopsys (2025) | ≈$35B · ~14× revenue | Simulation software |
| Altair → Siemens (2025) | ≈$10.6B · ~16× revenue | Engineering and data science |
| Dotmatics → Siemens (2025) | $5.1B | Scientific R&D software — the tools scientists work in every day |
| Alteryx → Clearlake / Insight (2024) | $4.4B · ~4.5× revenue | The distressed floor. Healthy sales in this class clear ~14–17× revenue; a business the market has lost patience with clears ~4–5×. |
| Overleaf | 25M+ users | Browser-native academic adoption converting into institutional licences — the bottom-up template |
| Figma | $749M rev. (FY24) · IPO 2025 | Browser-native collaboration earns a premium — and re-rates when it has to be proven: about $68B on day one, about $10–11B by mid-2026. Both halves belong on this page. |
Every figure above is a third-party public report, filing, or announcement, and each carries its own caution rather than only its upside. This page publishes no internal projection of Scellis's own numbers — that restraint is deliberate, and it is the same discipline the platform applies to a GPU kernel.
§ 06 · Business model
How a platform that gives compute away is a business
Scellis makes one promise its pricing can never break: computation is never metered. A person with no account can write and run any computation on their own device, without limit, on every plan including the free one. It is written into the architecture as a rule, not offered as a discount that can be withdrawn. That is not the business given away — it is the trust the business is built on.
What is sold sits around that free core, and every item on the list is something that happens when work leaves your device or enters an institution: hosted services — storage, sharing at scale, relayed and pooled compute capacity, collaboration seats; commercial-use licensing of the source-published engine; education and campus licensing; and consortium deployments on regulated data with validated content packs. Paid content controls *delivery*, never execution: once the bytes are on the device they run as ordinary, inspectable content, with no copy-protection claim attached to them.
The economics are structural. Because users bring their own compute, the marginal cost of serving a computation is close to zero — Scellis is not reselling GPUs it has to rent, and that is why the free plan is cheap enough to give away. And the route to market is a sequence, not one leap: teaching and individual adoption build the audience, regulated and consortium work buys the proof and the standing that comes with it, and that standing is what lets the substrate be adopted as a standard. Each stage funds the right to attempt the next.
One thing is deliberately not counted. The architecture can meter a compute market by verified work rather than by the clock, and the accounting for it runs today — but the public record of open GPU marketplaces does not support a business on it, so it carries no weight in this case and appears in no projection. It stays in the platform because pooling compute with people you trust is useful on its own.
§ 07 · Moat
Five assets that reinforce each other
Five reinforcing assets — and, in the same breath, what we concede.
The engine
The training compiler, the automatic gradients, and the hand-written GPU kernel library are the least copyable layer — years of engineering that a three-month demo does not reproduce.
Correctness as a public standard
Every piece of GPU code — ours and a user's alike — must agree with a reference implementation inside declared tolerances. The growing body of those checks is an asset that cannot be faked and that anyone, including a competitor, can audit.
Results that survive being shared
A run has an identity a link resolves, and models and datasets are delivered as signature-checked packs. It is the difference between sending someone a result and sending them the ability to obtain it themselves.
Compute that many people share
One workflow, many machines: work is split, sent, and checked before it is accepted rather than trusted — which is what makes a pool of strangers usable at all. The same mechanism runs across your own devices, an invited consortium, or an open pool, and federated learning is one configuration of it: many sites learn a shared model while the raw data stays on each of them. For institutions whose data cannot move, that is not a feature, it is permission to participate.
Content packs reach a new field
The revenue layer reaches any discipline with no engine change: a new regulated market is signed content, not a platform release. That is why one team can serve fields it does not itself understand.
Not one of these is uncopyable on its own — a well-funded team could clone any single corner in months, and the page on honest limits says so in as many words. The moat is the compound: an engine whose users write its very kernels, a body of correctness checks that turns being right into something anyone can audit, results that survive being shared, the consortium relationships that regulated work is built on, and the speed of a system that is coherent all the way to its foundations. A fast-follow copies a feature. It does not copy the compound.
What Scellis concedes, in writing: a browser tab does not win a race against a rented datacenter GPU, and it does not try to — raw throughput is conceded to the runtimes that specialise in it. The claims here are narrower and firmer: nothing to install, the user's own machine, offline operation, free local computation, results that re-run, and people who work together. Naming the limits precisely is what keeps the rest credible.
§ 08 · Risks
What would make this wrong
Five things a serious reader will find. Each is stated first and answered second, because finding them yourself after a page advertises its own honesty is worse than reading them here.
Demand for training in a browser is unproven
This is the sharpest of the five. In-browser machine learning has real and fast-growing demand, but almost all of it is for running models, not training them: the popular browser training library has been dormant for about twenty months. Scellis is ahead of its demand curve, which is also why the ground is uncontested. The answer: start where the alternative is nothing — teaching, locked-down institutional fleets, data that is not allowed to move — rather than trying to convert people with a working install who feel no pain.
AI assistants may absorb the workload
For exactly the tasks this platform demonstrates — load a table, train a small model, plot a curve — describing it in English and having code generated and run in a hosted sandbox is now one message away, free, with the whole scientific Python world included. The answer: when generation is free, checking the result becomes the bottleneck, and a disposable cloud sandbox has no memory, no provenance, and no way into data that is not allowed to leave the building. That is the instrument Scellis is — and that same shift is listed above as an opportunity, honestly, because it is both.
The window is contested, and it decays
Browser inference is commoditising, and the teams that own it are one product decision from adding training. Being first into the intersection is the thesis; it is not a guarantee. The answer: the compound in the moat above, and speed — which is why every month before a stranger uses this thing is a month spent, not saved.
The people who adopt fastest are not the people who feel the pain
Researchers who could switch tomorrow already have a working install and feel no pain; the institutions that feel it — regulated, behind an IT lockdown — buy on cycles of eighteen to thirty-six months and are cautious about a young supplier. Two different problems, with opposite remedies. The answer: teaching and locked-down environments carry adoption while consortium conversations run on their own long clock, started early rather than when the money is needed.
One author is both the coherence and the concentration
The engine is coherent to its foundations because one person designed and wrote it end to end. The same sentence is the largest single-point risk on this page, and no reader should have to work that out for themselves. The answer: building the team around the engine is precisely what the first outside capital is for, and the architecture was built to be handed over — every capability arrives as content through one checked path, which is the opposite of a system only its author can extend.
§ 09 · Team
Who is building it
Founder · CEO
Kemal İnecik
Machine-learning PhD researcher at Helmholtz Munich and the Technical University of Munich, building deep generative models in one of the world's leading AI-for-science labs. Author of more than ten machine-learning papers — in Nature, Cell, ICML, and NeurIPS among others. He designed and built Scellis end to end: the training compiler, the automatic-differentiation and GPU-kernel libraries, the correctness regime that holds them to a reference implementation, and the platform around them.
Co-founder · Science
Fabian J. Theis
Professor at the Technical University of Munich and Director at Helmholtz Munich. A Leibniz Prize laureate — Germany's most prestigious research award — and an ERC Advanced Grant holder, he is one of Europe's most cited scientists in machine learning for the sciences. His group pioneered the application of foundation models to scientific data, the closest methodological precedent to what a general, reproducible compute platform makes routine.
Scellis is built in Germany. The engine was designed and written end to end by its founder — which is why it is coherent to its foundations rather than assembled from parts — and the scientific judgment behind it comes from a decades-long research programme in machine learning for the sciences. That concentration is honestly stated in the risks above, and answered there. The full team page has the detail; the about page tells the longer story of what we are making and why.
§ 10 · Roadmap
From foundation to platform
Four phases, each with the horizon it runs in and the milestone that ends it. The horizons are intentions, not commitments — the milestones are what actually has to become true.
Foundation — now
The substrate: training on the browser's GPU, correctness checked against a reference, results that re-run from a link, live collaboration, pooled and federated compute, and one typed interface that drives all of it.
Ends when: a stranger reproduces a real training run from a link.
Launch and teaching — 2027
Public early access, the classroom motion, and the surface that lets an external AI agent drive the platform over the standard agent protocol (MCP) — the first capability on this page that does not exist yet. Aimed where the alternative to Scellis is nothing.
Ends when: people come back without being asked, and the first courses adopt it.
Regulated pilots — 2027–2029
One site, then a consortium, working on sensitive data with validated content packs under the trust regime built for exactly that: an invited, institutionally signed group. What is sold here is the shortcut through compliance and the network — not a protocol.
Ends when: one institution runs one real sensitive workload, with a named champion inside it.
The platform economy — 2030+
The content market turning, capability written by its own users compounding, and the substrate established as the reproducible, agent-drivable standard other people build on.
Ends when: capability grows without the core team — the wheel turns on its own.
§ 11 · FAQ
Questions investors ask
Isn't this just TensorFlow.js?
No, and the difference is the whole thesis. TensorFlow.js is a library: it trains on the older graphics path, on one device, with a fixed set of operations, and it has shipped no release in about twenty months. Scellis is a substrate: a full training stack on the modern GPU path, every kernel checked against a reference implementation, results that re-run from a link, live collaboration, pooled compute across many machines, and a catalog its users extend themselves. Training in a browser is the ticket to entry here. It was never the argument.
Why can't a big incumbent just copy it?
Any single corner is copyable in months — Hugging Face could most plausibly add GPU fine-tuning to a browser runtime, and we say so on the page rather than pretending otherwise. The compound is not: an engine whose users write its own kernels, a body of correctness checks that makes being right auditable, results that survive being shared, consortium relationships, and the speed of a system built coherently from its foundations. There is also a disincentive worth naming: for anyone who rents GPUs, training that runs free on a user's own machine eats revenue they already collect.
Why does pooled compute matter commercially?
Because it is what an institution is allowed to say yes to. A hospital or a research consortium cannot send its data anywhere, so the only way it can join a study at all is if the computation comes to the data and only checked results leave. Scellis does that as one mechanism — split the work, send it, check every result before accepting it — across your own devices, an invited consortium, or an open pool. Federated learning is one configuration of it. That is a permission to participate, not a feature, and it is what the regulated pilots are sold on.
Is this open source?
Not exactly, and the distinction is deliberate. The interchange ring — the specifications, the correctness corpus, the reference implementation, and the developer kits — is permissively licensed, so anyone, including a competitor, can verify every correctness claim we make. The engine is source-published under a fair-code licence: free for research, teaching, and personal and internal use. We never call the engine open source, because it is not, and [the licensing page](/platform/openness/) gives the exact terms rather than the warm label. Only the platform service and our own content packs are withheld.
How do you make money if compute is free?
Local computation is free on every plan by rule, and always will be. What is sold sits around it, and each item is something that happens when work leaves the device or enters an institution: hosted storage and sharing, relayed and pooled compute capacity, commercial-use licensing of the engine, education and campus licensing, and consortium deployments with validated content. Because users bring their own compute, serving a computation costs us almost nothing — the free plan is cheap to run precisely because the mathematics happens on the user's machine.
Why start with teaching?
Because that is where the alternative to Scellis is genuinely nothing. The honest version of this argument is narrow: a Chromebook can reach a cloud notebook, and that is how most classrooms train today. What it cannot do is get past a managed school fleet where administrators block or age-gate outside services for minors, where a free quota can die in the middle of a lesson, and where student data must not leave the school's jurisdiction. An on-device trainer that needs no account is the only option that survives all three constraints — and every shared link is an activation that costs nothing.
What stage is the company?
Pre-launch. The substrate is built and held behind automated verification, there are no live users yet, and the site treats the product as early access. The proof we care about in the near term is not a revenue line — it is a stranger using it voluntarily and coming back, plus one institution running one real sensitive workload. What we are looking for is the first outside capital to build the team around the engine and take it to those two proofs; the brief carries the shape of that conversation.
Where does user data live?
On the device. Local execution is the default, and any network egress is a separate, named, consented step — the platform never phones home. When many sites train one shared model, only model updates leave, never raw data; and because an update can still reveal something about the data behind it, that mode keeps a differential-privacy floor with clipping on by default, with the budget accounted for. 'Data never leaves' is true of the bytes. The information-level guarantee holds only with that floor engaged, and we say so on every page where it matters.
§ 12 · Contact
For qualified investors
The technical brief, the architecture documentation, the correctness corpus, and the company's current corporate, intellectual-property and licensing status are available to qualified investors on request. Write to invest@scellis.com and we will take it from there.