7 AM, A baby in the NICU at Boston Children’s gets blood drawn. By 11 AM, their whole genome is sequenced. That’s a Guinness World Record set last year by Broad Clinical Labs, Roche, and the BCH team, published in NEJM.
But then the doctor waits. Not for the sequencer. For the software.
After variant calling, you still have to annotate, aka figure out what each of the ~4 million variants in that genome actually means. Which gene? Which transcript? Pathogenic in ClinVar? The standard tool, Ensembl Variant Effect Predictor (VEP), takes 2–5 hours for a whole genome. When sequencing itself drops below four hours, annotation becomes the rate-limiting step.
As a researcher, I spent a good part of my PhD waiting for VEP. Run the job, go to lunch, come back, still running. The frustration never left. So this year I rewrote it.
fastVEP — Ensembl VEP, rebuilt from scratch in Rust, open-source.
4M+ variants, 508K transcripts, ~86 seconds on a MacBook
130× faster than VEP v115.1 on the same clinical data
100% concordance across 23 annotation fields
ClinVar, gnomAD, dbSNP, SpliceAI built in (takes longer)
Single 3.2 MB binary, zero dependencies, Apache 2.0
Validated on human, mouse, Drosophila, Arabidopsis, yeast
RastQC — FastQC, rebuilt the same way, open-source. FastQC is the QC tool nearly every sequencing lab on Earth runs on every genome it produces. The compute adds up to a staggering amount of duplicated work, every day, in every facility.
3.9× faster end-to-end, ~500× faster startup
4–9× less memory
100% concordance across five organisms
Long-read support, MultiQC compatibility
Single 2.1 MB binary, available as an agent skill
These aren’t optimizations. A 130× speedup isn’t a faster version of the same workflow; it’s a different category of tool.
I knew FastQC and VEP needed a rewrite for years. But, I never had the time, and honestly never had the Rust chops to ship a production rewrite alone.
Agentic coding changed that. What used to be a six-month team project became a focused sprint by one researcher who knew the domain well. The GPU spent by coding agents during development is offset within days by every lab that stops re-running the slow pipeline. The carbon math works out almost immediately.
This is the part worth pausing on. The bottleneck has shifted from who can write the rewrite to who (1) knows what’s worth rewriting and (2) knows how to validate the software. That’s an empowering change in who gets to define the tools science runs on.
I’m not inventing anything here. I’m joining three movements that have been gathering force:
Rust-rewriting the foundations. Astral’s uv and ruff took Python tooling — pip, flake8, black, isort — and made it 10–100× faster while shipping as single binaries. The Python ecosystem retooled around them in roughly eighteen months. Polars is doing the same to pandas. In genomics, the noodles crate is quietly rebuilding the file-format stack (BAM, VCF, GFF, FASTA) in Rust. The pattern is consistent: take a workhorse tool everyone tolerates, rebuild it in Rust, ship a single binary, watch the ecosystem re-tool around it. fastVEP and RastQC are the same pattern, applied to clinical genomics.
Rapid clinical genomics. Stephen Kingsmore’s team at Rady Children’s pioneered rapid WGS for NICU babies more than a decade ago. The Broad/Roche/BCH four-hour record is the latest milestone in a long arc. This community has spent twenty years pushing the wet-lab side — faster chemistry, faster basecalling, faster pipelines. The dry-lab side, especially tertiary analysis, has not kept up. We sequence at 2026 speed and annotate at 2014 speed. That gap is now the most leveraged place to work in clinical bioinformatics.
Performance as a moral category. Jonathan Blow, Casey Muratori, and the broader Handmade community have argued for years that slow software is a cultural failure rather than a physical one; we’ve trained ourselves to accept watching progress bars instead of fixing them. Nikita Prokopov’s Software Disenchantment essay is the same argument from a web-app angle. I half-agreed and half-rolled my eyes at this crowd for years. Then I started timing my own tools. They were right. The wait isn’t a constant of nature. It’s a bug we stopped noticing.
What ties these three together: the belief that the tools we use every day are not load-bearing artifacts constrained by the law of nature. They were written by people, often quickly, often a long time ago, and they can be rewritten by people now.
Two tools are not a stack. Many parts of the functional and clinical genomics software stack are workhorses written in C++, Java, or Perl in the 2000s and 2010s, used billions of times, almost never rewritten. If we can compress that whole chain from days to minutes, the bedside calculus changes. Diagnoses arrive while clinical decisions are still open. Trios get re-analyzed in real time as new evidence appears. AI scientists running thousands of in-silico experiments stop being throttled by tools that were designed for one run a day.
I want to see the entire sequencing software stack rewritten over the next year. By the labs and individuals who actually use it, feel the pain of the wait, and now have agentic coding to compress what used to be team-years into focused weeks. The economics flip the moment you ship, because every download is permanent compute and time savings for somebody else.
If you run a sequencing lab, please try the tools and tell me where they break. If you’re building AI scientists or biomedical agents, please wire them in. Your humans and agents will be faster, cheaper, and more honest about what they actually did.
The hardware is ready. The software should be too.
Try it
fastVEP: https://fastvep.org/
fastVEP GitHub: https://github.com/Huang-lab/fastVEP
RastQC GitHub: https://github.com/Huang-lab/RastQC
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.