System Requirements

The computation runs inside your own PC, so the PC is the performance. Everything below is something we measured ourselves, and where we did not measure, it says so.

The one line to read before buying: if you will use structure prediction, protein length decides the hardware. Everything else (ADMET, docking, analysis) runs on an ordinary office PC.

Minimum and recommended

	Minimum	Recommended
OS	Windows 10 (64-bit)	Windows 11
CPU	4 cores	6 cores or more
Memory (RAM)	16 GB	32 GB (if you have no GPU and work past 800 residues)
Disk	40 GB free	80 GB free on SSD
GPU	Not required	12 GB VRAM or more, if you use structure prediction
Internet	Only for installation, licence checks and updates	— your research data does not leave the PC

Why 16 GB is the minimum: one structure prediction run committed 6.6 GB at 74 residues and 9.2 GB at 520. On an 8 GB PC even the shortest proteins leave no room.

Without a GPU, RAM decides the length you can handle

RAM	Confirmed protein length	Time and memory at that length
8 GB	Not recommended	Even 74 residues commits 6.6 GB
16 GB	up to about 800 residues	1 h 2 min · 14.5 GB committed
32 GB	up to about 1,200 residues	2 h 54 min · 27.0 GB committed

Measured 2026-10-17 on a 31 GB machine. CPU memory climbs steeply with length — from 7.4 GB at 520 residues to 22.5 GB at 1,200, three times as much.

A GPU removes this requirement. When the work runs on the GPU, system memory stayed flat at 4.9 GB regardless of length. For long proteins a GPU is not only about speed — it is also about not having to buy more RAM.

Structure prediction — the lengths we confirmed

This is the range we actually ran. The measurements were made on an AMD Radeon RX 7900 XTX (24 GB, ROCm), and the achievable length is set by GPU memory.

GPU memory	Example cards	Confirmed protein length
8 GB	RTX 4060 · 5060 · 3060 Ti	up to about 500 residues
12 GB	RTX 3060 12GB · 4070 · 5070	up to about 700 residues
16 GB	RTX 4060 Ti 16GB · 4070 Ti Super · 5070 Ti · 5080	up to about 900 residues
24 GB	RTX 3090 · 4090 · RX 7900 XTX	up to about 1,200 residues — the most we measured

Evidence (measured, peak reserved memory): 400 residues 4.9 GB · 600 7.9 GB · 800 11.9 GB · 1,000 17.0 GB · 1,200 21.4 GB. 1,500 residues failed on 24 GB (out of memory at 22.1 GB). The lengths in the table leave room for what the display and driver use.

Those figures come from a heavier setting that generates five poses and computes affinity, so folding a single protein uses less (measured 2026-10-17: 260 residues 3.1 GB · 520 residues 5.2 GB · 800 residues 9.1 GB · 1,200 residues 17.5 GB). The length limits above are based on the heavier case, so they carry headroom — we do not trim that headroom to claim longer limits, because we do not decide what you will run.

How long it takes — same work, only the accelerator changed (measured 2026-10-17)

Protein length	GPU (24 GB)	CPU only, no GPU	Difference
74 residues (1CTF)	39 s	51 s	1.3×
129 residues (1LYZ)	41 s	75 s	1.8×
153 residues (1MBN)	41 s	91 s	2.2×
260 residues (2CAB)	46 s	223 s	4.8×
400 residues	56 s	603 s	10.7×
520 residues	72 s	19 min	15.7×
800 residues	140 s	1 h 2 min	26.5×
1,200 residues	326 s	2 h 54 min	31.9×

Measured on the same engine with only --accelerator changed, so nothing but the accelerator differs. The GPU was faster at every length we measured, and the gap widens with length (1.3× at 74 residues, 31.9× at 1,200). CPU time grows with roughly the 2.7th power of length; GPU time grows far more slowly.

Correction (2026-10-17): we previously wrote that "below roughly 200 residues the GPU is slower than the CPU". That was wrong. It came from placing two tables side by side that were measured in different environments on different work — the GPU side generated five poses and computed affinity, which is substantially heavier. Re-measured on identical work, the GPU was faster even at 74 residues.

