Technical blog
Molecular simulations are the backbone of drug discovery and materials science, but they’re notoriously complex.
For example, the pharmaceutical industry spends 15% of its revenue on R&D — more than 20% of the total R&D spend across all other sectors combined — and molecular dynamics is one of the heaviest computational line items in that budget.
Modelling different phenomena demands fundamentally different techniques. Characterizing a single material, for example, can involve chaining several computational methods together, and the number of possible combinations grows quickly as new techniques emerge. For scientists and machine learning researchers, this can create a laborious, clunky workflow: combining several complex software packages, spending hours debugging inconsistencies, and potentially using hundreds of lines of configuration and glue code.
Today, we are excited to open-source kUPS, a molecular simulation engine for the AI era.
kUPS is a toolkit that unifies diverse molecular simulation techniques behind a single composable interface. It gives computational scientists and ML researchers a shared, Python-native platform to run a broad range of simulations that are GPU-native and highly efficient, scaling seamlessly from a single laptop to data center GPUs.
In practice, using kUPS, a researcher can write a custom simulation for a novel use case in an afternoon, rather than taking weeks of effort.

Simulation tools weren’t built for the AI era
Discovering materials requires combining hundreds of thousands of accurate molecular simulations with machine learning to select the most promising candidates for laboratory synthesis. High-throughput computational screening means exploring vast chemical spaces across thousands of simulation runs.
However, a one-size-fits-all approach fails when dealing with diverse phenomena. Researchers use different techniques including molecular dynamics for transport properties like diffusion, Monte Carlo sampling for adsorption equilibria and to predict gas uptake, and geometry optimization for predicting stable structures. Real-world applications rarely call for just one of these in isolation.
This means researchers juggle separate software packages for each method (LAMMPS, GROMACS, RASPA, and others), each with its own input formats, data structures, and assumptions. This fragmentation is costly. Experimenting with a new method typically means writing complex C++ code from scratch for every framework.
The rise of AI has made things harder still. Modern methods like machine-learning force fields, Boltzmann generators, and other learned components need to be deeply embedded in simulations for optimal performance, but traditional simulation packages were built to optimize well-known algorithms for CPUs, rather than GPUs. Their support for GPU-accelerated machine learning is bolted on through rigid interfaces that cannot keep pace with rapid developments in the field. Integrating a PyTorch model into a C++ engine means implementing custom bridges, cross-language memory management, and sacrificing the flexibility that made the model easy to develop in the first place.
Meanwhile, the tools powering AI development (Python, automatic differentiation, GPU-native computation) remain foreign to traditional simulation codes. We built kUPS to close that gap.
A modern foundation for molecular simulations
kUPS is built on three design principles: composability, structured data, and batched execution. Every operation flows through JAX, so simulations run natively on CPU, GPU, and TPU with no code changes.
Working in collaboration with NVIDIA, we have optimized for GPU performance in particular, achieving up to 49× throughput over widely adopted tools like RASPA for certain simulations. And, because many models today live in PyTorch, we also open-source Tojax, a library for transforming PyTorch functions into JAX, meeting developers where they are.
This work is in addition to our ongoing collaboration with NVIDIA on ALCHEMI, their platform for accelerating AI-driven simulation in chemistry and materials science.
“We’ve been working closely with the CuspAI team to help push the boundaries of GPU-accelerated molecular simulation. The ALCHEMI collaboration with CuspAI demonstrates what’s possible when modern simulation software is built natively for accelerated computing. This approach accelerates scientific discovery in unprecedented ways, unlocking the kind of throughput gains that let researchers move from thousands of simulations to millions, and thus from hypothesis to discovery, faster than ever before.”
Composability
To fully characterize a material, scientists often need to link multiple techniques into a single workflow. In traditional tools, each combination means writing new glue code from scratch. kUPS is designed so that any method can be combined with any other by construction.
Every operation follows a single abstraction: propagate a state to its next state. The next state depends only on the current state and a random key. This has practical consequences. Simulations are bitwise reproducible, because replaying the same sequence of keys from a given state always yields identical trajectories. Checkpointing is trivial, since the state is a complete snapshot with no hidden history, and any propagator can be tested in isolation by feeding it a single state.
For scientists, this means fewer hours spent debugging subtle nondeterminism, and more confidence that results will hold up when shared, reproduced, or scaled.

The shared interface is what makes it all composable. In kUPS, an integrator, a thermostat, a Monte Carlo move, a force field evaluation are all propagators. Because they share the same signature, they snap together freely. A new potential works with every existing sampler, and a new sampling method works with every existing potential.
This extends naturally to learned components: a machine-learning force field, a generative model serving as the proposal distribution in a Markov chain Monte Carlo (MCMC) simulation, or a learned large-timestep integrator all plug in through the same abstraction. This could reduce the timeframe for wiring a custom simulation for a novel use case from weeks, to a single afternoon.

Data structure
Molecular simulations involve data at different scales: per-atom positions and forces, per-molecule charges and topologies, per-system temperatures and pressures. Organizing such data in memory and ensuring their efficient use is a challenge for GPUs. When thousands of threads need to read positions simultaneously, scattering that data across separate objects means scattered memory access and idle hardware.

