The Biot–Savart Law — Magnetic Field of a Current-Carrying Wire

1. The Biot–Savart Law

Consider a wire carrying current I. A tiny element of the wire, of length dl and direction along the current, contributes a magnetic field dB at a field point located a displacement r away:

The cross product means the field is always perpendicular to both the current direction and the line to the field point — magnetic field lines circle around a wire, they never point radially toward or away from it, unlike an electric field around a charge. The total field at any point is the vector sum (integral) of dB over the entire current path.

2. Field of an Infinite Straight Wire

Integrating the Biot–Savart law along an infinite straight wire at perpendicular distance a from the field point gives one of the most useful results in electromagnetism:

The field falls off as 1/a, not 1/a² — because the "source" is an entire infinite line, not a point. Doubling your distance from a long straight wire halves the field, not quarters it. This 1/a scaling is exactly what Ampère's law predicts from symmetry, and it is a useful sanity check for any Biot–Savart numerical integrator: feed it a long straight segment and confirm the field matches μ₀I/(2πa) away from the ends.

3. Field of a Finite Wire Segment

Real simulations use finite segments, not infinite wires. For a straight segment seen from perpendicular distance a, with the two ends subtending angles θ₁ and θ₂ from the perpendicular foot, the closed-form result is:

As the segment's ends go to ±∞, sin θ → ±1 and this reduces exactly to the infinite-wire result μ₀I/(2πa) from Section 2 — a good way to verify the formula. This closed-form expression is fast enough to evaluate per-segment in real time, which is why polygon-approximated wire loops in a simulation use it instead of brute-force numerical quadrature per segment.

4. Field on the Axis of a Circular Current Loop

For a circular loop of radius R carrying current I, the field on the axis at distance z from the loop's center is:

This is the building block for solenoids: stack N loops per unit length and integrate along the solenoid's axis to derive the familiar B = μ₀nI formula for the field deep inside a long solenoid, where n = N/length. It is also the field profile behind every "magnetic field" simulation that lets you drag a current loop and watch the field lines bulge outward on either face.

5. Superposition: Arbitrary Wire Shapes

Because the Biot–Savart law is linear in current, the field of any wire shape — a coil, a braid, a helix, a lightning-bolt fractal — is just the vector sum of the fields from each small straight segment approximating the curve:

This is precisely how a "magnetic field of a wire" simulation is built: the user-drawn or procedurally generated path is broken into N straight segments, and the field at every point on a visualisation grid is the sum of N finite-segment contributions — an O(N) cost per grid point, or O(N·M) for an M-point grid.

6. Numerical Implementation in JavaScript

A general-purpose Biot–Savart solver represents the wire as a polyline (array of 3D points) and sums the finite-segment contribution for each edge:

function segmentField(p1, p2, current, fieldPoint, mu0 = 4 * Math.PI * 1e-7) {
  // Vector along the segment
  const dl = { x: p2.x - p1.x, y: p2.y - p1.y, z: p2.z - p1.z };
  const segLen = Math.hypot(dl.x, dl.y, dl.z);
  const dir = { x: dl.x / segLen, y: dl.y / segLen, z: dl.z / segLen };

  // Perpendicular distance a, and angles theta1/theta2 from the foot of the perpendicular
  const toP1 = { x: fieldPoint.x - p1.x, y: fieldPoint.y - p1.y, z: fieldPoint.z - p1.z };
  const along = toP1.x * dir.x + toP1.y * dir.y + toP1.z * dir.z;
  const perp = {
    x: toP1.x - along * dir.x,
    y: toP1.y - along * dir.y,
    z: toP1.z - along * dir.z
  };
  const a = Math.max(Math.hypot(perp.x, perp.y, perp.z), 1e-6);  // avoid singularity on the wire
  const theta1 = Math.atan2(-along, a);
  const theta2 = Math.atan2(segLen - along, a);

  // Finite-segment closed form: B = (mu0 I / 4 pi a) (sin theta2 - sin theta1)
  const mag = (mu0 * current / (4 * Math.PI * a)) * (Math.sin(theta2) - Math.sin(theta1));

  // Direction: dir x perpUnit gives the azimuthal (circling) direction
  const perpUnit = { x: perp.x / a, y: perp.y / a, z: perp.z / a };
  const circ = {
    x: dir.y * perpUnit.z - dir.z * perpUnit.y,
    y: dir.z * perpUnit.x - dir.x * perpUnit.z,
    z: dir.x * perpUnit.y - dir.y * perpUnit.x
  };
  return { x: mag * circ.x, y: mag * circ.y, z: mag * circ.z };
}

function wireFieldAt(polyline, current, fieldPoint) {
  let total = { x: 0, y: 0, z: 0 };
  for (let i = 0; i < polyline.length - 1; i++) {
    const b = segmentField(polyline[i], polyline[i + 1], current, fieldPoint);
    total.x += b.x; total.y += b.y; total.z += b.z;
  }
  return total;
}

7. Biot–Savart vs. Ampère's Law

In a simulation, Biot–Savart is the workhorse because it needs no symmetry assumption — it works equally well for a straight wire, a solenoid, or a hand-drawn squiggle. Ampère's law is reserved for validating the numerical result against the handful of geometries where a closed-form answer exists.

8. Applications