From 100 Million Cells to One Molecule You Can Walk Inside — Why Cascade Makes NexoPeek Essential Now

I still remember the night the data dump landed on my laptop. A single CSV, 100 million rows, each row a cell from a spatial transcriptomics experiment. The file was 27 GB, the kind of thing that makes a laptop fan sound like a jet engine. I had a deadline in two days, a grant review looming, and a sinking feeling that the usual “load‑into‑pandas‑and‑plot” workflow would never finish in time.

The viral post that popped up on Hacker News that morning — “From 100 Million Cells to One Molecule You Can Walk Inside” — felt like a personal message. It described a pipeline called Cascade that breaks a massive cellular atlas into hierarchical tiles, each tile small enough to stream to a browser, yet preserving the full resolution needed to zoom down to a single transcript. The article claimed that NexoPeek, a web‑based viewer built on top of Cascade, lets you “walk inside” a molecule, rotating, slicing, and measuring distances in real time.

I clicked the link, half‑expecting marketing fluff. Instead I found a technical deep‑dive: a description of a quad‑tree‑like spatial index stored as Parquet files on object storage, a WebAssembly‑compiled rendering engine that streams only the visible tiles, and a WebGPU‑accelerated shader that draws point clouds at 60 fps even on a modest GPU. The numbers were concrete — 1.2 ms per tile fetch, 0.8 ms decode, 0.4 ms raster — and the benchmarks were run on a single‑core Cloud Run instance. No hidden clusters, no proprietary magic.

That night I cloned the open‑source Cascade repo, spun up a local MinIO bucket, and ran the ingestion script on a 4‑core VM. The ingestion took 3 hours, wrote 12 TB of tiled Parquet, and produced a manifest JSON that NexoPeek reads at load time. The first time I opened the viewer in Chrome, the 100 million‑cell dataset appeared as a faint cloud. I hovered, the tile loader fetched the next level, and suddenly individual nuclei resolved. Another zoom, and a single mRNA molecule glowed, its coordinates exact to the nanometer.

The experience was visceral. I could rotate the molecule with a mouse drag, slice it with a plane slider, and measure the distance between two transcripts by clicking two points — a feature the demo highlighted as “spatial ruler”. The UI never froze; the frame‑time graph in DevTools stayed flat at 16 ms. I realized the cascade architecture does two things that matter for any large‑scale spatial data product:

1. Progressive refinement — the index guarantees that the first tile you see is a coarse summary, and each subsequent tile adds detail only where you look.
2. Stateless streaming — tiles are immutable objects in object storage; the viewer never needs a persistent server session, just signed URLs.

For a team like mine — a handful of bio‑informaticians, a shared cloud budget, and a need to ship interactive figures to reviewers — this meant we could publish a live, explorable supplement instead of a static PNG. The grant reviewers could open the link, zoom to the exact region we highlighted in the paper, and verify the spatial colocalization themselves. No more “supplementary movie” that never plays on the conference Wi‑Fi.

There were hiccups. The first ingestion run crashed because the Parquet writer hit a 2 GB row‑group limit; I had to patch the writer to split row groups at 500 MB. The WebGPU shader failed on Safari until I added a fallback to WebGL2. The signed‑URL expiration was set to 1 hour, which broke long‑running explorer sessions; a quick lambda refresher fixed it. Each fix felt like a small victory, the kind you only get when the stack is transparent enough to debug.

What struck me most was how Cascade’s design mirrors the biology: just as a tissue is organized into organs, then cells, then molecules, the data is organized into tiles, then sub‑tiles, then points. The same hierarchy that lets a pathologist zoom from a whole‑slide image to a single nucleus now lets a computational biologist zoom from a million‑cell atlas to a single transcript. The tool didn’t invent that hierarchy; it exposed it.

Now, when a new dataset lands — a 200 million‑cell atlas from a collaborator — I don’t reach for a heavier cluster. I spin up the same ingestion pipeline, point it at a new bucket, and hand the manifest URL to NexoPeek. The viewer loads in seconds, the first tile paints in milliseconds, and I can start asking scientific questions instead of engineering ones.

If you’re wrestling with spatial data that feels too big for a browser, give the cascade‑tiling approach a try. The open‑source repo, the ingestion scripts, and a minimal NexoPeek starter are all on GitHub. Clone, run the demo on a tiny subset, and see the first tile appear. Then scale up. The architecture does the heavy lifting; you just bring the biology.

Explore the cascade, walk the molecule, and let the data tell its story.