kUPS stores simulation data in Tables, columnar containers where every property shares the same leading dimension. Each row carries a unique key, analogous to a primary key in a SQL database, and tables reference each other through index arrays that act as foreign keys. This gives us structure-of-arrays layout (one contiguous array per property) rather than arrays-of-structures (one object per atom). With many checks and strict type checking, this significantly reduces implementation errors and the manual work of remembering data layouts when implementing new simulations. On GPUs, where performance depends on coalesced memory access across thousands of threads, this layout is the difference between saturating the hardware and wasting it.
Performance
Traditional simulation tools process one system at a time, leaving most of a GPU’s capacity idle. kUPS is built around batching: running many independent systems in parallel as a single vectorized computation. The columnar table layout makes this natural: stacking systems along the leading dimension turns a batch of simulations into a single dense array operation. This is the backbone of our high-throughput workflows and where the performance gains come from.

As an example, we benchmark two representative workloads on a single NVIDIA L4 GPU, using metal-organic frameworks — porous materials with downstream uses including carbon capture — as a test case. We are actively expanding our suite of benchmarks to include further examples across diverse material classes.
First, we explore NVT molecular dynamics of a single 114-atom metal–organic framework (MOF) using the MACE neural network potential. Even without batching, kUPS achieves 1.8× the throughput of ASE, the standard Python interface for running MACE, purely from lower overhead in the simulation loop. Batching multiple systems would increase performance further by saturating the GPU across independent runs.
Second, we look at grand-canonical Monte Carlo (µVT) for CO₂ adsorption in a 3×3×3 supercell of the same framework (3,078 framework atoms, ~30 CO₂ molecules at average loading). RASPA, the most widely used tool for this task, runs on a single CPU core. kUPS replaces it with a fully vectorized GPU implementation, achieving 49× throughput on the same workload. Using kUPS, an entire class of simulations that was architecturally locked to serial CPU execution can now run natively on accelerators.
Putting it together
In a traditional workflow, setting up a molecular dynamics simulation with a machine-learning potential might involve hundreds of lines of configuration spread across multiple files and languages, plus careful glue code to connect the model to the simulation engine. With kUPS, the same simulation takes a few lines of Python. Users can define a data layout, wire up a potential and integrator, and run:
class MyAtoms:
positions: Array
atomic_numbers: Array
...
class MySystems:
unitcell: UnitCell
...
class MyFirstState:
atoms: Table[ParticleId, MyAtoms]
systems: Table[SystemId, MySystems]
mace: MACEModel
...
atoms = MyAtoms(...) # populate atoms
systems = MySystem(...) # populate systems
state = MyFirstState(atoms, systems, ...) # populate state
chain = key_chain(jax.random.key(0)) # random key chain
potential = make_tojaxed_potential_from_state(
identity_lens(MyFirstState), # lens: tells the potential where to find its inputs in the state
compute_position_and_unitcell_gradients=True
)
propagator = make_md_propagator(state_lens, "verlet", potential)
for _ in range(1000):
state = propagator(next(chain), state)Swapping MACE for UMA is a single line change, adding a Monte Carlo move alongside the dynamics — or inserting a learned large-timestep model between integration steps — takes just a few lines more. With traditional tools, changes like these would typically mean switching to an entirely different package and rewriting the simulation from scratch.
Methods and potentials
kUPS ships with a broad set of methods and potentials covering the most common molecular simulation tasks, all built using the same composable abstractions available to any user.
On the sampling side, this includes molecular dynamics ensembles (NVE, NVT, NPT), Monte Carlo methods (NVT, µVT), and geometry optimizers (FIRE, L-BFGS). For interactions, kUPS provides classical potentials such as Lennard-Jones, Coulomb (via Ewald summation), harmonic bonds and angles, and Morse, alongside ML force fields including MACE and UMA. Every built-in method was written with the same public API you would use to build your own, and anything you add will work with every existing component from day one.
Bridging the gap: Tojax
Rather than asking users to rewrite their PyTorch models, we additionally open-source Tojax, a library that converts any PyTorch function into a JAX function with a single line of code.
model = SimpleModel() # any PyTorch nn.Module
jax_model = tojax(model) # → callable in JAX
x = jnp.ones((128, 32, 10))
output = jax.jit(jax.vmap(jax_model))(x) # JAX transformation compatibleA pre-trained MACE, NequIP, or custom PyTorch potential can be brought into kUPS with minimal code changes. With Tojax, the model composes with jit, vmap, grad, and all other JAX transformations, the same ones kUPS relies on for batching and automatic differentiation.
There is no performance penalty: Tojax traces through the PyTorch module and emits a native JAX computation graph, compiled and optimized end-to-end by XLA with no Python-level back-and-forth between frameworks at runtime.
Get started
kUPS and Tojax are open-source. We built them because we needed a simulation toolkit that could keep up with the pace of AI research: one where trying a new idea means writing a few lines of Python, not weeks of C++. One where simulations run natively on GPUs without compromise, and where classical methods, machine-learning potentials, and generative models all live within a single composable framework.
Whether scientists and machine learning researchers are screening millions of materials for carbon capture, semiconductors or catalysts, exploring drug-protein interactions, or developing entirely new simulation methods, we hope kUPS will give them the foundation to move faster.



