Why does developing a medicine need computer scientists? Drug discovery brings to mind laboratories observing cells and testing substances. Yet difficult choices come before any experiment: which disease-related process to change, which substances to test, and what to investigate first with limited time and money.
As candidates and data accumulate, those choices require several kinds of expertise. Biology explains processes in living systems; chemistry addresses substances and reactions; statistics and computer science provide ways to find patterns and compare possibilities. Combining methods and judgment from different disciplines around one research question is interdisciplinary research.
Life science has long developed alongside other fields. What deserves attention now is that computation goes beyond organizing research data: it increasingly shapes which experiments are performed. If calculations select candidates, judging whether those calculations are trustworthy becomes part of the research.
Choosing a drug candidate already brings disciplines together
Consider finding a substance that modulates a disease-related protein. Proteins perform many functions, including transmitting signals and facilitating chemical reactions. Researchers hypothesize which protein could be affected to help treat a disease. This biological object is called the target.
They may then calculate where and how candidate molecules could bind. Before making and testing substances, this helps prioritize candidates. Computational biology, which studies living systems through data, mathematical models, and computation, participates in this process. A candidate that looks promising computationally still needs experiments to establish binding, desired activity, and safety.
Joint judgment begins with deciding what data to supply. Choosing protein regions and experimental reference data requires biological understanding. Converting that data to computational inputs, selecting models, and assessing errors require computer science, mathematics, and statistics. Changing the input changes the calculation; interpreting the result can prompt reconsideration of the original biological assumptions.
Collaboration therefore does not end when a laboratory question is handed to a computer. Calculations change the next experiment, and experimental data changes models and analysis methods. One person may span several fields, but the team needs the ability to understand and judge those connections.
Questions, inputs and computational conditions, interpretation, and experiments form one workflow. This is an explanatory diagram, not molecular structure data or experimental results.
Another question emerged while reviewing 20 research tools
The need for collaboration also appeared while preparing actual tools. We recently reviewed Nadoo Bio's 20-tool catalog and validated individual execution environments. Listing a tool, completing a run with a specified input, and deciding whether the output supports research were separate achievements.
Some programs failed even on recent hardware. Comparing results also required examining how numbers were calculated. When computers become research instruments, understanding their operating conditions becomes research expertise too. CPU/GPU differences and numerical precision make this concrete.
CPU and GPU modes can differ in more than speed
CPUs and GPUs both compute. CPUs handle varied tasks and complex control flow; GPUs excel at large amounts of similar work in parallel. Moving every biological research tool to a GPU is not automatically beneficial. Data preparation and some sequence analyses may suit CPUs, while AI models repeating many multiplications and additions may benefit from GPUs. A sequence is the ordered set of building blocks in a protein or DNA. Actual benefits depend on implementation and input size.
For research, pay particular attention to execution paths. CPU and GPU modes can use different mathematical libraries or kernels. A kernel is a small program that performs an operation on a device. Different batching or addition orders can change the final digits. PyTorch, widely used for AI computation, does not guarantee bitwise-identical CPU and GPU results even with the same inputs. [1]
This does not make CPU output always correct and GPU output approximate. What matters is the actual data type and algorithm used on each path. Nor does specifying “GPU” prove that the whole workflow ran there. CPU preprocessing followed by GPU model computation is common.
A comparison therefore needs more than a record that the same file was supplied. Record whether preprocessing and model settings matched, whether learned model weights were the same version, and which device ran each stage. First establish that the same research question is being compared.
An older model did not run immediately on a new Blackwell GPU
Our RFantibody validation illustrates this. RFantibody designs structures and sequences for antibody candidates; antibodies are proteins that recognize and bind particular targets. Blackwell names an NVIDIA GPU architecture family, while CUDA provides software for computing on NVIDIA GPUs. In the October 22, 2026 record, the original CUDA 11.8/PyTorch 2.3.1 combination stopped on a Blackwell device with no kernel image is available. It lacked GPU code executable on that device.
Switching to PyTorch 2.7.0+cu128 still failed once more. The uv run launcher restored the older PyTorch according to the recorded installation specification. The example pipeline completed only after preventing that version rollback at execution time. Chai-1 validation on October 24 likewise required resolving a conflict between its package's PyTorch constraints and the selected Blackwell environment.
Why new hardware does not automatically run a research tool
Buying a recent GPU or renting a cloud GPU server does not make research software immediately runnable. The installed program must contain code for that device, and drivers and computational libraries must be compatible. Labels such as sm_120, CUDA, and cu128 describe different parts of this relationship.
sm_120 identifies a target for GPU executable code. The 120 refers to NVIDIA compute capability 12.0. It identifies supported device features and instructions, not a performance score of 120. [2]
CUDA provides the software foundation for developing and running programs on NVIDIA GPUs. The CUDA Toolkit contains a compiler and computational libraries, among other components. A driver is also required to control the GPU from the operating system. Hardware, drivers, development tools, and runtime libraries are related but distinct. [7]
cu128 identifies a PyTorch package built for CUDA 12.8. While sm_120 describes device capabilities targeted by executable code, cu128 describes the software package to install. PyTorch 2.7 introduced this package together with Blackwell support. [3]
Component | Role | Compatibility question |
|---|---|---|
GPU and | Device and architecture targeted by executable code | Is code executable on this GPU included? |
GPU driver | Controls the device through the operating system | Does it support the intended CUDA runtime? |
CUDA environment | Software foundation for GPU computation | Are driver and computational libraries compatible? |
PyTorch | Framework built for the CUDA 12.8 family | Does it support the GPU and the tool's extension modules? |
Research program | Runs the model and analysis | Does this input and execution path work with that combination? |
Not every Blackwell device is sm_120. NVIDIA's table lists RTX PRO 4000 Blackwell and RTX 5090 as 12.0, B200 as 10.0, and GB10 as 12.1. A shared generation name does not establish identical execution requirements. [2]
Installing a cu128 package also does not automatically make separately used extensions compatible. As NVIDIA explains, either executable code for the device or compatible code that can be translated for it at runtime is needed. The latter intermediate representation is called PTX. [4]
Researchers already invest time in questions, data, and interpretation. Finding GPU-compatible packages, resolving dependencies, and tracking version rollbacks adds a burden before research begins. Cloud services reduce the effort of acquiring hardware, but do not automatically guarantee compatibility between rented hardware and research software.
That is why biology researchers and computing/infrastructure specialists need to collaborate. Researchers judge meaningful inputs and outcomes; environment specialists configure and record consistent execution. Together, they must distinguish input problems, model limitations, and installation failures to move the work forward.
GPU model, software build, and actual kernel each require verification. These cases establish execution success for particular inputs, not predictive accuracy across all research conditions.
When researchers must also build the execution environment
Researchers already read papers, form hypotheses, design experiments, and interpret data. Matching driver and package versions, tracing errors, and adjusting settings for limited memory add considerable work when adopting a computational tool.
In the RFantibody example, changing the biological input could not fix the installation rollback. Time spent on that issue delayed examination of the candidates themselves. Even after successful execution, moving to another computer or updating a library can require verification again.
Interdisciplinary research does not mean that one researcher must independently handle biology, computer science, and infrastructure operations. Teams need ways to connect expertise and jointly maintain recurring environment preparation. Computer scientists can investigate models, algorithms, and numerical computation; research software and infrastructure engineers can maintain installation, execution, and records. Roles may overlap, but responsibilities for scientific questions and operational work should remain clear.
Researchers should not need to rebuild the environment from scratch each time, yet must be able to inspect the computational conditions. Interpreting results together on that foundation is a practical form of collaboration. Reducing setup work should not hide information needed for interpretation.
What FP16 and FP32 change
Once compatibility is resolved, the next question concerns numbers. FP16 and FP32 are floating-point formats, not instruction names: they store numbers in 16 and 32 bits, respectively. Floating point divides representation between scale and significant digits. Actual calculation also involves processing instructions, software, and accumulation of intermediate results.
Computers cannot represent every real number exactly. They round to values representable with a fixed number of bits. FP16 uses less space than FP32 but has more limited range and spacing between representable values. A small arithmetic example makes this visible.
Educational example: calculate 2048 + 1 - 2048, storing each operation's result in the specified format and rounding to the nearest value, with ties going to the even significand. These numbers are not protein scores or experimental measurements.
Step | FP16 | FP32 |
|---|---|---|
Calculate and store | 2048 | 2049 |
Subtract 2048 from the stored value | 0 | 1 |
In FP16, the next representable value above 2048 is 2050. The midpoint, 2049, rounds to 2048 under this rule. The lost 1 cannot be recovered later. Identical inputs and formulas can therefore produce different results because of storage format.
Order matters too. In the same FP16 format, evaluating the parentheses first in 2048 + (1 - 2048) gives 1. A fused multiply-add (FMA) instruction also rounds a different number of times than separate multiplication and addition, potentially changing the result. FMA may be closer to the exact mathematical value. This is a property of numerical computation, including on CPUs, rather than evidence of a faulty GPU or manipulated data. [5]
The example rounds to the specified format at each step. Real models may accumulate intermediates at higher precision; this diagram does not describe every FP16 model.
AI models may use mixed precision, for example lower-precision multiplication with FP32 accumulation. BF16 also uses 16 bits, but allocates bits differently between range and detail. TF32 reduces input precision for certain matrix operations on supported GPUs. Recording “FP32 input” alone therefore does not establish the precision of every internal operation. [1]
Lower precision can reduce memory or improve speed. The concern is using it without checking whether it preserves the outcomes required for the research question, rather than lower precision itself.
Do numerical differences change research decisions?
Computer scientists can trace data types, kernels, randomness, and parallel execution, investigating differences through numerical analysis. Biology and drug discovery researchers judge their implications for candidate selection and follow-up experiments. One person may cover both perspectives, but a team needs both.
In a hypothetical case, two candidate scores are very close. If environment-dependent variation exceeds their difference, one run cannot firmly establish first and second place. Examine more than changed decimal digits: assess candidate ranking, selection-threshold decisions, and stability of the structural region of interest.
A single tolerance cannot cover all outputs. Classifications, energy values, and atomic coordinates have different meanings and units. Establish task-appropriate comparisons, then compare a reference run with the changed environment. FP32 can serve as a reference without becoming biological ground truth.
Structural prediction confidence concerns confidence in the proposed shape. It is not binding strength or drug efficacy. Establishing a small computational difference, judging a predicted structure plausible, and experimentally demonstrating binding are distinct forms of evidence.
Overlaid lines and candidate cards illustrate a comparison method. They are not measured data or an accuracy plot for a particular model.
In the cloud, computational conditions become research records
Cloud computing rents external resources over the internet. Teams can use servers and GPUs without buying hardware. If a service provides only a virtual server or GPU, users may still be responsible for operating systems, libraries, model setup, and troubleshooting.
Access to hardware differs from access to a prepared research environment. Managed environments and shared infrastructure can reduce the burden. They should still identify which combinations of models, input ranges, and devices were actually verified. Renting a GPU does not make research conditions identical: device software, models, weights, and precision settings also affect comparability.
Record the seed too. A seed initializes random-number generation and helps compare candidate generation or sampling again. However, matching seeds does not guarantee identical outcomes across CPUs, GPUs, or library versions. [6]
Teams need more than an undifferentiated collection of operational logs: they need links that reconstruct which inputs were calculated with which model, environment, and conditions. Retain original inputs and preprocessing, model/weight versions, execution images, devices, precision, seeds, and output files. Error and retry history explains how a successful result was produced.
Cost also connects to research design. Running many candidates once and fewer candidates repeatedly under varied conditions are different studies. Total runtime and failure/retry costs help decide where to allocate resources. This is where expertise in faster computation meets expertise in choosing questions worth repeating.
Keeping inputs, environments, results, and retries together makes changed conditions traceable. This diagram illustrates records useful to a research team.
Deciding together what to trust
Compatibility and rounding can look like installation or number-processing issues. But if those calculations select experiments, the team needs a shared understanding of what was compared and how far the evidence goes. Computational conditions cannot be neatly separated from biological interpretation.
Collaboration needs to go beyond researchers handing over questions and engineers starting servers. Together, define the inputs that express the question, agree what to fix and compare before running, and judge whether numerical differences are meaningful enough to change the next experiment.
A well-defined biological question makes computation useful; a validated computational process makes its output interpretable. Experimental findings then prompt reconsideration of model assumptions and evaluation criteria. Biology and computer science must collaborate in drug discovery not merely to calculate more, but to share responsibility for deciding which calculations justify the next experiment.
References
PyTorch. Numerical accuracy. Official 2.9 documentation: CPU/GPU differences, TF32, and FP16/BF16 intermediate accumulation. Checked October 25, 2026.
NVIDIA. CUDA GPU Compute Capability. Official device capability table. Checked October 25, 2026.
PyTorch Team. PyTorch 2.7 Release. Official release announcement, April 23, 2025; Blackwell and CUDA 12.8 support. Checked October 25, 2026.
NVIDIA. Blackwell Compatibility Guide. Official binary and PTX compatibility guidance. Checked October 25, 2026.
NVIDIA. Floating Point and IEEE 754. Official technical documentation, sections 2.1–2.3: representation, operation order, and FMA. Checked October 25, 2026.
PyTorch. Reproducibility. Official 2.9 documentation: randomness control and cross-environment limits. Checked October 25, 2026.
NVIDIA. NVIDIA CUDA Toolkit. Official product/developer documentation: compiler, libraries, and runtime components. Checked October 25, 2026.