Introduction

Watch smoke rise, a river braid around a rock, or cream swirl into coffee. All of it is governed by the Navier-Stokes equations, written down in the 1840s by Claude-Louis Navier and George Gabriel Stokes. They are Newton's law for a fluid: mass is conserved, and every parcel of liquid accelerates in response to pressure, friction and the push of its neighbours.

Engineers trust these equations completely. They design airplane wings, predict the weather, and model blood flow with them every single day. And yet there is a question about them so basic, and so stubborn, that the Clay Mathematics Institute put a $1,000,000 prize on it in 2000.

The question is almost childishly simple to state: in three dimensions, if you start a fluid off smoothly, does it stay smooth forever — or can the speed somewhere blow up to infinity in finite time? A hundred and eighty years after the equations were written, nobody knows.

Stir Up Turbulence

Here is a small 2D fluid. Drag the pointer across it to inject motion and watch how a clean push breaks up into curling vortices — the swirling eddies that are the signature of turbulence.

<p class="hint">A tiny <b>2D fluid</b>. <b>Drag</b> across the canvas to push the liquid and inject swirl, then watch a clean stroke break up into curling <b>vortices</b> — the fingerprint of turbulence. In 2D this stays smooth forever; in 3D, whether it can blow up is a million-dollar open question.</p>
<canvas id="fluid" width="240" height="240"></canvas>
<div class="status" id="status">Drag across the fluid to stir it.</div>
<div class="btns">
  <button id="stir" type="button">Auto-stir</button>
  <button id="reset" type="button" class="ghost">Calm the fluid</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 .7rem; line-height: 1.45; }
#fluid { width: 240px; height: 240px; border-radius: 10px; border: 1px solid #cdd9e3;
         background: #0b1b2b; touch-action: none; cursor: crosshair; display: block; }
.status { font-size: 1rem; font-weight: 600; margin: .6rem 0; min-height: 1.4em; color: #1d3557; }
.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; }

// A minimal 2D incompressible-fluid feel: we advect a scalar "dye" field and a velocity field on a grid. Dragging adds momentum; the field is diffused and advected each frame, so a straight push curls into vortices. This is the 2D case — provably smooth for all time (Ladyzhenskaya). The 3D version is the open Navier-Stokes Millennium Problem (Clay Institute, 2000).
const N = 48;                 // grid resolution
const cv = document.getElementById('fluid');
const ctx = cv.getContext('2d');
const SC = cv.width / N;

let vx, vy, dye;              // velocity x/y and dye fields, size N*N
function blank(){ return new Float32Array(N*N); }
function reset(){ vx = blank(); vy = blank(); dye = blank(); }
reset();

const idx = (i,j) => i + j*N;

// Semi-Lagrangian advection: trace each cell back along the velocity field.
function advect(field){
  const out = new Float32Array(N*N);
  for(let j=0;j<N;j++) for(let i=0;i<N;i++){
    let x = i - vx[idx(i,j)]*0.6;
    let y = j - vy[idx(i,j)]*0.6;
    x = Math.max(0.5, Math.min(N-1.5, x));
    y = Math.max(0.5, Math.min(N-1.5, y));
    const i0=Math.floor(x), j0=Math.floor(y), i1=i0+1, j1=j0+1;
    const sx=x-i0, sy=y-j0;
    out[idx(i,j)] =
      (1-sx)*((1-sy)*field[idx(i0,j0)] + sy*field[idx(i0,j1)]) +
          sx*((1-sy)*field[idx(i1,j0)] + sy*field[idx(i1,j1)]);
  }
  return out;
}

// Light diffusion = viscosity. Averages each cell toward its neighbours.
function diffuse(field, amt){
  const out = new Float32Array(N*N);
  for(let j=0;j<N;j++) for(let i=0;i<N;i++){
    const c = field[idx(i,j)];
    const l = field[idx(Math.max(0,i-1),j)];
    const r = field[idx(Math.min(N-1,i+1),j)];
    const u = field[idx(i,Math.max(0,j-1))];
    const d = field[idx(i,Math.min(N-1,j+1))];
    out[idx(i,j)] = c + amt*((l+r+u+d)/4 - c);
  }
  return out;
}

function step(){
  vx = advect(vx); vy = advect(vy);
  vx = diffuse(vx, 0.18); vy = diffuse(vy, 0.18);
  dye = advect(dye);
  dye = diffuse(dye, 0.06);
  for(let k=0;k<N*N;k++){ vx[k]*=0.992; vy[k]*=0.992; dye[k]*=0.985; }
}

function render(){
  const img = ctx.createImageData(cv.width, cv.height);
  for(let py=0;py<cv.height;py++) for(let px=0;px<cv.width;px++){
    const i = Math.min(N-1, Math.floor(px/SC));
    const j = Math.min(N-1, Math.floor(py/SC));
    const d = Math.min(1, dye[idx(i,j)]);
    const speed = Math.min(1, Math.hypot(vx[idx(i,j)], vy[idx(i,j)])*0.5);
    const o = (px + py*cv.width)*4;
    img.data[o]   = 20 + 235*d*(0.4+0.6*speed);
    img.data[o+1] = 40 + 150*d + 60*speed;
    img.data[o+2] = 60 + 180*d + 120*(1-speed)*d;
    img.data[o+3] = 255;
  }
  ctx.putImageData(img, 0, 0);
}

