Where the Memory Wall Is


by

Three drug discovery jobs, three different GPU bottlenecks — memory, none at all, and raw parallelism. The interesting part is how little they have in common.

Last November I had time on RTX 6000 Blackwell cards — 96 GB each — at a Swiss data centre, and put together some use cases for a talk at DINAcon. Nine months on, the models have moved and it is worth writing down what the memory ceiling really meant. Three jobs, three different bottlenecks.

1. A protein that does not fit

Most proteins are small. A kinase domain is around 300 residues; a GPCR about the same. Then there is TRRAP: 3859 amino acids, a PIKK-family scaffolding protein, recurrently mutated in cancer.

Osimertinib, the EGFR kinase domain (323 aa), ACKR3 with a designed nanobody (306 aa), and TRRAP (3859 aa), at constant magnification.
Osimertinib, the EGFR kinase domain (323 aa), ACKR3 (306 aa) with a designed nanobody (120 aa), and TRRAP (3859 aa), at constant magnification.

Cofolding models scale quadratically in sequence length, because the pair representation does. I measured this on Boltz-2 in 100-residue steps and fitted the curve:

Boltz-2 VRAM against sequence length, measured and extrapolated. VRAM(L) = 1.27×10⁻⁵L² + 0.002141L + 2.81.
Boltz-2 VRAM against sequence length, measured and extrapolated. VRAM(L) = 1.27×10⁻⁵L² + 0.002141L + 2.81.

My largest successful Boltz-2 run was 2700 residues. The fit puts full-length TRRAP at roughly 215 GB — more than twice what a 96 GB card holds. Bigger hardware alone was not going to close that gap.

What closed it was OpenFold3’s low-memory mode. In default settings OpenFold3 will not take 3859 residues on 96 GB either; in low-mem mode the full chain came back in about sixteen minutes.

TRRAP (3859 aa), calculated with OpenFold3 in low-memory mode.
TRRAP (3859 aa), calculated with OpenFold3 in low-memory mode.

That is the useful lesson, and it is not the one I expected going in. The memory wall is real, but you attack it from two sides. Buying a card with more VRAM moves it a little — quadratically little. An implementation that trades compute for memory moves it a lot. Check what the code can do before pricing the hardware.

2. Mutants, in minutes

Osimertinib – and Poziotinib, below – is a covalent inhibitor for EGFR-mutant lung cancer, developed to survive the T790M gatekeeper mutation. Resistance keeps evolving, so the recurring question in any kinase program is what the site looks like once a new variant appears.

My test was whether a model reproduces a pose we already know. Below, Boltz-2 models of the double mutant T790M/L858R, are overlaid on the corresponding crystal structures.

Osimertinib in EGFR T790M/L858R: docked pose (yellow) against crystal structure 6JX4 (green).
Osimertinib in EGFR T790M/L858R: predicted pose (yellow) against crystal structure 6JX4 (green).
Poziotinib, same colour scheme, against 8F1Y.
Poziotinib, same colour scheme, against 8F1Y.

Both drugs reproduce the crystallographic binding mode perfectly – rmsd values were below 1 Angstrom. A mutant–compound pair takes minutes on one GPU. So you no longer pick the two or three variants worth modeling — you run the whole clinical panel against your series.

This case needs no special hardware. A 24 GB consumer card is enough, and a Mac with enough unified memory will get there too if you are patient. Data centers earn their keep on the jobs in sections 1 and 3 — not on this one.

3. Design: a throughput problem

The measured number: 2000 protein designs generated and ranked in just under 4 hours on 4 GPUs. The Boltzgen authors suggest sampling around 60,000 for a serious campaign — call it a long weekend on 8 cards, assuming throughput scales cleanly, which I verified in a different project at that scale.

Memory never came close to be an issue here. A nanobody plus a GPCR is a small system. What this job wants is cards, plural, kept busy.

None of these designs have seen a wet lab. A ranked list from a generative model is the start of a project, not a result — the point is that the list now costs a weekend of GPU time rather than months of immunization and panning.

Since November 2025

OpenFold3 left preview in March 2026: full stack, weights, training and inference code, evaluation scripts and the training data itself, permissively licensed. For consulting that matters more than a benchmark: I can run it inside a client’s firewall, tell them exactly what the model was trained on, and know it will still be there, unchanged, when the project ends.

BoltzGen has meanwhile accumulated a broad body of validation across target classes and binder modalities. Regrettably it did not deliver when I used this for peptide design in a live project.

The practical version
  • Large single structures are a memory problem — but check for a low-memory implementation before you check the price of a bigger card.
  • Routine cofolding and mutant modelling is not a hardware problem at all. One 24 GB card under a desk keeps up with a medicinal chemistry program.
  • Design campaigns are a throughput problem: several cards you can saturate, and a pipeline that survives one of them failing.

A pair of RTX 3090s covers most of what clients ask me for. The value of occasional 96 GB access is not that everyday work gets faster — it is that a category of question I used to decline becomes answerable.

I run CADD Consulting GmbH in Zofingen, Switzerland — structure-based design, free energy calculations and AI structure prediction for biotech, pharma and academic groups. All structures shown are from non-confidential internal work. Thanks to stepping stone AG for GPU access.

Models: Boltz-2 (repo, MIT) · BoltzGen (repo, MIT) · OpenFold3 (repo, Apache 2.0)


CADD Consulting
Privacy Overview

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.