Real infrastructure.
We run on it too.
ndexr is live high-performance computing we built from the kernel up — and ndexr.io itself now runs on it : the same validated R and reproducible stack we hand you. Sign in and it's yours — yourname.ndexr.io , your own cloud, an HPC session, or the validated Posit plane. Every version saved, and it rebuilds exactly.
The same stack we run our own production work on — open for you to build on.
Real software, built with AI — and reproducible by default.
Describe what you want and it gets built on live infrastructure — not a mockup, the real thing at your own address. Every version is saved and rebuilds exactly, so the work carries the provenance that serious and regulated projects depend on.
Real, validated infrastructure
We run on it every day. So can you.
ndexr isn't a sandbox — it's live high-performance computing, and
this very site runs on it
: ndexr.io serves from R built by our own stack (
ml R/4.6.1-foss-2024a
), not the operating system's. The whole software
stack is compiled from source, cryptographically signed, and distributed so every machine
runs the exact same bytes, checked on every read. That's lab-grade reproducibility —
on by default, for everyone. It's all public; here's the machinery.
Platform layers
Four ways to run on the validated stack.
However you like to work, you land in the same reproducible environment. Bring your own cloud, attach to a server you're already running, open the interactive HPC portal, or publish into the validated Posit plane.
The mission
Reproducible software, all the way down.
A company I worked for once paid my whole year's salary for analytics software I'd just rebuilt myself. Everything since has chased the same three things — speed, reproducibility, accessibility — with R and Shiny at the center.
Now: build the whole toolchain from the ground up — R, Python, Rust — then all of CRAN and Bioconductor on top, as validated software. Connect to our server and reproduce the entire environment on the spot. From there, we all just share servers.
Two ways to get the stack
Start an instance at
aws.ndexr.io
with your own AWS keys. The validated environment is already there at boot, so
module load R
works the moment you log in — nothing to compile or install.
Live now at the OnDemand portal : sign in, pick RStudio, Jupyter or a shell, and your session starts on a Slurm-scheduled node in your own validated space — the same reproducible environment, nothing to set up. The convenience of a hosted notebook, on real infrastructure.
Or publish to the validated Posit plane →Who it's for
Research & analysis
Reproducible pipelines, dashboards, and reports in R and Python — built on the same validated toolchain every time, so results still hold when someone reruns them.
Regulated & validated work
Audit trails, pinned dependencies, and documented build provenance. Every version is on the record — the accounting that GxP and other regulated environments require.
Learning by building
Want to understand how scientific software gets made? Build something real, watch every decision get recorded, and learn the patterns by using them.
How it works
Describe your idea
Describe what you want in plain words. Half-formed is fine. It can be a game, a tool, a form, a tracker — anything. Ask questions, get answers, figure it out together.
Watch it get built
It builds right in your browser, step by step — and every step is written down. You steer, you change your mind, you keep going. The real thing, not a mockup, with a record of exactly how it was made.
You own it
Your site lives at yourname.ndexr.io. Your data, your code, and the full history of how it was built. Walk away anytime — you take everything with you, and it rebuilds exactly the same, anywhere.
The architecture
Every domain is a workspace. One system serves them all.
Each domain carries everything you need to build it — a visual UI, a code editor, a terminal, a Git repo with releases, and an agent that can operate it for you. nginx routes every address into one Shiny app where each site is just a module, so a single repo already serves 120+ live domains . You add a module, not a codebase.
ide.ndexr.io
), a
terminal
on the box it runs on,
Git & release
(
git.ndexr.io
), and an
agent
that operates it on your behalf. Same domain, five doors.
app.r
— fan out to every domain. Each is a self-contained unit with its
own agent
,
isolated git
on a
dev-NNNN
branch, and a
release process
— and each reaches the rest of the
platform. Add a domain and nothing else changes; it's one more branch off the same entrypoint.
Your own space
Everyone gets a fully-validated HPC space.
The build ships the whole stack to a new server — the same validated bytes on every machine. From there, anyone can start in their own space. Validation is universal; your role only changes what you can reach, run, and manage.
|
Visitor
logged out
|
Member
signed in · free
|
Owner
paid space
|
Admin
platform
|
|
|---|---|---|---|---|
| Browse public sites | ||||
| Your own validated HPC space | ||||
| Build, install & run on the validated stack | ||||
| Custom domains of your own | ||||
| Invite & manage a team | ||||
| Operate the cluster & every space |
How the platform works
Capabilities on by default. Your work stays yours.
Nothing is rationed by plan or held behind upgrade tiers. The capabilities are on by default, what you build is yours, and you can export it and walk away whenever you like.
The usual model
- Priced per seat — the bill climbs with every person you add
- Private sharing and access controls locked behind upgrade tiers
- Custom domains rationed by plan: one, then five, then ten
- Your work lives on their platform
With ndexr
- No per-seat tax — share with your team, your customers, or the whole public
- Access controls and private sharing on from day one
- Bring as many domains as you want, all under one system
- Your code, your data, your repo — export it and walk anytime
For teams that need it inside their own walls
The whole platform, installed where you control it.
The reproducible, on-the-record builds everyone gets here are the same ones a regulated lab can validate. Everything that runs ndexr.io can run inside your own infrastructure — on-prem, air-gapped, or in your private cloud: many users and many applications under one validated install, where every version has to be accounted for.
Reproducible builds
Every dependency pinned, every image content-addressed. The build you validate is the build that runs — bit for bit, every time, on any node.
Many users, many apps
One platform serving isolated tenants. Each user gets their own apps, data schema, and access boundary. Scale horizontally across an HPC cluster.
Validation-ready
Designed for GxP and other regulated environments. Audit trails, deterministic deployments, and documented build provenance to support IQ/OQ/PQ.
The same platform we run in production — installed and validated inside yours.
Talk to us about a private installGet started
What do you want to make?
Describe it in plain words. It gets built on the real thing — and it's yours.
Get startedBuild on the same stack we run our own work on.