Introduction

Point a computer at a drop of water, a protein, or a chunk of metal and ask it a simple question: what happens next? Molecular dynamics (MD) answers it the way Newton would. Every atom feels a force from every neighbor — a push when too close, a gentle pull when just far enough — and force means acceleration. Know where the atoms are, compute the forces, nudge them forward a sliver of time, and repeat.

That sliver is tiny: a single step usually spans about a femtosecond (10−1510^{-15} seconds), because atoms vibrate that fast and a bigger step would let them fly through each other. So a microsecond of real life — the blink it takes a small protein to fold — is a billion steps, each one touching every atom.

The beautiful part: the recipe is exact in principle. There is no guessing, no approximation in the bookkeeping — just Newton's law applied over and over. The brutal part is everything that word "over" hides.

Simulate the Atoms

Here are a few particles scattered in a box. Each pair pushes apart when too close and pulls together when slightly too far — the classic Lennard-Jones force. Press Play and the simulation steps time forward with the velocity-Verlet integrator, the workhorse of real MD codes.

<p class="hint">A handful of particles in a box. Each pair pushes apart when too close and pulls together when slightly too far (the Lennard-Jones force). Press <b>Play</b> to step time forward with velocity-Verlet. Turn on <b>Cooling</b> and they settle into a compact cluster — the lowest-energy structure.</p>
<canvas id="stage" width="320" height="260"></canvas>
<div class="readout" id="readout">Step 0 · energy —</div>
<div class="btns">
  <button id="play" type="button">Play</button>
  <button id="cool" type="button" class="ghost">Cooling: off</button>
  <button id="reset" type="button" class="ghost">Reset</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