A PC without a GPU gets the CPU structure engine; a PC with a GPU gets the GPU runtime layered on top of it. The CPU column above is that GPU-capable engine run on the CPU. Measured separately, the CPU-only build was somewhat faster (260 residues 168 s · 400 residues 468 s · 520 residues 1,097 s, measured 2026-10-16). Either way the conclusion is the same.

The input range is 30–800 residues

That is the length you can submit for folding one protein. We counted the protein chains in the 815 experimental structures we hold, and 96.5% were 800 residues or shorter (median chain 289 residues). It is not enough if you want to submit a full-length protein or a whole complex — in the same set, 22% of complexes exceed 1,000 residues in total.

If you have no GPU, or a small one

When GPU memory is under 8 GB the program does not use the GPU and runs on the CPU instead. That is deliberate.

We tested a GeForce GTX 1050 (2 GB) on real hardware. When GPU memory runs out, the Windows NVIDIA driver does not raise an error — it borrows system memory. So instead of failing, one 50-residue run took 2,791 seconds. The same work finishes in 63 seconds on a 24 GB GPU. That is about 44×, with no error to explain it. That is why we do not use small GPUs at all.

What we did not measure

Lengths above 1,200 residues — not measured. All we confirmed is that 1,500 residues failed on 24 GB.
Normal-speed structure prediction on NVIDIA — not measured. The NVIDIA cards named above are matched by memory capacity; our measurements were made on AMD. On NVIDIA we only confirmed the slowdown on a 2 GB card.
Hardware for complexes (multiple chains) by length — we measured single chains only.
Laptops, external GPUs, virtual machines — not measured.

Figures extrapolated from fitted curves are kept separately, near the bottom of the Measurements page. Do not use them to decide a purchase — they are estimates, not numbers we measured.

How this relates to monthly compute time

Plans are metered as a single monthly compute time (Basic 5 h · Plus 15 · Pro 30 · Pro+ 60 · Max 120 h per month). Every feature runs without a GPU — structure prediction and docking are only slower, and deductions follow the reference-PC table. If you run short, an extra-time pack (50% of the monthly time, one per billing cycle) adds more. Deductions follow the table for our reference PC, so a slower PC of yours is not charged more.

Work	Counted per	Deduction
ADMET panel	molecule	0.4 s
DDI, comparison, trial lookup	item	0.7 s
Docking	molecule	11.1 s
Candidate campaign (binding · cell · ADMET together)	one run + each molecule × target × cell combination	20 s + 0.03 s per combination (10,000 molecules ≈ 5 min)
Screening campaign · molecule generation · synthesis route	one run	20 s
Structure prediction, 100 residues or fewer	one run	60 s
Structure prediction, 101–150 residues	one run	90 s
Structure prediction, 151–260 residues	one run	180 s
Structure prediction, 261–350 residues	one run	300 s
Structure prediction, 351–450 residues	one run	480 s
Structure prediction, 451 residues or more	one run	1,140 s (longer proteins are charged this value too — the actual CPU time is longer: about 1 h at 800 residues and 2 h 54 min at 1,200)

Reference PC: AMD Ryzen 5 9600X 6 cores · 31 GB RAM · native Windows (measured 2026-10-16). For example, Basic's 5 hours a month is roughly 60 structure predictions at 300 residues, or about 1,600 molecules of docking. Conversations with the AI assistant do not use compute time — it helps you use the program and read results, and does no scientific computation itself.

How to check what your own PC can do, after installing

The program reads that PC's GPU model, memory and driver version and shows the protein length possible on this PC. Before a structure prediction starts it tells you the expected time, and it asks for confirmation on anything over five minutes. For a length we never measured it says so and asks — it does not show a plausible-looking estimate instead.

Within 7 days of your first payment we refund the compute time you have not used (Refund Policy). You can check the fit before paying with the free demo.