// Inject momentum + dye in a small blob around the pointer.
function splat(i, j, fx, fy){
  const R = 3;
  for(let dj=-R;dj<=R;dj++) for(let di=-R;di<=R;di++){
    const ni=i+di, nj=j+dj;
    if(ni<0||ni>=N||nj<0||nj>=N) continue;
    const w = Math.exp(-(di*di+dj*dj)/4);
    vx[idx(ni,nj)] += fx*w;
    vy[idx(ni,nj)] += fy*w;
    dye[idx(ni,nj)] = Math.min(1, dye[idx(ni,nj)] + w);
  }
}

let dragging=false, lastI=0, lastJ=0;
function toGrid(e){
  const rect = cv.getBoundingClientRect();
  const t = e.touches ? e.touches[0] : e;
  return [ ((t.clientX-rect.left)/rect.width)*N, ((t.clientY-rect.top)/rect.height)*N ];
}
function down(e){ e.preventDefault(); dragging=true; const [i,j]=toGrid(e); lastI=i; lastJ=j;
  setStatus('Keep dragging — watch the swirl form.'); }
function move(e){ if(!dragging) return; e.preventDefault();
  const [i,j]=toGrid(e); splat(Math.floor(i), Math.floor(j), (i-lastI)*4, (j-lastJ)*4);
  lastI=i; lastJ=j; }
function up(){ dragging=false; }
cv.addEventListener('mousedown', down); cv.addEventListener('mousemove', move);
window.addEventListener('mouseup', up);
cv.addEventListener('touchstart', down); cv.addEventListener('touchmove', move);
window.addEventListener('touchend', up);

function setStatus(t){ document.getElementById('status').textContent = t; }

// Auto-stir: a moving source that quickly turns laminar push into vortices.
let auto=0;
document.getElementById('stir').addEventListener('click', ()=>{ auto = 140;
  setStatus('Auto-stirring — laminar flow is breaking into eddies.'); });
document.getElementById('reset').addEventListener('click', ()=>{ reset();
  setStatus('The fluid is calm again. Drag to stir.'); });

function loop(){
  if(auto>0){ const t = (140-auto)*0.12;
    const i = Math.floor(N/2 + Math.cos(t)*N*0.28);
    const j = Math.floor(N/2 + Math.sin(t*1.3)*N*0.28);
    splat(i, j, -Math.sin(t)*6, Math.cos(t)*6);
    auto--;
    if(auto===0) setStatus('Order dissolved into turbulence. In 2D it stays smooth forever.');
  }
  step(); render();
  requestAnimationFrame(loop);
}
loop();
Result
Console

This little simulation is honest about one thing: it lives in two dimensions, and in 2D mathematicians have proven the flow stays smooth forever — no blow-up, ever (Ladyzhenskaya, 1960s). The whole drama of the Millennium Problem is that the very same equations in three dimensions gain a mechanism called vortex stretching that 2D simply doesn't have, and nobody can rule out that it concentrates energy into a single point and tears the solution apart. Watch the eddies; now imagine them able to stretch and sharpen without limit.

The Real Complexity

So what exactly is open? Let's be precise about the status.

  • 2D is fully understood. For a fluid confined to a plane, Olga Ladyzhenskaya and others proved decades ago that smooth initial data gives a smooth solution for all time. Solved.
  • 3D, short time: also fine. Start smoothly in three dimensions and the solution provably stays smooth for at least a little while.
  • 3D, all time: this is the open question. Nobody can prove the solution never develops a singularity — a point where velocity or its gradient races to infinity in finite time. Nor can anyone produce an example where it does.
  • Weak solutions exist, but might not be unique or smooth. Jean Leray showed in 1934 that rough "weak" solutions always exist; what's missing is proving they are smooth and unique. That gap is the whole problem.

The culprit is vortex stretching: in 3D, swirling tubes of fluid can stretch and spin faster, feeding energy into ever-smaller scales. The dissipating friction (viscosity) fights back. Status: OPEN — it is one of the seven Clay Millennium Prize Problems, posed in 2000, and like P vs NP it remains unclaimed. We don't even know whether the answer is "always smooth" or "sometimes blows up."

Where It Matters

You might think an unsolved equation would be useless. The opposite is true — Navier-Stokes is one of the most consequential tools in all of science and engineering:

  • Weather and climate: every forecast and every climate model integrates these equations across the atmosphere and oceans.
  • Aerodynamics: aircraft wings, car shapes and rocket nozzles are all designed by simulating the flow around them.
  • Medicine: blood flow through arteries and air through lungs is modelled to plan surgeries and design devices.
  • The turbulence enigma: predicting turbulence — the chaotic, multi-scale flow you stirred up above — is so hard it is often called the most important unsolved problem in classical physics.

Because we can't prove solutions stay smooth, every large simulation lives with a quiet question mark: when the model sharpens toward a singularity, is that real physics or numerical illusion? That uncertainty connects fluid dynamics to the broader story of computational limits — places where we can compute an answer long before we can prove it is the right one.

Conclusion

The Navier-Stokes equations carry a strange double life. They are accurate enough to fly an airliner across an ocean, yet a century and a half later mathematicians cannot prove that, in three dimensions, they never produce infinite speed out of perfectly gentle beginnings.

That is the rare honesty of an open problem: not proven impossible, not yet solved, just genuinely unknown. So the next time you watch a vortex curl off the back of a spoon, remember you are looking at the smooth, well-behaved case — and that whether its three-dimensional cousins can ever tear themselves apart is a $1,000,000 question that, like P vs NP, is still waiting for an answer.

Share this article

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

Comments

Loading comments...

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