canvas { background: #0e1726; border-radius: 10px; display: block; width: 100%; max-width: 320px; }
.readout { font: 600 14px ui-monospace, monospace; color: #1d3557; margin: .5rem 0; min-height: 1.3em; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button.on { background: #0a7d33; border-color: #0a7d33; color: #fff; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Molecular dynamics in 2D with the velocity-Verlet integrator and a Lennard-Jones pair force. The recipe is EXACT in principle: compute forces, half-kick the velocities, drift the positions, recompute forces, half-kick again. With no cooling it conserves energy (it just explores); with cooling it drains kinetic energy and settles into the minimum-energy cluster.
const cv = document.getElementById('stage'), ctx = cv.getContext('2d');
const W = cv.width, H = cv.height;
const EPS = 1.0, SIG = 16, RC = 2.8 * SIG; // SIG in pixels
const DT = 0.45;                            // time step (one frame = one step)
let pos, vel, cooling = false, running = false, steps = 0, raf = null;

function seedSystem() {
  // loose grid so no pair starts overlapping (keeps forces — and energy — sane)
  pos = []; vel = []; let s = 7;
  const rnd = () => { s = (s * 1103515245 + 12345) & 0x7fffffff; return s / 0x7fffffff; };
  let k = 0;
  for (let r = 0; r < 3 && k < 7; r++)
    for (let c = 0; c < 3 && k < 7; c++) {
      pos.push([90 + c * SIG * 1.6 + rnd() * 6, 70 + r * SIG * 1.6 + rnd() * 6]);
      vel.push([(rnd() - 0.5) * 2.2, (rnd() - 0.5) * 2.2]);
      k++;
    }
  steps = 0;
}

// forces[i] and total potential energy from the Lennard-Jones pair potential
function compute() {
  const n = pos.length, f = pos.map(() => [0, 0]); let pe = 0;
  for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
    let dx = pos[i][0] - pos[j][0], dy = pos[i][1] - pos[j][1];
    let r2 = dx * dx + dy * dy;
    if (r2 < RC * RC && r2 > 1) {
      const inv = 1 / r2, s2 = SIG * SIG * inv, s6 = s2 * s2 * s2, s12 = s6 * s6;
      pe += 4 * EPS * (s12 - s6);
      const fr = 24 * EPS * (2 * s12 - s6) * inv; // (-dU/dr)/r
      f[i][0] += fr * dx; f[i][1] += fr * dy;
      f[j][0] -= fr * dx; f[j][1] -= fr * dy;
    }
  }
  return [f, pe];
}
const kinetic = () => vel.reduce((a, v) => a + 0.5 * (v[0] * v[0] + v[1] * v[1]), 0);

let F = null;
function step() {
  if (!F) [F] = compute();
  const n = pos.length;
  for (let i = 0; i < n; i++) {            // half kick + drift
    vel[i][0] += 0.5 * DT * F[i][0]; vel[i][1] += 0.5 * DT * F[i][1];
    pos[i][0] += DT * vel[i][0];      pos[i][1] += DT * vel[i][1];
    // reflect off the soft walls so nothing escapes the box
    if (pos[i][0] < 10) { pos[i][0] = 10; vel[i][0] *= -1; }
    if (pos[i][0] > W - 10) { pos[i][0] = W - 10; vel[i][0] *= -1; }
    if (pos[i][1] < 10) { pos[i][1] = 10; vel[i][1] *= -1; }
    if (pos[i][1] > H - 10) { pos[i][1] = H - 10; vel[i][1] *= -1; }
  }
  let pe; [F, pe] = compute();
  for (let i = 0; i < n; i++) {            // second half kick
    vel[i][0] += 0.5 * DT * F[i][0]; vel[i][1] += 0.5 * DT * F[i][1];
    if (cooling) { vel[i][0] *= 0.96; vel[i][1] *= 0.96; }
  }
  steps++;
  const E = kinetic() + pe;
  document.getElementById('readout').textContent =
    fmt('Step %steps% · energy %E%%v%', { steps: steps, E: E.toFixed(1), v: cooling ? ' · cooling' : '' });
}

function draw() {
  ctx.clearRect(0, 0, W, H);
  // bonds between near neighbors, then atoms
  ctx.strokeStyle = 'rgba(120,170,255,.35)'; ctx.lineWidth = 2;
  for (let i = 0; i < pos.length; i++) for (let j = i + 1; j < pos.length; j++) {
    const dx = pos[i][0] - pos[j][0], dy = pos[i][1] - pos[j][1];
    if (dx * dx + dy * dy < (1.5 * SIG) * (1.5 * SIG)) {
      ctx.beginPath(); ctx.moveTo(pos[i][0], pos[i][1]); ctx.lineTo(pos[j][0], pos[j][1]); ctx.stroke();
    }
  }
  for (const p of pos) {
    const g = ctx.createRadialGradient(p[0] - 3, p[1] - 3, 2, p[0], p[1], SIG / 2);
    g.addColorStop(0, '#7fd0ff'); g.addColorStop(1, '#2a6fb0');
    ctx.fillStyle = g;
    ctx.beginPath(); ctx.arc(p[0], p[1], SIG / 2, 0, 7); ctx.fill();
  }
}

function loop() { if (!running) return; step(); draw(); raf = requestAnimationFrame(loop); }
function reset() { running = false; if (raf) cancelAnimationFrame(raf); F = null;
  seedSystem(); draw(); document.getElementById('play').textContent = 'Play';
  document.getElementById('readout').textContent = 'Step 0 · energy —'; }

document.getElementById('play').addEventListener('click', e => {
  running = !running; e.target.textContent = running ? 'Pause' : 'Play';
  if (running) loop();
});
document.getElementById('cool').addEventListener('click', e => {
  cooling = !cooling; e.target.textContent = fmt('Cooling: %v%', { v: cooling ? 'on' : 'off' });
  e.target.classList.toggle('on', cooling);
});
document.getElementById('reset').addEventListener('click', reset);
seedSystem(); draw();
Result
Console

Turn on Cooling and the jiggling drains away: the particles slide downhill in energy and settle into a compact, ordered cluster — a tiny crystal — exactly the structure that minimizes their potential energy. Watch the energy readout. Without cooling the total energy barely drifts (the integrator conserves it); the system just explores. Every frame is one step, and you are watching a few dozen of them. A real run needs billions.

The Real Complexity

So how hard is molecular dynamics, really? It splits into two very different costs.

  • One step is easy and exact. Computing the forces on n atoms is straightforward — naively n2n^{2} pair interactions, and with neighbor lists and tree methods close to O(nlog⁡n)O(n \log n). Velocity-Verlet then moves everyone forward and conserves energy almost perfectly. This part is firmly in P.
  • The number of steps is the wall. Femtosecond steps mean a microsecond costs a billion iterations; a millisecond — the timescale of many real biological events — costs a trillion. This timescale gap is the practical enemy. Worse, tiny rounding differences amplify (the systems are chaotic), so individual trajectories diverge and only statistics over many runs are trustworthy.
  • The forces themselves are an approximation. Classical MD uses hand-tuned force fields. To get them right you must solve quantum mechanics for the electrons — and deciding the ground-state energy of a general local Hamiltonian is QMA-complete (Kitaev, 1999; Kempe–Kitaev–Regev, 2006), the quantum analogue of NP-complete. That is believed to be intractable even for quantum computers in the worst case.

That is the punchline: the algorithm is exact and polynomial per step, yet honest simulation runs straight into the exponential cost of quantum systems. MD is what you do when "just integrate Newton's law" is correct but "just run it long enough" is impossible.

Where It Matters

Because it shows atoms moving when no microscope can, molecular dynamics quietly powers a lot of science and industry:

  • Drug discovery: watching how a candidate molecule wiggles into a protein pocket guides which compounds are worth synthesizing.
  • Protein folding and biology: MD complements the structure-prediction problem, revealing the motion a folded protein actually performs.
  • Materials and batteries: simulating how atoms diffuse, crack or crystallize helps design alloys, electrolytes and semiconductors before building them.
  • Specialized hardware: the timescale gap is so severe that purpose-built machines (and GPU clusters) exist just to push MD a few orders of magnitude further.

In every case the appeal is the same: an experiment you can pause, rewind and inspect atom by atom — paid for with an avalanche of arithmetic.

Conclusion

Molecular dynamics is a rare kind of problem: the method is right, not approximate in its core logic. Give it positions and forces and it tells you what the atoms do, step by exact step. There is no clever shortcut to discover — the difficulty is not that we don't know how, but that the honest answer demands an avalanche of tiny steps, and getting the forces exactly right reaches down into the intractable world of quantum systems.

So the next time you hear that a supercomputer simulated a protein for a few microseconds, appreciate the scale: that is a billion exact little nudges, each touching every atom. Molecular dynamics is truth you can afford only in small doses — exactness rationed by the clock.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/molecular-dynamics/Content licensed under CC BY-NC 4.0.