A pixel-art game for learning single-cell analysis. You take a project, walk a research institute from one stage of it to the next, poke at everything, and play each analysis step as a small hands-on puzzle. The aim is to make an abstract subject visible, and to have some fun on the way.
It is built for people who learn by doing: students, clinicians, postdocs, and anyone who has been handed a count matrix and a deadline.
Play it in your browser, or open index.html from a copy of this repository. There is nothing to install and no build step.
| Key | Does |
|---|---|
| ← → | Walk, and adjust the selected control |
| Space / Enter | Talk, read, poke, open doors, confirm |
| ↑ ↓ | Pick a control inside a room |
| Esc | Leave a room |
| G | Show the goals of the game you are in |
| L | Step out to the map of the institute, from any hall |
| M | Sound on or off (off by default) |
| F | Full screen |
Mouse and touch work for everything: click or tap a spot to walk there, click a thing to walk over and poke it, drag sliders and lines, and tap "Leave" to step out of a room.
On a phone the game is playable with taps alone. Held upright, there is a row of buttons under the screen, and a button that turns the game on its side: it then fills the phone at nearly twice the size, with a thumb pad at each end, and you turn the phone, not the page. That works with the rotation lock on. Held sideways, the screen fills the height and a thumb pad sits on each side.
Progress is saved in the browser. "Restart game" in the page header wipes it.
You start in the arrivals bay, where you pick a parcel. Nobody asks for a name: you are Ari until you print a badge of your own at the printer by the lift. Each parcel is a project: a question, and the samples to answer it with. Nobody runs every kind of single-cell analysis on one study, so the project decides which stages you go through. A road across the institute leads from one stage to the next.
| Project | Cells | Stages built | Still to come |
|---|---|---|---|
| Why do some patients respond? | Immune cells in blood | Core facility, the Cloud, the Bureau, the Laundry, the Weigh House, and the review in the Long Gallery | Who signals |
| How does a cortex build itself? | The developing brain | Core facility, the Cloud, the Bureau, the Laundry, the Marshalling Yard, and the review in the Long Gallery | Cell fate |
Every project starts the same way, because the data is made the same way. The two share their first four stages, each played on its own cells: T cells and monocytes in one, neurons and radial glia in the other. The fifth is where they part. Comparing patients is a question the blood project has, and the cortex project does not. The cortex project asks in what order its cells arise, and has a fifth stage of its own for that. Both end in the same place, the Long Gallery, where the project is reviewed. More tissues and more kinds of project are planned. To ask for one, use the request board in the game or open an issue.
Stage 1, the core facility: from a tube of cells to a clean count matrix.
| Room | You do | You learn |
|---|---|---|
| 1-1 Droplet bay | Choose how many cells to load, and across how many lanes | Doublets rise with every cell you load |
| 1-2 The Cliff | Separate cells from empty droplets on the barcode rank plot | A count cut-off is not enough; test each barcode against the ambient profile |
| 1-3 QC gate | Filter damaged cells by genes detected and mitochondrial share | Thresholds from a tutorial do not transfer; read lenient ones off the data |
| 1-4 Soup kitchen | Measure and remove ambient RNA | Use genes a cell cannot express; too much correction erases real signal |
| 1-5 Doublet hunt | Make artificial doublets, score the cells, pick a cut-off | Same-type doublets are invisible, and real transitions sit between clusters too |
| Reviewer 2 | Answer five questions about what you just did | Whether any of it stuck |
Stage 2, the Cloud: from a count matrix to a map you know how to read. This hall has no rooms. It is one hall with a glass pipeline along the wall. Your data rides the pipe from station to station, you walk beside it, and each finished station shows what the data looks like now on its monitor.
| Station | You do | You learn |
|---|---|---|
| 2-1 Leveller | Colour the cells to find what drives the picture, then divide by depth and take logs | Until you normalise, sequencing depth is the biggest difference between cells |
| 2-2 Gene picker | Choose how to rank genes, how many to keep, and whether to skip mitochondrial and ribosomal genes | Rank by variance above the trend; too few genes or too many both lose the rare cells |
| 2-3 Rotator | Turn an axis through two genes to find the widest spread, then choose how many components to keep | What a principal component is, how to read the elbow, and why too few is the worse mistake |
| 2-4 Neighbours | Choose how many neighbours each cell is linked to, and watch the neighbour graph redraw | Too few neighbours and a cell type falls into pieces; too many and a small population is absorbed |
| 2-5 Map table | Draw the neighbour graph as a flat map, draw it again from a new random start, and say what is the same in both | Which cells share an island can be trusted; the position, distance and size of islands cannot |
| Journal club | Your student presents your map. Nod at the fair claims, object to the rest | A UMAP is a map, not a result |
Stage 3, the Bureau: from a map to cell types you can defend. This hall is a detective's office built around one case board. Nobody knows who the cells are yet. The board on the wall fills in as you work: pins, then clusters, then marker genes, then names, then a stamp.
| Station | You do | You learn |
|---|---|---|
| 3-1 The Cut | Turn the resolution dial, then fix what one dial cannot: zoom into one cluster, or merge two | Resolution is a choice. Too coarse hides a group, too fine invents a split, and a split needs genes behind it |
| 3-2 The line-up | Move through candidate genes while the map lights up with each one, and pin the marker | A marker lights up its cluster and little else. A tiny p-value does not make one, and a cluster with no gene of its own may be doublets |
| 3-3 Name desk | Work down drawers of names, lineage to subtype, and file each cluster where the evidence stops | Check the genes a cell type should lack, go as deep as the evidence goes, and no deeper |
| 3-4 The Oracle | Pick a reference cartridge for an automatic annotator, then settle where it differs from the file | A good reference can refine a name. A cell type the reference lacks gets the nearest label, with confidence |
| The Chief | Answer five objections by presenting the right piece of evidence, or concede | How to defend each decision you made in the Bureau |
Each lesson in a stage has one home. The doublets, for example, are found at the line-up and leave the board there. No later station asks about them again.
Stage 4, the Laundry: more than one sample. The same kind of sample is run on Monday, on Thursday and again a month later, and no two runs come out looking alike. This hall is a laundrette under one washing line, which changes as you work: two runs pegged apart, then pegged together, then joined by a third.
| Station | You do | You learn |
|---|---|---|
| 4-1 Sorting table | Tie each island of cells to its partner in the other run by comparing marker genes, and leave the one island that has no partner | A batch effect is a shift every cell type shares. Look before you correct, and a cell type found in one run only is not a batch effect |
| 4-2 The Wash | The knob for Harmony's theta was left on its highest setting, and the wash looks finished. Switch the light to PPBP to see what that cost, then find the setting to take out | Too little leaves the runs apart, too much pulls real differences together, and the strongest wash mixes best. Mixing alone picks the wrong setting |
| 4-3 Lost and found | Sweep a lamp over a newly mapped run to see which cells carry the marker of the label they were given, and flag the group that does not | Mapping gives every new cell a label, including cells the reference has never held, and the neighbours all agree. Check labels against markers |
| The counter | Deal with three study plans from Vera, the group leader: swap tubes between runs, split a sample over both, and choose what to call the batch | Confounding is fixed at the bench. A bridging sample shows what the run alone does. Whatever is called the batch is removed, with all that changes with it |
Stage 5, the Weigh House: what changes. Twelve patients, six of whom responded, each sampled before and after treatment. This hall is an old public weigh house, with brass scales, weights and a wall of ledgers, and this stage belongs to the blood project only. Over every station hangs a small balance, which sits crooked until the station is done.
| Station | You do | You learn |
|---|---|---|
| 5-1 The Scales | Every cell is a grain on a two-pan balance, responders against the rest. Bag each patient's grains into one weight, read the needle again, and stamp three claims | Cells from one patient are not independent. Sum the counts per donor and cell type (a pseudobulk), and test donors |
| 5-2 Formula bench | Put tiles into a formula under a chart of every patient before and after, for three questions: what changed, what changed in responders only, and a formula that will not fit | The design decides what a test answers. Pairing removes what differs between patients, an interaction is a change that depends on the group, and a term the others already tell cannot be estimated |
| 5-3 The Stairs | Two hundred genes sorted by p-value. Choose a flat line, Bonferroni or the Benjamini-Hochberg ruler, and a rate, and see which steps light up | Testing many genes makes false alarms certain. Control the false discovery rate, and know what the other rules cost |
| 5-4 The Census | Pump cells into a copy of a jar until it matches the jar after treatment, then enter in the ledger what changed, and against what | Cell-type shares are compositional: when one cell type grows, the shares of the others fall with nothing happening to them. State changes against a reference |
| The read-out | Build one sentence for the clinic from tiles: who, when, which cells, what they do, and what that has to do with response | Say what the data supports and no more. Twelve patients show what goes with response, not what predicts or causes it |
Stage 5 of the cortex project, the Marshalling Yard: in what order. Tissue from three ages, and in every sample cells caught at each point of one process, from stem cell to settled neuron. This hall is an engine shed at the edge of a railway yard, with rails in the floor, and this stage belongs to the cortex project only. Over every station stands a signal, at danger until the station is done.
| Station | You do | You learn |
|---|---|---|
| 5-1 The Turntable | Swing a turntable to one end of a band of cells or the other and release an engine. A wave numbers every cell from where it arrives, and two rows of lamps show a stem-cell gene and a late gene along the order. Set the root | Pseudotime is a place in an order, counted from a root. The cells fit the order from either end equally well, so the root is chosen from what is known, and a wrong root tells the story backwards |
| 5-2 The Track | Lay track between islands of cells and send a test wagon over each piece. It crosses where enough cells of one island have neighbours in the other, and stops at a gap | An order can be worked out between any two groups of cells. A trajectory exists only where the cells form a continuum, and cells that came from elsewhere stay off the line however near they sit on the map |
| 5-3 The Timetable | Set a lever for how much to smooth, run a trolley of five lamps along the line, and peg each gene's card where its lamp comes on | Genes come on along pseudotime in an order. With too little smoothing single cells drown it, and with too much a wave that few cells carry is gone |
| 5-4 The Clock | Put three trains, one for each sample, in order of age from where their wagons stand, and turn the labels over. Then answer two questions about what the line can say | Real time points check the direction. A crowded stretch is not a long one, and one line of states is not one line of descent |
| The departure board | Slide a plate for each kind of cell on to a rail, turn a flap to a gene for each, and pull the signal. The yard checks the board. Then Vera asks for the times | Say what the data supports and no more: an order, with the direction checked, and no durations |
The end of each project, the Long Gallery: the review. One long hall, and no stations. Your work hangs along its wall: a frame for every station you played, in order, with the person whose stage it was standing by. The wall is made from the project's route, so the blood project hangs the Weigh House where the cortex project hangs the Marshalling Yard.
| Part | You do | You learn |
|---|---|---|
| The wall | Walk it. Stand at a frame and its plate comes up: what you did there, in your own numbers. A step that Tomo ran says so, and a station still to do hangs empty | What the project came to, one step after another |
| Questions from the floor | Five people each have an objection to the project. Hear one, walk whoever asked to the frame that answers it, and say so there | Every step of an analysis is there to rule out one particular way of being wrong. A reviewer's question is answered by pointing at the step that rules it out, with the setting that was used |
| The close | At the lectern, Vera states the question the project began with, reads out what you found in your own words, says what was not shown, and shows the page | What the data supports, and what is still open |
The review can start once every station on the road is done, the last one of each stage included. Until then the gallery can be walked, and Vera says what is owed. A finished project wears a ribbon on its parcel in the arrivals bay, and its gallery stays open.
Every station in the Cloud runs real arithmetic on one small generated matrix (174 cells of five cell types, 207 genes): normalisation, a variance score, PCA, nearest neighbours and a force layout. Nothing is scripted. The map you unfold is computed live, from your own choices upstream. The Bureau does the same on a second, larger sample (258 cells of seven cell types plus a few doublets, 178 genes): community detection with a resolution, sub-clustering, marker statistics per cluster and a small reference classifier all run in the browser. The Laundry has three more runs (136, 132 and 66 cells, 152 genes): the Wash runs Harmony itself at whatever theta you set, and the new run is mapped onto the result the way Symphony does it. The Weigh House has twelve generated patients, each sampled twice (24 samples of five cell types, with 1,175 cells and 200 genes where a station shows them one by one): the t-tests, the least-squares fits, the Benjamini-Hochberg cuts and the cell-type shares are all computed in the browser. The Marshalling Yard has 402 generated cells of six kinds from three samples (42 genes): the neighbour graph, the pseudotime from whichever root you set, the links between islands, the smoothed curves and the three trains are computed in the browser too.
Everything the game tells you is said inside the game. The same small cast runs through every project: Vera leads the group and hands out the work, Tomo is the student, and each stage has someone who knows it (Mika, Noor, Ida, Bea, and then Amara or Jun). All of them come to the review at the end of a project, with Reviewer 2, the Chief, a visitor, and somebody from where the samples came from: a clinician for the blood, a curator from the tissue bank for the cortex. They use the name on your badge. The one whose stage it is briefs you in a few short lines when you arrive, with the part of the screen being talked about lit up. When a result passes or fails, the mentor says why. While you play there is no text: an arrow points at what to press next, the meters show their targets, and the goals show as lights. G opens the goals as a list. In the halls and on the map, a bouncing arrow marks where to go next.
In a hurry, or only here for one topic? Step out to the map with L and walk to the stage you want. If you have no data for a stage or a step, Tomo will make some for you, with default settings. You get no stars for work you did not do, and you can always go back and do it yourself.
Choices carry over. The load you pick in 1-1 sets how many doublets are waiting in 1-5. The cells you rescue or lose at the Cliff are the cells you filter in 1-3. The genes you pick in 2-2 are the genes 2-3 rotates, the components you keep are the ones 2-4 measures neighbours in, and the neighbour graph you lock is the one 2-5 draws. The eight clusters you cut in 3-1 are the ones the line-up, the name desk, the Oracle and the Chief work on. The wash you take out in 4-2 is the map the new run is placed on in 4-3. The rule you set on the Stairs and the reference you enter at the Census are the ones your methods section names, and the sentence you hand over at the read-out is kept for the end of the project. In the cortex project the root you set at the Turntable is the root every later station counts from, the span you set at the Timetable is the one your methods section gives, and the departure board is kept, row by row, for the end of the project. In the Long Gallery all of it hangs on one wall, and at the close Vera reads your sentence, or your board, as you wrote it.
As you clear rooms, the notebook writes your methods section from the settings you actually chose: loading, cell calling, filtering thresholds, contamination fraction, doublet cut-off, normalisation, gene selection, the number of components, the number of neighbours, the layout seed, the clustering resolution, how the clusters were named, how the runs were corrected and a new one mapped, and then how the patients were compared or how the cells of a lineage were put in order.
The halls have more than 50 things to poke. Most answer with a line or two, some move, and ten open a pixel-art figure with a caption (a UMAP, a flow cell mid-run, a cDNA trace, a volcano plot, a scree plot and others).
Each room has a notebook with the objective and field notes, and a terminal that shows the same step in real tool syntax: Scanpy, Seurat, CyteArc, and the specialist tool for the job (DropletUtils, SoupX, CellBender, scDblFinder, Scrublet, CellTypist, SingleR, CyteType, Harmony, scVI, Symphony, decoupler, DESeq2, PyDESeq2, edgeR, statsmodels, scCODA, propeller, Milo, Slingshot, Monocle 3, tradeSeq). Highlighted values in the code are live: change them in the game or in the code.
More stages are planned: cell communication, cell fate, chromatin, surface proteins, spatial data, perturbations. On the map they are building sites, and the review stands at the end of the road beyond them.
The game is open source and meant to be changed. Fork this repository to make your own version, or send a pull request to improve this one. Good first changes:
- Fix the science. If a room teaches something wrong or out of date, edit its file. Each room's notebook page in the game links straight to it.
- Add something to a hall. A prop, a line, a figure.
- Add a tissue. A cell system is a file of cell types, genes and words (
js/systems/), and a pack for each later stage it can play. The shared stations read them. - Build a station or a stage. The stages still to come are building sites on the map.
- Report a problem. Open an issue.
A fork should set G.REPO in js/engine/core.js to its own address, so the links in the game point at the fork.
Plain HTML, CSS and JavaScript. Classic scripts, no modules, no dependencies. All art is drawn in code in a 320 by 180 grid, at the full resolution of the screen, so it stays sharp on phones and large monitors alike.
| Path | What it holds |
|---|---|
index.html |
The page: the screen, the notebook and the terminal. It loads the engine and the world only |
js/engine/ |
core.js: canvas, palette, pixel helpers, input, sound, saves, scenes, speech boxes, the main loop. book.js: the notebook and terminal panel. loader.js: fetches a stage's scripts when the player walks in. stats.js: the play statistics, see below. fonts.js, main.js |
js/scenarios.js |
The registry: every stage (its stations, the scripts it needs) and every project (its cell system and its route) |
js/world/ |
title.js, start.js (the badge printer: a name of your own), bay.js (choosing a project), campus.js (the map), hall.js (walking a hall: what every hall shares), requests.js (the request sheet), figures.js |
js/systems/ |
One file per cell system: immune.js, brain.js. Cell types, gene tables and every tissue-specific word the first two stages use. A later stage needs more of a cell system, and that is a pack of its own: immune.who.js and brain.who.js for the Bureau, immune.runs.js and brain.runs.js for the Laundry, immune.changes.js for the Weigh House, brain.order.js for the Marshalling Yard, immune.gallery.js and brain.gallery.js for the Long Gallery |
js/data/ |
The maths. maths.js: median, PCA, community detection, graph layout. cloud.js, atlas.js, loads.js, trial.js, line.js: the generated data behind stages 2, 3 and 4 and the two fifth stages, and what is computed on it |
js/stages/make/ |
The core facility's furniture (hall.js), rooms 1-1 to 1-5 and Reviewer 2 |
js/stages/map/ |
The Cloud's furniture (hall.js), stations 2-1 to 2-5 and journal club |
js/stages/who/ |
The Bureau's furniture (bureau.js), stations 3-1 to 3-4 and the Chief |
js/stages/runs/ |
The Laundry's furniture (laundry.js), stations 4-1 to 4-3 and the counter |
js/stages/changes/ |
The Weigh House's furniture (hall.js), stations 5-1 to 5-4 and the read-out |
js/stages/order/ |
The Marshalling Yard's furniture (hall.js), stations 5-1 to 5-4 and the departure board |
js/stages/gallery/ |
The Long Gallery, the end of every project: its wall, its people and the questions from the floor (hall.js), and the close at the lectern (close.js) |
The game stays light as it grows. The page starts with about a quarter of the code. A stage's stations, its maths and the cell system of the project in hand are fetched when the player walks into that stage, and what one project worked out is dropped when the player takes up another.
To add a cell system, copy js/systems/immune.js, change the cell types, genes and words, and name it in a project in js/scenarios.js. The first two stages work for any system written this way. The Bureau and the Laundry need more: the sample's gene table, the references, the line-up's rounds, the name desk's drawers, and every line that names a cell or a gene. That is the system's pack for the stage, js/systems/<id>.who.js and js/systems/<id>.runs.js, loaded when the player walks in. A stage lists the systems that have a pack for it (systems: in js/scenarios.js); for any other system it shows as a building site on the map. The stations of those two stages are tuned to the numbers in the blood packs. The brain packs keep those numbers slot for slot and change the names, which is the safe way to add a tissue: a new table of numbers needs every verdict checked again. The Weigh House has a pack for blood only, js/systems/immune.changes.js, and its data module reads the pack when a station asks for the data, not when the script arrives. The Marshalling Yard is the same the other way round: a pack for the cortex only, js/systems/brain.order.js, read by js/data/line.js.
To add a project, add an entry to G.SCENARIOS in js/scenarios.js: a question, a cell system, a route through the stages, and the names of the stages still to come.
To give a project its ending, put gallery last on its route, add its cell system to the systems of the stage gallery, and write the pack js/systems/<id>.gallery.js. The gallery makes its wall from the route when the player walks in: the frames, their plates and the people of the stages need nothing written. The pack holds what only that project can say: the questions from the floor (who asks, the question and its short form, the station that answers it, what is said at its frame, and what is said at a frame that nearly answers it), one line for each station of the project's own stage saying what it rules out, a look for anybody who is in no other stage, and what Vera reads out and leaves open at the close. js/systems/immune.gallery.js is the example. A plate is the room's line in the notebook's log (LOG in js/engine/book.js), so a new station needs a line there, and it can have an emblem for its frame in ART in js/stages/gallery/hall.js; without one it gets a plain picture.
To add a stage, add it to G.STAGES and put its files in js/stages/<id>/. Every stage brings its hall as a kit, G.kits.<id> = { ITEMS, LINES, W, GOALS, NOTES, draw, room, line, paint }: the things in the hall, what they say, the hall's page in the notebook and how it is drawn. A kit may add hooks for what only that hall does: use (what happens when the player uses one of its things), arrive (what is said on the first visit), tick, over and fore (things that move by themselves, drawn behind or in front of the player), locked, label, mark, dark, book, next, and open for a hall whose things are made when the player walks in. js/stages/runs/laundry.js is the shortest example, js/stages/gallery/hall.js uses most of the hooks, and js/world/hall.js lists them.
To add a station, register a scene (G.scenes.name = { enter, update, draw }), add it to the stage's rooms and scenes in js/scenarios.js and to rooms and tries in fresh() in js/engine/core.js, and add an item for it to the stage's hall. Give its notebook page an aim and some goals and the goal lights appear by themselves. A G.Beats list of lines is spoken in a speech box on the screen: by the stage's mentor, or by whoever the line names ('NOOR: ...'). A line can carry a spot rectangle, which is lit while it is said, and can be a function when its words depend on the cell system. G.resultDraw has the mentor explain a result before the buttons appear, and G.cue(x, y) draws the bouncing arrow. For the key that commits an answer use G.act() instead of G.hit('a'): it ignores the one press too many that often follows a speech. Take anything tissue-specific from G.sys, not from the station's own code.
To add something to poke, add an item, its lines and a drawing to the kit of the hall it belongs in. The notebook page of each hall links to that file.
Open index.html?debug to get window.__game in the console, for example __game.go('cliff').
Tests live in tests/: playthroughs of every stage and of the review for both projects by keyboard and by touch, a memory soak, a fuzz, saves from older versions, and a check of the numbers behind stages 3, 4 and 5. node tests/run.js quick takes about four minutes and runs on every push; tests/README.md has the rest.
The copy of the game at docs.nygen.io counts how it is played, so that we can see which stations people finish, where they give up, and what they would like next. It uses PostHog, on its servers in the EU, in its cookieless mode.
- What is counted. A visit. Vera's first words heard, a label read, a project taken. A badge printed (how long it took and whether a name was typed, never the name). A stage walked into. A station started, finished (with the seconds it took, the tries and the stars) or left unfinished. A step given to Tomo. A stage or a project finished. A code tab opened, the methods copied, the link to GitHub followed. A tick on the request sheet. The screen turned on its side on a phone. Each goes with the project in hand, the number of stations done so far, the stars, and whether the screen is a touch screen. PostHog adds what a browser tells any site: its kind and version, the size of the screen, the language, the time zone, and the page that led here. From the network address of the request it works out a rough place, a country and a city, and that can be switched off in the project's settings.
- What is not. The name on your badge never leaves the page, and nothing typed anywhere else does. No cookie is set and nothing is kept in the browser for counting, so a visitor is counted for one day and cannot be followed after it, or from one site to another. There are no recordings of the screen. A browser that asks not to be tracked is not counted, and neither is one that blocks the counter: the game plays the same.
- Your own copy counts nothing. The counter runs only on the sites listed in
js/engine/stats.js. A fork, a copy in a folder and the test suite load nothing and send nothing. To count the players of your own copy, setwindow.CYTESEEING_STATS = { key, host, sites }inindex.htmlbefore the scripts, with the token of your own PostHog project. The token in the file is public by design: it can send events and read nothing. - The request sheet at the request board and in arrivals lists a few tissues and kinds of data. A tick is one count, kept in the save so that it is counted once. Where nothing is counted, the board leads to the GitHub issues as it always did. The list is
G.REQUESTSinjs/world/requests.js.
The rooms teach the reasoning behind each step, not exact numbers. The data is generated, not real, and some things are simplified on purpose:
- The doublet rate uses the common rule of thumb for a standard 10x chip: about 0.8% per 1,000 cells recovered.
- The profile test in room 1-2 stands in for EmptyDrops. It shows what the test does and how
lowerand the FDR threshold change the outcome, without running the real statistics. - Room 1-4 uses one soup share for every cell. Real tools can estimate it per cluster or per cell.
- Room 1-5 scores cells on a two-dimensional map. Real doublet callers do the same thing in a space with many more dimensions.
- The Cloud uses 207 genes where a real matrix has about 20,000, so the numbers are scaled down: 40 genes there stands for roughly 2,000, and a handful of components for the usual 10 to 50. The terminal shows the real-size gene counts.
- Room 2-2 scores genes the way Seurat's "vst" does (variance of values standardised by the mean-variance trend, then clipped), with a running median in place of the fitted curve.
- The Cloud judges a setting by how often a cell's nearest neighbours are of its own cell type. The game knows the cell types because it generated the cells. With real data you do not.
- The Map table is not UMAP. It is a plain force layout of the neighbour graph: linked cells pull together, crowded cells push apart. It also starts from random positions, where real UMAP starts from a rough first guess (a spectral layout or the principal components). That exaggerates how much a map changes between runs, and the station says so. The lesson itself holds for real UMAP: do not interpret the position, distance or size of islands.
- In room 2-2 the mitochondrial and ribosomal genes are built to vary for technical reasons, so leaving them out helps. With real data that is a judgement call, and the room says so.
- The Bureau uses a second generated sample. Expression levels are set so that detection looks like real droplet data: CD4 RNA, for example, is caught in about a third of the CD4 T cells and in more of the monocytes. The game knows what each cluster really is, because it generated the cells, and uses that only to decide which cluster each lesson is about. The numbers on screen are computed from the cells.
- The Cut runs Louvain, modularity optimisation with a resolution parameter, on a neighbour graph whose links are weighted by shared neighbours. Leiden optimises the same score and guarantees well-connected clusters, and is what you should use on real data.
- "A split has genes behind it" is a rule made for the game: at least 3 genes with a 3-fold difference and an AUC of 0.85 or more between the two sides. "A cluster hides a group" means that clustering it again on its own links gives parts that pass that rule. On this sample no single resolution clears both, which is common with real data but not guaranteed.
- The Bureau's map is a force layout started from the first two principal components. Like a UMAP, it is for looking at.
- The line-up's 60% inside and 20% outside are a rule of thumb, not a standard. Its p-values come from a rank-sum test with a normal approximation and a correction for ties.
- The Name desk's drawers are a small hand-made hierarchy for blood cells, not the Cell Ontology, and a name counts as supported when its genes are in at least 60% of the cluster and the genes it should lack are in at most 30%.
- The Oracle is the simplest kind of label transfer: each cell takes the label of the reference profile it correlates with best over the marker genes, and a cluster takes the majority label. Its blood reference is built from the same averages the cells were generated from, so it is as good as a reference gets, and it still cannot name a cell type it does not contain. The lung reference is invented.
- The Laundry uses three generated runs of one kind of sample. A run's effect is one factor per gene, shared by every cell type, and the run that waited on the bench also carries a handling signature (JUN, FOS and others), stronger in monocytes. Real batch effects are messier and differ more between cell types.
- At the sorting table, two islands are partners when each is the other's best match by correlation of their mean expression, after each run's own mean is subtracted. It stands in for mutual nearest neighbours, which do the same cell by cell.
- The Wash runs the Harmony algorithm of 2019 (soft clustering with a diversity penalty, then a ridge regression in each cluster) on 268 cells with 9 clusters, from the best of 8 k-means starts, for at most 20 rounds. It is written from the paper and will not match any implementation number for number. On this sample theta 2 and 4 pass, lower values leave the runs apart, and 8 and 16 pull the platelets into another island. Where those boundaries fall is a property of this small sample, not of Harmony.
- RUNS MIXED and PLATELETS APART are counts over each cell's 10 nearest neighbours, in the spirit of iLISI and cLISI. The second one uses the game's knowledge of which cells are platelets. With real data you would look at their marker genes, which is what the PPBP light is for.
- Lost and found maps in the manner of Symphony, with a vote among the 5 nearest reference cells. The plasma cells land among the B cells with unanimous votes and at ordinary distances, because the genes that set them apart were never among the reference's variable genes. The lamp's test, one marker gene per label, seen or not seen, is deliberately crude. A real check uses several markers and compares groups of cells.
- The counter's gauge is Cramér's V between the batch label and the condition. Real designs have more to balance (sex, age, where a sample was collected), and a bridging sample helps only as far as the run affects it the way it affects the other samples.
- The brain cell system follows the numbers of the blood one, slot for slot, in every stage. Only the names change, so each station gives the verdicts that were tuned on blood. In the first two stages: two related cell types, one apart, one large and a rare relative of it (pan-neuronal genes shared by excitatory and inhibitory neurons, intermediate progenitors between radial glia and neurons, outer radial glia as the rare type). In the Bureau: deep-layer neurons, newborn neurons, intermediate progenitors, interneurons, ventricular and outer radial glia, oligodendrocyte precursors, and doublets of a neuron and a radial glia cell. Real developing cortex has more cell types and far more gradual transitions.
- What the blood lessons become in the cortex. The programme that runs at its own strength in every CD8 T cell is the switch from progenitor to neuron, still running in newborn neurons. CD4, famous and rarely caught, is FEZF2, which radial glia make too (Guo et al. 2013). The genes B cells share with monocytes are SOX6 (Azim et al. 2009) and NPAS3, which interneurons share with radial glia and oligodendrocyte precursors. CD14 and CD16 monocytes are ventricular and outer radial glia (Pollen et al. 2015). The reference with a gap is a fetal atlas made from younger tissue, with no oligodendrocyte precursors, and the wrong reference is an adult atlas, which calls radial glia astrocytes.
- The genes of both cell systems were checked against expression data in CZ CELLxGENE: blood from healthy donors (13 million cells from 63 data sets), and fetal human brain, mainly Bhaduri et al. 2021 and Wang et al. 2025. Where a row did not fit, the gene was changed and the numbers were kept. Some rows still do not fit. In blood: MAL is the best RNA marker of CD4 T cells there is, and it is caught in about a quarter of them; CD8A and CD8B are in about half of CD8 T cells, and FOXP3 in about one regulatory T cell in six; the table gives NK cells less CD3E than the quarter of them that carry it; JCHAIN is also in about a quarter of B cells; in the first two stages the rare dendritic cells carry S100A8 and S100A9 almost as monocytes do, which is too much. In the cortex: CCND2 is also made by oligodendrocyte precursors and by ventricular radial glia (Glickstein et al. 2009; Tsunekawa et al. 2012); the precursors make no FEZF2; intermediate progenitors carry NEUROD6, NEUROD2 and TBR1 at about half the rate of neurons, where the table gives them almost none; HMGB2 and TOP2A run higher in radial glia than in intermediate progenitors, not lower; the sample's interneurons are all of one kind, where real tissue of this age has many from the caudal ganglionic eminence too; the subplate genes are NR4A2, a marker from rodents, and ST18, which Polioudakis et al. 2019 confirmed in human tissue. That data does not tell ventricular from outer radial glia, so those rows rest on Pollen et al. 2015.
- In the brain's Laundry, microglia are the cells only one run caught, and striatal neurons are the cells the reference has never seen: they are given the interneuron label, and NXPH1, which these cortical interneurons carry, is dark in them. Four numbers differ from the blood table, because the blood ones would be false: microglia make no SLC17A6, striatal neurons make SNAP25, microglia make MEF2C (Deczkowska et al. 2017), and CX3CR1 is set higher so that the microglia stay an island of their own. The handling signature of the run that waited is stronger in one cell type because the game makes it so; nothing says radial glia react more than other cells.
- The Weigh House's patients are generated: twelve donors, six of them responders, two visits each, five cell types. Planted, and nothing else: in responders after treatment the CD8 T cells about double in number and raise MKI67 and HLA-DRB1 (and CD38, at the Scales); 24 interferon-stimulated genes rise in the monocytes of every patient after treatment; three donors carry HLA-DRB5; one responder gave five times the cells and has FKBP5 high; GZMK is higher in responders at both visits. Every other gene is noise.
- That response is cleaner than a real one. In blood after PD-1 blockade, dividing CD8 T cells that carry HLA-DR and CD38 rose in most patients, and what went with clinical benefit was the size of the rise set against tumour burden (Huang et al. 2017) or how early it came (Kamphorst et al. 2017). The game names no treatment. A doubling of all CD8 T cells is invented for the Census, and so is the rise of interferon genes in everybody's monocytes. The 24 genes themselves are real interferon-stimulated genes: all are on the list that Kueck et al. 2019 screened.
- HLA-DRB5 sits on one group of HLA haplotypes only, the group that HLA-DRB1*15:01 belongs to (Alexandrov et al. 2026; Akel et al. 2022), which is why many donors have no copy. In healthy blood in CELLxGENE it is caught in about 6% of CD8 T cells, carriers and non-carriers together, and in about half of the B cells; the game gives a carrier's CD8 T cells about a third. CD38 and MKI67 are caught in under 1% of CD8 T cells in healthy blood, and the levels the game gives them after treatment are invented. FKBP5 is switched on by glucocorticoids in blood cells (Vermeer et al. 2003), the kind of thing one patient can carry for a reason no study recorded. The game gives no reason.
- The needle of the Scales is Welch's t-test on log-normalised values: of 1,175 cells while the grain is loose, and of twelve pseudobulks once it is bagged. Its dial covers four orders of magnitude of p. Real pipelines fit a count model to the pseudobulk counts, or a mixed model to the cells.
- The Formula bench fits by least squares to log2 pseudobulk levels, which the game draws directly on the log scale. The tile visit:response is one column: after treatment, in a responder. Typed as a formula it expands differently: formulaic 1.2, which PyDESeq2 uses, builds an interaction column for each visit, and the matrix is no longer of full rank. The DESeq2 and PyDESeq2 tabs follow the DESeq2 vignette's layout for individuals nested within groups, and both were run on simulated counts. The number of a donor within their group is made a factor in R and wrapped in
C()in Python: left as a plain number it is read as a quantity, and the model loses the pairing without any error. The edgeR tab adds one "after" column for each group to the donor columns, as the edgeR User's Guide does, and the difference between the two is what the bench's tile measures. - The Stairs hold 200 genes, 24 of them with a real change. Their sizes and the seed were chosen so that, on this one data set, Benjamini-Hochberg at 5% is the only one of the twelve settings that passes: 19 real effects and 1 false alarm among 20 lit steps. A real data set is not so tidy. The procedure keeps the rate on average, not in each experiment; here a flat p below 0.01 lights 19 real effects and 2 false alarms, which is close; and with 20,000 genes instead of 200 a flat line does far worse. The game counts real and false because it made the data.
- At the Census, one pump of CD8 T cells (twice the count) leaves every layer within 0.6 points of the jar after treatment, and no other single cell type comes within 8 points. Halving the four others gives exactly the same jar, which is the point: the shares cannot decide, and a reference does. The ledger's test is a paired t-test, in the six responders, of each cell type's log ratio to the reference. scCODA models all the counts together, with a prior that favours few changes.
- The read-out checks every tile with those same tests. "Goes with" is the only last word it takes, because the twelve patients were looked at once: nothing was tested in new patients, and nothing was done to a patient to see what followed.
- The Marshalling Yard's cells are generated: three samples (called 14, 17 and 20 weeks; the ages are invented), each with 110 cells of one lineage that have a hidden position along one process, from radial glia through intermediate progenitors and newborn neurons to maturing neurons. Every gene follows a smooth curve of that position (on and then off, on for a while, or off and then on), with noise. The older the sample, the more of its cells lie late. Beside the line are 36 oligodendrocyte precursors on a spur off the radial glia, and 36 interneurons that are joined to nothing. Three in ten of the radial glia are dividing. Nothing else is planted.
- That line is tidier than a real one. Radial glia also make neurons directly, without an intermediate progenitor (Noctor et al. 2004), intermediate progenitors divide too, and the line branches: branching and fate are the next stage's subject. Radial glia of the human cortex are one source of its oligodendrocyte precursors (Huang et al. 2020), which is all the spur stands for. Cortical interneurons are born in the ganglionic eminences (Hansen et al. 2013; Ma et al. 2013), so a sample of cortex holds none of their progenitors; the game gives them no link to the line at all, where real data usually shows a few stray ones.
- Pseudotime in the game is the shortest way through the neighbour graph (10 nearest neighbours, on 8 principal components of 36 genes) from five root cells, as a share of the longest such way. It follows the hidden position with a rank correlation of 0.94. Diffusion pseudotime, in the Scanpy tab, uses random walks; Monocle 3 and Slingshot measure along a graph or a curve that they fit. The two ends of the band are found without knowing which is the start: the cell that lies furthest, with its neighbours, from an arbitrary cell, and then the cell furthest from that one. The third road leads to the cell half-way between them.
- The Track's test is PAGA's, as Scanpy computes it (model v1.2): the links between two groups of cells, counted both ways, over the number expected if every link landed on a cell picked at random. The mark of 5% that a wagon needs is the game's own. Scanpy draws links above 1% unless told otherwise, and gives no p-value, because the random model expects too many links. On this sample the four joined pairs score between 25% and 53%, and no other pair has a single link. The islands are the cell types as generated, not clusters found in the data. The map is the Bureau's force layout, and the interneurons land beside the maturing neurons, closer to them than the newborn neurons are.
- The Timetable smooths log-normalised expression along pseudotime with a Gaussian kernel, read at 35 stops. The lever sets its width: none, 0.01, 0.03, 0.15 or 0.3 of the range. A lamp is lit where a gene's level reaches half of its mean in the cells that carry any of it. On this sample only 0.03 can be read. With no smoothing all five lamps flicker, and at 0.01 two still do; at 0.15 the EOMES lamp peaks at 37% and never lights; at 0.3 NEUROD1 and GRIN2B are lost as well. That PAX6, EOMES, NEUROD1 and TBR1 come on in this order is published (Englund et al. 2005; Hevner et al. 2006). GRIN2B as the last rests on expression data: it is caught in 1% of progenitors and 21% of excitatory neurons in Bhaduri et al., and in nine in ten of the maturing neurons of Wang et al. Along pseudotime the EOMES wave is not short: it takes up a quarter of the line, because pseudotime is long wherever many genes change. Heavy smoothing loses it because few cells carry it.
- At the Clock each train is the 110 lineage cells of one sample, and their mean pseudotime is 0.46, 0.55 and 0.68. The crowded stretch (99 cells) is the far end, where maturing neurons differ little from one another; the sparse one (10 cells) lies where progenitors become neurons. The generator has no clock in it, so "cannot be told" is true of this data by construction. That the first-born neurons of a cortex settle in its deep layers and later ones above them is the inside-out order, shown in the monkey by Rakic 1974; the human cortex also makes its deep-layer neurons before its upper-layer ones (Nowakowski et al. 2016). A snapshot fits more than one history of its cells (Weinreb et al. 2018).
- The departure board is checked by the yard, not against a key: the order of the plates against the median pseudotime of each kind of cell, each gene against where it is expressed (the kind of cell that carries most of it, or the next along the line), and the siding against the links.
- The Long Gallery teaches no method of its own. Each question from the floor is answered by a station: haemoglobin RNA in every cell by the soup kitchen, distance on the map by the map table, the number of clusters by the Cut, runs against cell types by the Wash, and then falling shares by the Census in the blood project, or the interneurons beside the line by the Track in the cortex project. What a station is said to rule out is one line of what it taught, and nothing is said there that the station did not say first.
- The questions are written so that one station answers each. A real reviewer's question is seldom that tidy: an analysis step guards against more than one mistake, and an objection is often met by two steps together. The people who ask are invented, and so are the clinician and the curator.
- A plate in the gallery is the notebook's own line for that station, so it shows the numbers of the player's run, including the ones that did not go well. The stars of the review count slips over the questions: three for none, two for one, one for more.
- At the close, what the project "did not show" is what its stations said they could not: for blood, no test in new patients, no cause, and no cell-to-cell signalling; for cortex, no descent of one cell from another (that takes lineage tracing), no durations, and no fate of a single cell.
The code in the terminal was last checked in November 2026 against Scanpy 1.12 and 1.13, Seurat 5.6 and 6.0, DropletUtils 1.32, scDblFinder 1.26, SoupX 1.6, SingleR 2.14, celldex 1.22, harmony 2.1 (R), harmonypy 2.1, Symphony 0.1.3, CellTypist 1.7, scvi-tools 1.5, CyteType 0.21 and CyteArc 1.3, and for the Weigh House decoupler 2.3, PyDESeq2 0.6, pertpy 1.5, statsmodels 0.15, DESeq2 1.52, edgeR 4.10, limma 3.68 and speckle 1.12, and for the Marshalling Yard slingshot 2.20, tradeSeq 1.26, Monocle 3 1.4 and CyteArc 1.4. The Scanpy snippets use the argument names of 1.12, which 1.13 still accepts and has begun to replace. Scanpy 1.13 also builds Harmony in, and its default is a newer variant than the 2019 algorithm the Wash teaches.
The R tabs were also run from start to finish on generated data, with the versions that Ubuntu 24.04 and Bioconductor 3.18 provide: R 4.3, Seurat 5.0, DropletUtils 1.22, scDblFinder 1.16, SoupX 1.6, SingleR 2.4, harmony 1.2, Symphony 0.1.1, DESeq2 1.42, edgeR 4.0, speckle 1.2, slingshot 2.10, tradeSeq 1.16 and Monocle 3 1.3. Two lines were read against their documentation and not run: the download of the celldex reference, and cellranger count. On Seurat older than 5.2, Leiden clustering (algorithm = 4) needs the Python module leidenalg; newer versions do not.
The recommendations follow the Single-cell best practices book and the papers behind each method. For the Marshalling Yard: the chapter on pseudotemporal ordering of that book, diffusion pseudotime (Haghverdi et al. 2016), PAGA (Wolf et al. 2019), Slingshot (Street et al. 2018) and its vignette, which recommends choosing the start from the time of collection or from marker genes, Monocle 3 (Cao et al. 2019), tradeSeq (Van den Berge et al. 2020), a benchmark of trajectory methods (Saelens et al. 2019), what a snapshot can and cannot say about dynamics (Weinreb et al. 2018; Tritschler et al. 2019), and the CyteArc page on pseudotime. For the Weigh House: the chapters on differential gene expression and compositional analysis of that book, why cells must not be counted as replicates (Squair et al. 2021; Zimmerman et al. 2021; Murphy and Skene 2022), the false discovery rate (Benjamini and Hochberg 1995), scCODA (Büttner et al. 2021), propeller (Phipson et al. 2022), Milo (Dann et al. 2022), the section of the DESeq2 vignette on individuals nested within groups, section 3.5 of the edgeR User's Guide on comparisons both between and within subjects, and the CyteArc page on comparing conditions across donors. For the Laundry: the integration chapter of that book, Harmony (Korsunsky et al. 2019), mutual nearest neighbours (Haghverdi et al. 2018), a benchmark of integration methods and the metrics it scores them by (Luecken et al. 2022), Symphony (Kang et al. 2021), pooling donors in one run and telling them apart by genotype (Kang et al. 2018), and the CyteArc pages on batch correction and reference mapping. For the Bureau: Leiden (Traag et al. 2019), why p-values computed after clustering are too small (Zhang et al. 2019), a benchmark of marker gene methods (Pullin and McCarthy 2024), CellTypist (Domínguez Conde et al. 2022), SingleR (Aran et al. 2019) and the CyteType and CyteArc documentation. For the first two stages: EmptyDrops (Lun et al. 2019), SoupX (Young and Behjati 2020), Scrublet (Wolock et al. 2019), scDblFinder (Germain et al. 2021), variable gene selection in Seurat v3 (Stuart et al. 2019), sctransform (Hafemeister and Satija 2019) and a comparison of normalising transformations (Ahlmann-Eltze and Huber 2023).
Made by Nygen Analytics. Released under the BSD 3-Clause licence, see LICENSE.
The idea of a walkable pixel world with one topic per room comes from Phil Ewels's scverse 2026 keynote. The code and art here are separate.
Fonts: Silkscreen and VT323, SIL Open Font License 1.1. Licence texts are in licenses/.