Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

Imagine a four-way water pipe junction where water never leaks, pools, or compresses. Every gallon of water that rushes into the junction must immediately exit through the outgoing pipes.

Electric circuits operate under this exact same principle because **electric charge** is strictly conserved in every physical process.

How do we translate this fundamental conservation law into a systematic tool for circuit analysis?

A **node** (or junction) is any point in an electrical circuit where two or more circuit branches connect.

**Electric current** ($I$) is the rate of flow of electric charge past a point, defined as $I = \frac{\Delta Q}{\Delta t}$ and measured in amperes (where $1\text{ A} = 1\text{ coulomb per second}$).

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8fafc;
      color: #1e293b;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      height: 100%;
      min-height: 100%;
      padding: 10px;
      overflow: hidden;
    }

    .equation-bar {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 8px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      padding: 6px 14px;
      border-radius: 20px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
      font-size: 15px;
      font-weight: 700;
      letter-spacing: -0.2px;
      flex-shrink: 0;
    }

    .tag-in {
      color: #2563eb;
      background: #eff6ff;
      padding: 2px 8px;
      border-radius: 6px;
      border: 1px solid #bfdbfe;
    }

    .tag-out {
      color: #059669;
      background: #ecfdf5;
      padding: 2px 8px;
      border-radius: 6px;
      border: 1px solid #a7f3d0;
    }

    .eq-sign {
      color: #64748b;
      font-weight: 800;
    }

    .canvas-container {
      position: relative;
      width: 100%;
      flex-grow: 1;
      max-height: 280px;
      display: flex;
      align-items: center;
      justify-content: center;
    }

    canvas {
      width: 100%;
      height: 100%;
      display: block;
    }

    .controls-grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
      width: 100%;
      max-width: 480px;
      flex-shrink: 0;
    }

    .ctrl-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 6px 10px;
      display: flex;
      flex-direction: column;
      gap: 3px;
      box-shadow: 0 1px 2px rgba(0,0,0,0.04);
    }

    .ctrl-head {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-size: 13px;
      font-weight: 700;
    }

    .ctrl-head.c-in { color: #2563eb; }
    .ctrl-head.c-out { color: #059669; }

    .slider {
      -webkit-appearance: none;
      appearance: none;
      width: 100%;
      height: 5px;
      border-radius: 3px;
      background: #e2e8f0;
      outline: none;
      cursor: pointer;
    }

    .slider::-webkit-slider-thumb {
      -webkit-appearance: none;
      appearance: none;
      width: 15px;
      height: 15px;
      border-radius: 50%;
      background: #2563eb;
      cursor: pointer;
      box-shadow: 0 1px 3px rgba(37,99,235,0.4);
    }

    .slider-out::-webkit-slider-thumb {
      background: #059669;
      box-shadow: 0 1px 3px rgba(5,150,105,0.4);
    }

    .slider::-moz-range-thumb {
      width: 15px;
      height: 15px;
      border-radius: 50%;
      background: #2563eb;
      cursor: pointer;
      border: none;
    }

    .slider-out::-moz-range-thumb {
      background: #059669;
    }
  </style>
</head>
<body>

  <div class="equation-bar">
    <span class="tag-in" id="sumInText">Σ I_in = 5 A</span>
    <span class="eq-sign">=</span>
    <span class="tag-out" id="sumOutText">Σ I_out = 5 A</span>
  </div>

  <div class="canvas-container" id="canvasWrapper">
    <canvas id="circuitCanvas"></canvas>
  </div>

  <div class="controls-grid">
    <div class="ctrl-card">
      <div class="ctrl-head c-in">
        <span>I₁ (In)</span>
        <span id="valI1">3 A</span>
      </div>
      <input type="range" class="slider" id="sliderI1" min="1" max="5" step="1" value="3">
    </div>

    <div class="ctrl-card">
      <div class="ctrl-head c-in">
        <span>I₂ (In)</span>
        <span id="valI2">2 A</span>
      </div>
      <input type="range" class="slider" id="sliderI2" min="1" max="5" step="1" value="2">
    </div>

    <div class="ctrl-card">
      <div class="ctrl-head c-out">
        <span>I₃ (Out)</span>
        <span id="valI3">2 A</span>
      </div>
      <input type="range" class="slider slider-out" id="sliderI3" min="1" max="4" step="1" value="2">
    </div>

    <div class="ctrl-card" style="background:#f8fafc; border-style:dashed;">
      <div class="ctrl-head c-out">
        <span>I₄ (Out)</span>
        <span id="valI4">3 A</span>
      </div>
      <div style="font-size:11px; color:#64748b; font-weight:600; padding:3px 0;">Auto-balanced (KCL)</div>
    </div>
  </div>

  <script>
    const canvas = document.getElementById('circuitCanvas');
    const ctx = canvas.getContext('2d');
    const wrapper = document.getElementById('canvasWrapper');

    const sliderI1 = document.getElementById('sliderI1');
    const sliderI2 = document.getElementById('sliderI2');
    const sliderI3 = document.getElementById('sliderI3');

    const valI1 = document.getElementById('valI1');
    const valI2 = document.getElementById('valI2');
    const valI3 = document.getElementById('valI3');
    const valI4 = document.getElementById('valI4');

    const sumInText = document.getElementById('sumInText');
    const sumOutText = document.getElementById('sumOutText');

    let I1 = 3, I2 = 2, I3 = 2, I4 = 3;

    function resize() {
      const rect = wrapper.getBoundingClientRect();
      const dpr = window.devicePixelRatio || 1;
      canvas.width = rect.width * dpr;
      canvas.height = rect.height * dpr;
      ctx.scale(dpr, dpr);
    }
    window.addEventListener('resize', resize);
    resize();

    function updateValues() {
      I1 = parseInt(sliderI1.value, 10);
      I2 = parseInt(sliderI2.value, 10);
      const totalIn = I1 + I2;

      sliderI3.max = totalIn - 1;
      if (parseInt(sliderI3.value, 10) >= totalIn) {
        sliderI3.value = totalIn - 1;
      }
      I3 = parseInt(sliderI3.value, 10);
      I4 = totalIn - I3;

      valI1.textContent = `${I1} A`;
      valI2.textContent = `${I2} A`;
      valI3.textContent = `${I3} A`;
      valI4.textContent = `${I4} A`;

      sumInText.textContent = `Σ I_in = ${totalIn} A`;
      sumOutText.textContent = `Σ I_out = ${totalIn} A`;
    }

    sliderI1.addEventListener('input', updateValues);
    sliderI2.addEventListener('input', updateValues);
    sliderI3.addEventListener('input', updateValues);
    updateValues();

    // Particle flow system
    class Particle {
      constructor(branch, progress = 0) {
        this.branch = branch; // 1: In1, 2: In2, 3: Out1, 4: Out2
        this.progress = progress; // 0 to 1
      }
    }

    const particles = [];
    let spawnTimerIn1 = 0;
    let spawnTimerIn2 = 0;
    let outToggle = 0;

    let lastTime = performance.now();

    function animate(currentTime) {
      const dt = Math.min((currentTime - lastTime) / 1000, 0.1);
      lastTime = currentTime;

      const w = canvas.width / (window.devicePixelRatio || 1);
      const h = canvas.height / (window.devicePixelRatio || 1);

      const cx = w / 2;
      const cy = h / 2;
      const margin = 28;

      const pIn1 = { x: margin, y: h * 0.22 };
      const pIn2 = { x: margin, y: h * 0.78 };
      const pOut1 = { x: w - margin, y: h * 0.22 };
      const pOut2 = { x: w - margin, y: h * 0.78 };

      // Spawn incoming particles based on Current I (charges/sec)
      const baseRate = 1.4;
      spawnTimerIn1 += dt * I1 * baseRate;
      while (spawnTimerIn1 >= 1) {
        particles.push(new Particle(1, 0));
        spawnTimerIn1 -= 1;
      }

      spawnTimerIn2 += dt * I2 * baseRate;
      while (spawnTimerIn2 >= 1) {
        particles.push(new Particle(2, 0));
        spawnTimerIn2 -= 1;
      }

      // Update particles
      const speed = 0.55; // screens per second
      for (let i = particles.length - 1; i >= 0; i--) {
        const p = particles[i];
        p.progress += speed * dt;

        if (p.branch === 1 || p.branch === 2) {
          if (p.progress >= 1) {
            // Reached node: route proportionally to Out1 or Out2
            const probOut1 = I3 / (I3 + I4);
            const targetBranch = Math.random() < probOut1 ? 3 : 4;
            p.branch = targetBranch;
            p.progress = 0;
          }
        } else {
          if (p.progress >= 1) {
            particles.splice(i, 1);
          }
        }
      }

      // RENDER
      ctx.clearRect(0, 0, w, h);

      // Draw Wires
      ctx.lineWidth = 5;
      ctx.lineCap = 'round';

      // In1 Wire
      ctx.strokeStyle = '#93c5fd';
      ctx.beginPath();
      ctx.moveTo(pIn1.x, pIn1.y);
      ctx.lineTo(cx, cy);
      ctx.stroke();

      // In2 Wire
      ctx.beginPath();
      ctx.moveTo(pIn2.x, pIn2.y);
      ctx.lineTo(cx, cy);
      ctx.stroke();

      // Out1 Wire
      ctx.strokeStyle = '#6ee7b7';
      ctx.beginPath();
      ctx.moveTo(cx, cy);
      ctx.lineTo(pOut1.x, pOut1.y);
      ctx.stroke();

      // Out2 Wire
      ctx.beginPath();
      ctx.moveTo(cx, cy);
      ctx.lineTo(pOut2.x, pOut2.y);
      ctx.stroke();

      // Direction Arrows
      function drawArrow(x1, y1, x2, y2, color) {
        const mx = (x1 + x2) / 2;
        const my = (y1 + y2) / 2;
        const angle = Math.atan2(y2 - y1, x2 - x1);
        const len = 9;
        ctx.fillStyle = color;
        ctx.beginPath();
        ctx.moveTo(mx + len * Math.cos(angle), my + len * Math.sin(angle));
        ctx.lineTo(mx + len * Math.cos(angle + 2.5), my + len * Math.sin(angle + 2.5));
        ctx.lineTo(mx + len * Math.cos(angle - 2.5), my + len * Math.sin(angle - 2.5));
        ctx.closePath();
        ctx.fill();
      }

      drawArrow(pIn1.x, pIn1.y, cx, cy, '#2563eb');
      drawArrow(pIn2.x, pIn2.y, cx, cy, '#2563eb');
      drawArrow(cx, cy, pOut1.x, pOut1.y, '#059669');
      drawArrow(cx, cy, pOut2.x, pOut2.y, '#059669');

      // Draw Particles (Charges)
      for (const p of particles) {
        let px, py;
        if (p.branch === 1) {
          px = pIn1.x + (cx - pIn1.x) * p.progress;
          py = pIn1.y + (cy - pIn1.y) * p.progress;
        } else if (p.branch === 2) {
          px = pIn2.x + (cx - pIn2.x) * p.progress;
          py = pIn2.y + (cy - pIn2.y) * p.progress;
        } else if (p.branch === 3) {
          px = cx + (pOut1.x - cx) * p.progress;
          py = cy + (pOut1.y - cy) * p.progress;
        } else if (p.branch === 4) {
          px = cx + (pOut2.x - cx) * p.progress;
          py = cy + (pOut2.y - cy) * p.progress;
        }

        ctx.fillStyle = (p.branch <= 2) ? '#2563eb' : '#059669';
        ctx.beginPath();
        ctx.arc(px, py, 4.5, 0, Math.PI * 2);
        ctx.fill();

        // Charge core highlight
        ctx.fillStyle = '#ffffff';
        ctx.beginPath();
        ctx.arc(px, py, 1.8, 0, Math.PI * 2);
        ctx.fill();
      }

      // Draw Center Junction Node
      ctx.fillStyle = '#1e293b';
      ctx.beginPath();
      ctx.arc(cx, cy, 10, 0, Math.PI * 2);
      ctx.fill();

      ctx.fillStyle = '#f8fafc';
      ctx.beginPath();
      ctx.arc(cx, cy, 5, 0, Math.PI * 2);
      ctx.fill();

      // Node Label
      ctx.fillStyle = '#475569';
      ctx.font = 'bold 12px system-ui';
      ctx.textAlign = 'center';
      ctx.fillText('Node', cx, cy - 15);

      // Terminal Labels
      ctx.font = '600 12px system-ui';
      ctx.fillStyle = '#2563eb';
      ctx.textAlign = 'left';
      ctx.fillText(`I₁ (${I1}A)`, pIn1.x, pIn1.y - 10);
      ctx.fillText(`I₂ (${I2}A)`, pIn2.x, pIn2.y + 18);

      ctx.fillStyle = '#059669';
      ctx.textAlign = 'right';
      ctx.fillText(`I₃ (${I3}A)`, pOut1.x, pOut1.y - 10);
      ctx.fillText(`I₄ (${I4}A)`, pOut2.x, pOut2.y + 18);

      requestAnimationFrame(animate);
    }

    requestAnimationFrame(animate);
  </script>
</body>
</html>

What happens when multiple current paths meet at a single node with different magnitudes?

In 1845, German physicist Gustav Kirchhoff formulated two fundamental circuit laws while still a university student, extending Georg Ohm's earlier work to complex multi-loop networks.

**Kirchhoff's Current Law (KCL)**, also known as **Kirchhoff's First Law**, states that the sum of all currents entering a junction must equal the sum of all currents leaving that junction:

$$\sum I_{\text{in}} = \sum I_{\text{out}}$$

Alternatively, if you assign entering currents a positive sign ($+I$) and leaving currents a negative sign ($-I$), the algebraic sum of all $n$ branch currents at a node is zero: $$\sum_{k=1}^{n} I_k = 0$$

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      background: #f8f9fa;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      padding: 12px;
      user-select: none;
    }

    .equation-bar {
      width: 100%;
      max-width: 480px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 8px 14px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      font-size: 15px;
      font-weight: 700;
      box-shadow: 0 1px 4px rgba(0,0,0,0.04);
    }

    .eq-group { display: flex; align-items: center; gap: 4px; }
    .val-in { color: #0284c7; }
    .val-out { color: #d97706; }
    .val-zero { color: #16a34a; background: #dcfce7; padding: 2px 8px; border-radius: 6px; }

    .junction-container {
      width: 100%;
      max-width: 480px;
      position: relative;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      overflow: hidden;
      margin: 8px 0;
    }

    svg {
      display: block;
      width: 100%;
      height: auto;
    }

    .controls {
      width: 100%;
      max-width: 480px;
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
    }

    .control-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 6px 10px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      font-size: 13px;
      font-weight: 600;
    }

    .control-card.auto {
      background: #f1f5f9;
      border-style: dashed;
    }

    .btn-step {
      width: 24px;
      height: 24px;
      border-radius: 6px;
      border: 1px solid #cbd5e1;
      background: #f8fafc;
      color: #1e2945;
      font-weight: 700;
      font-size: 14px;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      justify-content: center;
    }
    .btn-step:active { background: #e2e8f0; }

    .wire { stroke-width: 4; fill: none; stroke-linecap: round; }
    .wire-in { stroke: #bae6fd; }
    .wire-out { stroke: #fed7aa; }

    .node-center {
      fill: #1e2945;
      stroke: #ffffff;
      stroke-width: 3;
    }

    .branch-label {
      font-size: 13px;
      font-weight: 700;
      font-family: system-ui, sans-serif;
    }
  </style>
</head>
<body>

  <div class="equation-bar">
    <div class="eq-group">
      <span class="val-in" id="sumInText">+4.0 A</span>
      <span>+</span>
      <span class="val-out" id="sumOutText">(-4.0 A)</span>
    </div>
    <span>=</span>
    <div class="val-zero">Σ I = 0</div>
  </div>

  <div class="junction-container">
    <svg viewBox="0 0 400 210" id="circuitSvg">
      
      <line x1="30" y1="40" x2="200" y2="105" class="wire wire-in" />
      <line x1="30" y1="170" x2="200" y2="105" class="wire wire-in" />
      <line x1="200" y1="105" x2="370" y2="40" class="wire wire-out" />
      <line x1="200" y1="105" x2="370" y2="170" class="wire wire-out" />

      
      <g id="particles"></g>

      
      <circle cx="200" cy="105" r="9" class="node-center" />

      
      
      <text x="35" y="30" class="branch-label" fill="#0284c7" id="lblI1">+I₁ = +2.5 A →</text>
      
      <text x="35" y="195" class="branch-label" fill="#0284c7" id="lblI2">+I₂ = +1.5 A →</text>
      
      <text x="365" y="30" text-anchor="end" class="branch-label" fill="#d97706" id="lblI3">→ -I₃ = -1.0 A</text>
      
      <text x="365" y="195" text-anchor="end" class="branch-label" fill="#d97706" id="lblI4">→ -I₄ = -3.0 A</text>
    </svg>
  </div>

  <div class="controls">
    <div class="control-card">
      <span style="color:#0284c7;">I₁ (In)</span>
      <div style="display:flex; gap:6px; align-items:center;">
        <button class="btn-step" onclick="adjust('i1', -0.5)">−</button>
        <span id="ctrlI1" style="min-width:38px; text-align:center;">2.5 A</span>
        <button class="btn-step" onclick="adjust('i1', 0.5)">+</button>
      </div>
    </div>

    <div class="control-card">
      <span style="color:#0284c7;">I₂ (In)</span>
      <div style="display:flex; gap:6px; align-items:center;">
        <button class="btn-step" onclick="adjust('i2', -0.5)">−</button>
        <span id="ctrlI2" style="min-width:38px; text-align:center;">1.5 A</span>
        <button class="btn-step" onclick="adjust('i2', 0.5)">+</button>
      </div>
    </div>

    <div class="control-card">
      <span style="color:#d97706;">I₃ (Out)</span>
      <div style="display:flex; gap:6px; align-items:center;">
        <button class="btn-step" onclick="adjust('i3', -0.5)">−</button>
        <span id="ctrlI3" style="min-width:38px; text-align:center;">1.0 A</span>
        <button class="btn-step" onclick="adjust('i3', 0.5)">+</button>
      </div>
    </div>

    <div class="control-card auto">
      <span style="color:#d97706;">I₄ (Auto)</span>
      <span id="ctrlI4" style="color:#d97706; font-weight:700;">3.0 A</span>
    </div>
  </div>

  <script>
    let i1 = 2.5;
    let i2 = 1.5;
    let i3 = 1.0;

    const pGroup = document.getElementById('particles');

    const branches = [
      { id: 1, x1: 30, y1: 40, x2: 200, y2: 105, color: '#0284c7', count: 5 },
      { id: 2, x1: 30, y1: 170, x2: 200, y2: 105, color: '#0284c7', count: 5 },
      { id: 3, x1: 200, y1: 105, x2: 370, y2: 40, color: '#d97706', count: 5 },
      { id: 4, x1: 200, y1: 105, x2: 370, y2: 170, color: '#d97706', count: 5 }
    ];

    const dots = [];
    branches.forEach(b => {
      for (let j = 0; j < b.count; j++) {
        const c = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
        c.setAttribute('r', '3.5');
        c.setAttribute('fill', b.color);
        pGroup.appendChild(c);
        dots.push({ el: c, branch: b, progress: j / b.count });
      }
    });

    function adjust(target, delta) {
      if (target === 'i1') i1 = Math.max(0.5, Math.min(5.0, +(i1 + delta).toFixed(1)));
      if (target === 'i2') i2 = Math.max(0.5, Math.min(5.0, +(i2 + delta).toFixed(1)));
      if (target === 'i3') {
        const maxI3 = i1 + i2 - 0.5;
        i3 = Math.max(0.5, Math.min(maxI3, +(i3 + delta).toFixed(1)));
      }
      // Keep i3 valid if sum of inputs shrinks below i3
      if (i3 >= i1 + i2) i3 = Math.max(0.5, +(i1 + i2 - 0.5).toFixed(1));
      update();
    }

    function update() {
      const i4 = +(i1 + i2 - i3).toFixed(1);
      const sumIn = +(i1 + i2).toFixed(1);
      const sumOut = +(-sumIn).toFixed(1);

      document.getElementById('lblI1').textContent = `+I₁ = +${i1.toFixed(1)} A →`;
      document.getElementById('lblI2').textContent = `+I₂ = +${i2.toFixed(1)} A →`;
      document.getElementById('lblI3').textContent = `→ -I₃ = -${i3.toFixed(1)} A`;
      document.getElementById('lblI4').textContent = `→ -I₄ = -${i4.toFixed(1)} A`;

      document.getElementById('ctrlI1').textContent = `${i1.toFixed(1)} A`;
      document.getElementById('ctrlI2').textContent = `${i2.toFixed(1)} A`;
      document.getElementById('ctrlI3').textContent = `${i3.toFixed(1)} A`;
      document.getElementById('ctrlI4').textContent = `${i4.toFixed(1)} A`;

      document.getElementById('sumInText').textContent = `+${sumIn.toFixed(1)} A`;
      document.getElementById('sumOutText').textContent = `(${sumOut.toFixed(1)} A)`;
    }

    let lastTime = performance.now();
    function animate(now) {
      const dt = Math.min((now - lastTime) / 1000, 0.1);
      lastTime = now;

      const i4 = i1 + i2 - i3;
      const speeds = { 1: i1 * 0.25, 2: i2 * 0.25, 3: i3 * 0.25, 4: i4 * 0.25 };

      dots.forEach(d => {
        const spd = speeds[d.branch.id];
        d.progress = (d.progress + spd * dt) % 1.0;
        const x = d.branch.x1 + (d.branch.x2 - d.branch.x1) * d.progress;
        const y = d.branch.y1 + (d.branch.y2 - d.branch.y1) * d.progress;
        d.el.setAttribute('cx', x.toFixed(1));
        d.el.setAttribute('cy', y.toFixed(1));
      });

      requestAnimationFrame(animate);
    }

    update();
    requestAnimationFrame(animate);
  </script>
</body>
</html>

Why must this balance hold true every single instant without exception?

The **law of conservation of charge** states that electric charge cannot be created or destroyed in an isolated system.

Because an idealized circuit node is a single geometric point with zero volume, it has no capacitance and cannot accumulate or store net electric charge over time.

Therefore, the rate of charge accumulation at the node is strictly zero: $$\frac{dQ_{\text{node}}}{dt} = \sum I_{\text{in}} - \sum I_{\text{out}} = 0 \implies \sum I_{\text{in}} = \sum I_{\text{out}}$$

How do we use this mathematical relationship to solve for an unknown current in an actual circuit?

Consider a node with four connected branches: Branch 1 delivers $I_1 = 6\text{ A}$ into the node, Branch 2 carries $I_2 = 2\text{ A}$ away from the node, and Branch 3 delivers $I_3 = 5\text{ A}$ into the node. Let's find $I_4$.

Assume $I_4$ leaves the node. We substitute our known values directly into KCL:

$$\sum I_{\text{in}} = \sum I_{\text{out}} \implies 6\text{ A} + 5\text{ A} = 2\text{ A} + I_4$$

Simplifying gives $11\text{ A} = 2\text{ A} + I_4$, which yields $I_4 = 9\text{ A}$ directed **away** from the node.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Kirchhoff's Current Law</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      padding: 12px;
      gap: 10px;
    }

    .diagram-area {
      position: relative;
      width: 100%;
      max-width: 440px;
      height: 260px;
      background: #ffffff;
      border-radius: 12px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.06), 0 1px 2px rgba(0,0,0,0.04);
      overflow: hidden;
    }

    svg {
      width: 100%;
      height: 100%;
      display: block;
    }

    /* Flowing dashes animation */
    .flow-in {
      stroke: #2563eb;
      stroke-dasharray: 6 6;
      animation: dashIn 1.2s linear infinite;
    }

    .flow-out {
      stroke: #059669;
      stroke-dasharray: 6 6;
      animation: dashOut 1.2s linear infinite;
    }

    @keyframes dashIn {
      from { stroke-dashoffset: 24; }
      to { stroke-dashoffset: 0; }
    }

    @keyframes dashOut {
      from { stroke-dashoffset: 0; }
      to { stroke-dashoffset: -24; }
    }

    .wire-base {
      stroke: #e2e8f0;
      stroke-width: 8;
      stroke-linecap: round;
    }

    .node-center {
      fill: #1e2945;
      transition: transform 0.2s ease;
    }

    /* Branch Labels */
    .branch-tag {
      position: absolute;
      background: #ffffff;
      border: 1.5px solid #e2e8f0;
      border-radius: 8px;
      padding: 3px 8px;
      font-size: 13px;
      font-weight: 700;
      box-shadow: 0 2px 4px rgba(0,0,0,0.05);
      display: flex;
      align-items: center;
      gap: 4px;
      transform: translate(-50%, -50%);
      pointer-events: none;
    }

    .tag-in {
      border-color: #bfdbfe;
      color: #1d4ed8;
    }

    .tag-out {
      border-color: #a7f3d0;
      color: #047857;
    }

    .tag-unknown {
      border-color: #fde68a;
      color: #b45309;
      background: #fffbeb;
    }

    /* Balance Equation Bar */
    .math-bar {
      width: 100%;
      max-width: 440px;
      background: #ffffff;
      border-radius: 10px;
      padding: 10px 14px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      box-shadow: 0 1px 3px rgba(0,0,0,0.06);
      font-size: 14px;
      font-weight: 700;
    }

    .side-in {
      color: #1d4ed8;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .side-out {
      color: #047857;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .equal-sign {
      color: #64748b;
      font-size: 18px;
    }

    /* Interactive Controls */
    .controls {
      width: 100%;
      max-width: 440px;
      display: flex;
      gap: 8px;
    }

    .btn {
      flex: 1;
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      padding: 8px 10px;
      font-size: 13px;
      font-weight: 600;
      color: #475569;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      transition: background 0.2s, border-color 0.2s, color 0.2s;
    }

    .btn:active {
      background: #f1f5f9;
    }

    .btn.active {
      background: #eff6ff;
      border-color: #2563eb;
      color: #1d4ed8;
    }
  </style>
</head>
<body>

  
  <div class="diagram-area">
    <svg viewBox="0 0 440 260">
      
      <line class="wire-base" x1="40" y1="50" x2="220" y2="130" />
      <line class="wire-base" x1="40" y1="210" x2="220" y2="130" />
      <line class="wire-base" x1="220" y1="130" x2="400" y2="50" />
      <line class="wire-base" x1="220" y1="130" x2="400" y2="210" />

      
      <line class="flow-in" stroke-width="4" x1="40" y1="50" x2="220" y2="130" />
      <line class="flow-in" stroke-width="4" x1="40" y1="210" x2="220" y2="130" />
      <line class="flow-out" stroke-width="4" x1="220" y1="130" x2="400" y2="50" />
      <line class="flow-out" stroke-width="4" x1="220" y1="130" x2="400" y2="210" />

      
      <circle class="node-center" cx="220" cy="130" r="14" />
      <circle fill="#ffffff" cx="220" cy="130" r="4" />
      <text x="220" y="160" text-anchor="middle" font-size="11" font-weight="700" fill="#64748b">NODE</text>
    </svg>

    
    <div class="branch-tag tag-in" style="top: 28%; left: 24%;">
      <span>I₁ = <span id="v1">5</span>A</span> ➔
    </div>

    <div class="branch-tag tag-in" style="top: 72%; left: 24%;">
      <span>I₂ = <span id="v2">6</span>A</span> ➔
    </div>

    <div class="branch-tag tag-out" style="top: 28%; left: 76%;">
      ➔ <span>I₃ = <span id="v3">2</span>A</span>
    </div>

    <div class="branch-tag tag-unknown" id="tag4" style="top: 72%; left: 76%;">
      ➔ <span>I₄ = <span id="v4">9</span>A</span>
    </div>
  </div>

  
  <div class="math-bar">
    <div class="side-in">
      <span>Σ I<sub>in</sub></span>
      <span id="sumIn" style="font-size: 16px;">11 A</span>
    </div>
    <div class="equal-sign">=</div>
    <div class="side-out">
      <span>Σ I<sub>out</sub></span>
      <span id="sumOut" style="font-size: 16px;">11 A</span>
    </div>
  </div>

  
  <div class="controls">
    <button class="btn active" id="btnLesson" onclick="setPreset(0)">Lesson: 5 + 6 = 2 + 9</button>
    <button class="btn" id="btnSplit" onclick="setPreset(1)">Balanced Split</button>
    <button class="btn" id="btnHigh" onclick="setPreset(2)">High Flow</button>
  </div>

  <script>
    const presets = [
      { i1: 5, i2: 6, i3: 2, i4: 9 },
      { i1: 4, i2: 4, i3: 4, i4: 4 },
      { i1: 8, i2: 7, i3: 5, i4: 10 }
    ];

    function setPreset(index) {
      const data = presets[index];
      
      document.getElementById('v1').textContent = data.i1;
      document.getElementById('v2').textContent = data.i2;
      document.getElementById('v3').textContent = data.i3;
      document.getElementById('v4').textContent = data.i4;

      const totalIn = data.i1 + data.i2;
      const totalOut = data.i3 + data.i4;

      document.getElementById('sumIn').textContent = totalIn + ' A';
      document.getElementById('sumOut').textContent = totalOut + ' A';

      // Update button styles
      ['btnLesson', 'btnSplit', 'btnHigh'].forEach((id, i) => {
        document.getElementById(id).classList.toggle('active', i === index);
      });
    }
  </script>
</body>
</html>

What if you guess the direction of an unknown current incorrectly before you start calculating?

A common point of confusion is worrying about guessing the wrong arrow direction. If you had assumed $I_4$ was entering the node instead, your KCL equation would be $(6 + 5 + I_4) = 2$.

Solving gives $I_4 = -9\text{ A}$. A **negative current** simply means the real physical charge flow is opposite to your chosen reference arrow—the magnitude ($9\text{ A}$) remains completely correct.

electronics

Charge Conservation and Kirchhoff's Current Law (KCL). State Kirchhoff's current law (sum of currents entering a junction equals sum of currents leaving) and apply it to circuit nodes.

Kirchhoff's Current Law - DC Circuit Analysis

Kirchhoff's Junction Rule Review and Worked Problems

Kirchhoff's Current Law (KCL) - Direct Current Textbook

Pedagogical Strategy for A-Level Mastery: Begin by firmly rooting KCL in fundamental physics ($I = \frac{\mathrm{d}Q}{\mathrm{d}t}$ and conservation of charge) before introducing formal algebraic matrix/nodal notation. Use interactive simulations (such as PhET Circuit Construction Kit) to visually bust the 'current is consumed' misconception by placing ammeters immediately before and after nodes. Progress from qualitative 1-node branching puzzles to multi-node circuits with combined Ohm's Law/KCL formulations to prepare students for A2 Level circuit analysis and Thevenin equivalent reductions.

Charge Conservation and Kirchhoff's Current Law (KCL)

Nodes and Electric Current

Kirchhoff's Current Law