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 filling an empty toy chest all the way to the top with little wooden alphabet blocks. How many blocks can fit inside without spilling over?

The amount of space inside any 3D box is called its **volume**.

<!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>Volume of Cuboids</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.8/katex.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.8/katex.min.js"></script>
<style>
  * { box-sizing: border-box; margin: 0; padding: 0; font-family: system-ui, -apple-system, sans-serif; }
  body {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: space-between;
    padding: 12px;
    min-height: 100%;
    color: #1e2945;
    background: transparent;
    user-select: none;
    -webkit-user-select: none;
  }

  .nav-tabs {
    display: flex;
    gap: 6px;
    background: #f1f5f9;
    padding: 4px;
    border-radius: 10px;
    width: 100%;
    max-width: 380px;
  }

  .nav-btn {
    flex: 1;
    border: none;
    background: transparent;
    padding: 8px 4px;
    font-size: 13px;
    font-weight: 600;
    color: #64748b;
    border-radius: 6px;
    cursor: pointer;
    transition: all 0.25s ease;
  }

  .nav-btn.active {
    background: #ffffff;
    color: #0f172a;
    box-shadow: 0 2px 6px rgba(0,0,0,0.08);
  }

  .stage-container {
    width: 100%;
    max-width: 420px;
    height: 240px;
    display: flex;
    align-items: center;
    justify-content: center;
    position: relative;
  }

  svg {
    width: 100%;
    height: 100%;
    overflow: visible;
  }

  .cube-group {
    transition: opacity 0.35s ease, transform 0.35s ease;
  }

  .cube-group.hidden {
    opacity: 0;
    transform: translateY(-8px);
    pointer-events: none;
  }

  .readout-card {
    background: #ffffff;
    border: 1px solid #e2e8f0;
    border-radius: 12px;
    padding: 10px 20px;
    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.04);
    display: flex;
    align-items: center;
    justify-content: center;
    min-height: 48px;
    min-width: 220px;
    text-align: center;
  }

  .math-display {
    font-size: 20px;
    color: #1e2945;
  }

  /* Cube face styling */
  .face-top { fill: #60a5fa; }
  .face-left { fill: #3b82f6; }
  .face-right { fill: #2563eb; }

  .layer2 .face-top { fill: #f472b6; }
  .layer2 .face-left { fill: #ec4899; }
  .layer2 .face-right { fill: #db2777; }

  polygon {
    stroke: #ffffff;
    stroke-width: 1.2;
    stroke-linejoin: round;
  }
</style>
</head>
<body>

  
  <div class="nav-tabs">
    <button class="nav-btn active" onclick="setStep(0)">1 Cube</button>
    <button class="nav-btn" onclick="setStep(1)">1 Row</button>
    <button class="nav-btn" onclick="setStep(2)">1 Layer</button>
    <button class="nav-btn" onclick="setStep(3)">2 Layers</button>
  </div>

  
  <div class="stage-container">
    <svg viewBox="0 0 340 220" id="iso-stage">
      
    </svg>
  </div>

  
  <div class="readout-card">
    <div id="math-output" class="math-display"></div>
  </div>

<script>
  // Isometric projection params
  // Dimensions: 3 (length/x) × 2 (width/y) × 2 (height/z)
  const originX = 170;
  const originY = 135;
  const dx = 32;
  const dy = 18;
  const dz = 34;

  function isoPoint(x, y, z) {
    // x: right-down, y: left-down (depth), z: up
    const px = originX + (x - y) * dx;
    const py = originY + (x + y) * dy - z * dz;
    return [px, py];
  }

  function drawCube(x, y, z, stepRequired, isLayer2) {
    const p0 = isoPoint(x, y, z);
    const pX = isoPoint(x + 1, y, z);
    const pY = isoPoint(x, y + 1, z);
    const pXY = isoPoint(x + 1, y + 1, z);

    const pZ = isoPoint(x, y, z + 1);
    const pXZ = isoPoint(x + 1, y, z + 1);
    const pYZ = isoPoint(x, y + 1, z + 1);
    const pXYZ = isoPoint(x + 1, y + 1, z + 1);

    const group = document.createElementNS('http://www.w3.org/2000/svg', 'g');
    group.setAttribute('class', `cube-group ${isLayer2 ? 'layer2' : ''}`);
    group.dataset.step = stepRequired;

    // Top face
    const top = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    top.setAttribute('points', `${pZ[0]},${pZ[1]} ${pXZ[0]},${pXZ[1]} ${pXYZ[0]},${pXYZ[1]} ${pYZ[0]},${pYZ[1]}`);
    top.setAttribute('class', 'face-top');

    // Left face (front-left: Y side)
    const left = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    left.setAttribute('points', `${pY[0]},${pY[1]} ${pXYZ[0]},${pXYZ[1]} ${pYZ[0]},${pYZ[1]} ${pY[0]},${pY[1]}`);
    left.setAttribute('points', `${pY[0]},${pY[1]} ${pXY[0]},${pXY[1]} ${pXYZ[0]},${pXYZ[1]} ${pYZ[0]},${pYZ[1]}`);
    left.setAttribute('class', 'face-left');

    // Right face (front-right: X side)
    const right = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    right.setAttribute('points', `${pXY[0]},${pXY[1]} ${pX[0]},${pX[1]} ${pXZ[0]},${pXZ[1]} ${pXYZ[0]},${pXYZ[1]}`);
    right.setAttribute('class', 'face-right');

    group.appendChild(left);
    group.appendChild(right);
    group.appendChild(top);

    return group;
  }

  const svg = document.getElementById('iso-stage');

  // Render order back-to-front: z (0 to 1), y (0 to 1), x (0 to 2)
  const cubes = [];

  for (let z = 0; z < 2; z++) {
    for (let y = 0; y < 2; y++) {
      for (let x = 0; x < 3; x++) {
        let step = 0;
        if (z === 1) {
          step = 3; // 2 layers
        } else if (y === 1) {
          step = 2; // full bottom layer (2 rows)
        } else if (x > 0) {
          step = 1; // 1 row (3 cubes)
        } else {
          step = 0; // 1 unit cube
        }
        cubes.push({ x, y, z, step, isLayer2: z === 1 });
      }
    }
  }

  // Sort back to front for proper isometric occlusion
  cubes.sort((a, b) => {
    if (a.z !== b.z) return a.z - b.z;
    const depthA = a.x + a.y;
    const depthB = b.x + b.y;
    return depthA - depthB;
  });

  cubes.forEach(c => {
    const el = drawCube(c.x, c.y, c.z, c.step, c.isLayer2);
    svg.appendChild(el);
  });

  const formulas = [
    "1\\text{ cm}^3",
    "3 \\times 1 = 3\\text{ cm}^3",
    "3 \\times 2 = 6\\text{ cm}^3",
    "3 \\times 2 \\times 2 = 12\\text{ cm}^3"
  ];

  let currentStep = 0;

  function setStep(step) {
    currentStep = step;

    // Update buttons
    const buttons = document.querySelectorAll('.nav-btn');
    buttons.forEach((btn, idx) => {
      btn.classList.toggle('active', idx === step);
    });

    // Update cubes visibility
    const groups = document.querySelectorAll('.cube-group');
    groups.forEach(g => {
      const s = parseInt(g.dataset.step, 10);
      if (s <= step) {
        g.classList.remove('hidden');
      } else {
        g.classList.add('hidden');
      }
    });

    // Render KaTeX
    const out = document.getElementById('math-output');
    if (window.katex) {
      katex.render(formulas[step], out, { displayMode: true });
    } else {
      out.textContent = formulas[step];
    }
  }

  // Initialize
  setStep(0);
</script>

</body>
</html>

How do we measure this space with numbers instead of counting every single block?

We measure volume using tiny blocks called **cubic centimeters**, written as **$\text{cm}^3$**.

Each unit cube is $1\text{ cm}$ long, $1\text{ cm}$ wide, and $1\text{ cm}$ tall.

<!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>Volume of Cubes and Cuboids</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css">
  <script src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js"></script>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      background: transparent;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      user-select: none;
    }

    .main-container {
      width: 100%;
      max-width: 540px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 10px;
    }

    .svg-wrap {
      width: 100%;
      height: 220px;
      position: relative;
      display: flex;
      align-items: center;
      justify-content: center;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    .formula-card {
      background: #f0f7ff;
      border: 1.5px solid #bfdbfe;
      border-radius: 10px;
      padding: 8px 16px;
      text-align: center;
      min-height: 48px;
      display: flex;
      align-items: center;
      justify-content: center;
      width: 100%;
      font-size: 1.05rem;
    }

    .controls {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
      width: 100%;
    }

    .control-box {
      background: #ffffff;
      border: 1.5px solid #e2e8f0;
      border-radius: 10px;
      padding: 6px 4px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 4px;
    }

    .control-label {
      font-size: 12px;
      font-weight: 600;
      color: #475569;
    }

    .btn-group {
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .step-btn {
      width: 28px;
      height: 28px;
      border-radius: 6px;
      border: 1px solid #cbd5e1;
      background: #f8fafc;
      color: #1e2945;
      font-size: 15px;
      font-weight: 700;
      cursor: pointer;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: background 0.15s, border-color 0.15s;
    }

    .step-btn:hover {
      background: #e2e8f0;
      border-color: #94a3b8;
    }

    .step-btn:active {
      background: #cbd5e1;
    }

    .dim-val {
      font-size: 14px;
      font-weight: 700;
      min-width: 16px;
      text-align: center;
      color: #1d4ed8;
    }

    .presets {
      display: flex;
      gap: 6px;
      width: 100%;
      justify-content: center;
    }

    .preset-btn {
      flex: 1;
      max-width: 130px;
      padding: 5px 8px;
      font-size: 11px;
      font-weight: 600;
      background: #f8fafc;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      color: #334155;
      cursor: pointer;
      transition: all 0.15s;
    }

    .preset-btn:hover {
      background: #e0f2fe;
      border-color: #38bdf8;
      color: #0369a1;
    }
  </style>
</head>
<body>

  <div class="main-container">
    
    <div class="svg-wrap">
      <svg id="isoSvg" viewBox="-180 -130 360 250"></svg>
    </div>

    
    <div class="formula-card" id="mathDisplay"></div>

    
    <div class="controls">
      <div class="control-box">
        <span class="control-label">Length (l)</span>
        <div class="btn-group">
          <button class="step-btn" onclick="updateDim('l', -1)">−</button>
          <span class="dim-val" id="val-l">3</span>
          <button class="step-btn" onclick="updateDim('l', 1)">+</button>
        </div>
      </div>
      <div class="control-box">
        <span class="control-label">Width (w)</span>
        <div class="btn-group">
          <button class="step-btn" onclick="updateDim('w', -1)">−</button>
          <span class="dim-val" id="val-w">2</span>
          <button class="step-btn" onclick="updateDim('w', 1)">+</button>
        </div>
      </div>
      <div class="control-box">
        <span class="control-label">Height (h)</span>
        <div class="btn-group">
          <button class="step-btn" onclick="updateDim('h', -1)">−</button>
          <span class="dim-val" id="val-h">2</span>
          <button class="step-btn" onclick="updateDim('h', 1)">+</button>
        </div>
      </div>
    </div>

    
    <div class="presets">
      <button class="preset-btn" onclick="setDims(1,1,1)">1×1×1 Cube</button>
      <button class="preset-btn" onclick="setDims(3,2,2)">3×2×2 Box</button>
      <button class="preset-btn" onclick="setDims(4,3,2)">4×3×2 Box</button>
      <button class="preset-btn" onclick="setDims(3,3,3)">3×3×3 Cube</button>
    </div>
  </div>

  <script>
    const dims = { l: 3, w: 2, h: 2 };
    const COS30 = 0.866025;
    const SIN30 = 0.5;

    function updateDim(dim, delta) {
      const max = dim === 'h' ? 4 : 5;
      const next = dims[dim] + delta;
      if (next >= 1 && next <= max) {
        dims[dim] = next;
        render();
      }
    }

    function setDims(l, w, h) {
      dims.l = l;
      dims.w = w;
      dims.h = h;
      render();
    }

    function render() {
      document.getElementById('val-l').textContent = dims.l;
      document.getElementById('val-w').textContent = dims.w;
      document.getElementById('val-h').textContent = dims.h;

      // Update Math Formula via KaTeX
      const vol = dims.l * dims.w * dims.h;
      const formulaStr = `V = ${dims.l} \\times ${dims.w} \\times ${dims.h} = ${vol}\\text{ cm}^3`;
      katex.render(formulaStr, document.getElementById('mathDisplay'), { throwOnError: false });

      // Draw Isometric Cubes
      const svg = document.getElementById('isoSvg');
      svg.innerHTML = '';

      // Determine unit scale based on max dimensions
      const maxSpan = Math.max(dims.l + dims.w, dims.h * 1.5, 4);
      const u = Math.min(32, 160 / maxSpan);

      // Centering offset
      const cx = ((dims.l - dims.w) * u * COS30) / 2;
      const cy = ((dims.l + dims.w) * u * SIN30 - (dims.h * u)) / 2;

      // Render cubes back-to-front (z: 0 -> h-1, y: w-1 -> 0, x: 0 -> l-1)
      for (let z = 0; z < dims.h; z++) {
        for (let y = dims.w - 1; y >= 0; y--) {
          for (let x = 0; x < dims.l; x++) {
            const px = (x - y) * u * COS30 - cx;
            const py = (x + y) * u * SIN30 - (z * u) - cy;
            drawIsoCube(svg, px, py, u);
          }
        }
      }
    }

    function drawIsoCube(svg, px, py, u) {
      const dx = u * COS30;
      const dy = u * SIN30;

      // Top Face
      const topPts = [
        `${px},${py - dy}`,
        `${px + dx},${py}`,
        `${px},${py + dy}`,
        `${px - dx},${py}`
      ].join(' ');

      // Left Face
      const leftPts = [
        `${px - dx},${py}`,
        `${px},${py + dy}`,
        `${px},${py + dy + u}`,
        `${px - dx},${py + u}`
      ].join(' ');

      // Right Face
      const rightPts = [
        `${px},${py + dy}`,
        `${px + dx},${py}`,
        `${px + dx},${py + u}`,
        `${px},${py + dy + u}`
      ].join(' ');

      const g = document.createElementNS('http://www.w3.org/2000/svg', 'g');

      g.innerHTML = `
        <polygon points="${leftPts}" fill="#3b82f6" stroke="#1e40af" stroke-width="1" stroke-linejoin="round" />
        <polygon points="${rightPts}" fill="#2563eb" stroke="#1e40af" stroke-width="1" stroke-linejoin="round" />
        <polygon points="${topPts}" fill="#93c5fd" stroke="#1e40af" stroke-width="1" stroke-linejoin="round" />
      `;

      svg.appendChild(g);
    }

    // Initial render
    render();
  </script>
</body>
</html>

What if you have a giant box with hundreds of cubes?

To find how many cubes fit, multiply the three sides: **$V = l \times w \times h$**.

First, multiply length by width to find cubes on the bottom floor, then multiply by height for all the floors.

<!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>Calculating Volume of Cuboids</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.8/katex.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.8/katex.min.js"></script>
<style>
  * {
    box-sizing: border-box;
    margin: 0;
    padding: 0;
  }
  body {
    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
    background: #ffffff;
    color: #1e2945;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: space-between;
    min-height: 100%;
    padding: 12px 16px 16px;
    user-select: none;
    -webkit-user-select: none;
  }
  .header {
    display: flex;
    align-items: center;
    justify-content: center;
    gap: 8px;
    margin-bottom: 4px;
  }
  .nav-btns {
    display: flex;
    gap: 8px;
    background: #f1f5f9;
    padding: 4px;
    border-radius: 24px;
  }
  .nav-btn {
    border: none;
    background: transparent;
    padding: 6px 14px;
    font-size: 13px;
    font-weight: 600;
    color: #64748b;
    border-radius: 20px;
    cursor: pointer;
    transition: all 0.25s ease;
  }
  .nav-btn.active {
    background: #ffffff;
    color: #0284c7;
    box-shadow: 0 1px 4px rgba(0,0,0,0.1);
  }
  .stage {
    position: relative;
    width: 100%;
    max-width: 440px;
    height: 250px;
    display: flex;
    align-items: center;
    justify-content: center;
  }
  svg {
    width: 100%;
    height: 100%;
    overflow: visible;
  }
  .layer {
    transition: transform 0.45s cubic-bezier(0.34, 1.56, 0.64, 1), opacity 0.35s ease;
  }
  .layer-hidden {
    opacity: 0;
    pointer-events: none;
    transform: translateY(-40px);
  }
  .layer-stacked {
    opacity: 1;
    transform: translateY(0);
  }
  .formula-card {
    background: #f8fafc;
    border: 1px solid #e2e8f0;
    border-radius: 12px;
    padding: 8px 16px;
    min-height: 48px;
    display: flex;
    align-items: center;
    justify-content: center;
    width: 100%;
    max-width: 420px;
    box-shadow: 0 1px 3px rgba(0,0,0,0.03);
  }
  .katex {
    font-size: 1.15rem;
    color: #1e2945;
  }
  .cube-top { fill: #bae6fd; stroke: #0284c7; stroke-width: 0.8; }
  .cube-left { fill: #7dd3fc; stroke: #0284c7; stroke-width: 0.8; }
  .cube-right { fill: #38bdf8; stroke: #0284c7; stroke-width: 0.8; }
  
  .dim-text {
    font-size: 13px;
    font-weight: 700;
    fill: #0369a1;
    text-anchor: middle;
    dominant-baseline: central;
  }
  .dim-line {
    stroke: #0284c7;
    stroke-width: 1.5;
    stroke-dasharray: 3 3;
  }
</style>
</head>
<body>

  <div class="header">
    <div class="nav-btns">
      <button class="nav-btn active" id="btn-0" onclick="setStep(0)">1. Base Floor</button>
      <button class="nav-btn" id="btn-1" onclick="setStep(1)">2. Stack Floors</button>
      <button class="nav-btn" id="btn-2" onclick="setStep(2)">3. Total Volume</button>
    </div>
  </div>

  <div class="stage">
    <svg id="svg-cuboid" viewBox="0 0 400 240">
      
      <g id="dim-annotations">
        
        <path d="M 200,212 L 284,166" class="dim-line" />
        <text x="252" y="196" class="dim-text">Length = 4</text>

        
        <path d="M 190,212 L 126,177" class="dim-line" />
        <text x="146" y="202" class="dim-text">Width = 3</text>

        
        <g id="height-dim" style="transition: opacity 0.3s ease; opacity: 0;">
          <path d="M 112,168 L 112,96" class="dim-line" />
          <text x="76" y="132" class="dim-text">Height = 3</text>
        </g>
      </g>

      
      <g id="layer-0" class="layer"></g>

      
      <g id="layer-1" class="layer layer-hidden"></g>

      
      <g id="layer-2" class="layer layer-hidden"></g>
    </svg>
  </div>

  <div class="formula-card" id="math-output"></div>

<script>
  // Dimensions
  const NX = 4; // Length
  const NY = 3; // Width
  const NZ = 3; // Height

  // Isometric projection constants
  const ORIGIN_X = 200;
  const ORIGIN_Y = 175;
  const DX_X = 22, DX_Y = 12;   // Step along Length (x)
  const DY_X = -24, DY_Y = 13;  // Step along Width (y)
  const DZ_Y = 24;              // Step along Height (z)

  function project(x, y, z) {
    return {
      px: ORIGIN_X + (x * DX_X) + (y * DY_X),
      py: ORIGIN_Y + (x * DX_Y) + (y * DY_Y) - (z * DZ_Y)
    };
  }

  function createCube(x, y, z) {
    const g = document.createElementNS('http://www.w3.org/2000/svg', 'g');
    
    // 8 isometric vertices for unit cube at (x,y,z)
    const p000 = project(x, y, z);
    const p100 = project(x + 1, y, z);
    const p110 = project(x + 1, y + 1, z);
    const p010 = project(x, y + 1, z);
    
    const p001 = project(x, y, z + 1);
    const p101 = project(x + 1, y, z + 1);
    const p111 = project(x + 1, y + 1, z + 1);
    const p011 = project(x, y + 1, z + 1);

    // Top face
    const top = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    top.setAttribute('points', `${p001.px},${p001.py} ${p101.px},${p101.py} ${p111.px},${p111.py} ${p011.px},${p011.py}`);
    top.setAttribute('class', 'cube-top');

    // Left face (Width side)
    const left = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    left.setAttribute('points', `${p000.px},${p000.py} ${p010.px},${p010.py} ${p011.px},${p011.py} ${p001.px},${p001.py}`);
    left.setAttribute('class', 'cube-left');

    // Right face (Length side)
    const right = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
    right.setAttribute('points', `${p000.px},${p000.py} ${p100.px},${p100.py} ${p101.px},${p101.py} ${p001.px},${p001.py}`);
    right.setAttribute('class', 'cube-right');

    g.appendChild(left);
    g.appendChild(right);
    g.appendChild(top);
    return g;
  }

  // Build layers in isometric painter order (back-to-front: highest y down to 0, lowest x up to NX-1)
  for (let z = 0; z < NZ; z++) {
    const layerG = document.getElementById(`layer-${z}`);
    for (let y = NY - 1; y >= 0; y--) {
      for (let x = 0; x < NX; x++) {
        layerG.appendChild(createCube(x, y, z));
      }
    }
  }

  const stepsData = [
    {
      layers: [true, false, false],
      showHeight: false,
      math: "\\text{Base Floor} = 4 \\times 3 = 12\\text{ cubes}"
    },
    {
      layers: [true, true, true],
      showHeight: true,
      math: "12\\text{ cubes} \\times 3\\text{ floors} = 36\\text{ cubes}"
    },
    {
      layers: [true, true, true],
      showHeight: true,
      math: "V = l \\times w \\times h = 4 \\times 3 \\times 3 = 36\\text{ units}^3"
    }
  ];

  let currentStep = 0;
  let timer = null;

  function renderStep(idx) {
    currentStep = idx;
    const data = stepsData[idx];

    // Buttons
    for (let i = 0; i < 3; i++) {
      document.getElementById(`btn-${i}`).classList.toggle('active', i === idx);
    }

    // Layers visibility
    for (let z = 0; z < NZ; z++) {
      const el = document.getElementById(`layer-${z}`);
      if (data.layers[z]) {
        el.classList.remove('layer-hidden');
        el.classList.add('layer-stacked');
      } else {
        el.classList.add('layer-hidden');
        el.classList.remove('layer-stacked');
      }
    }

    // Height annotation
    document.getElementById('height-dim').style.opacity = data.showHeight ? '1' : '0';

    // KaTeX render
    const out = document.getElementById('math-output');
    try {
      katex.render(data.math, out, { displayMode: true, throwOnError: false });
    } catch(e) {
      out.textContent = data.math;
    }
  }

  function setStep(idx) {
    clearInterval(timer);
    renderStep(idx);
    startAutoPlay();
  }

  function startAutoPlay() {
    timer = setInterval(() => {
      currentStep = (currentStep + 1) % stepsData.length;
      renderStep(currentStep);
    }, 4000);
  }

  renderStep(0);
  startAutoPlay();
</script>

</body>
</html>

Let's put this formula to work on a real cardboard box.

A pencil box has a length of $5\text{ cm}$, a width of $3\text{ cm}$, and a height of $2\text{ cm}$.

$$V = 5\text{ cm} \times 3\text{ cm} \times 2\text{ cm} = 30\text{ cm}^3$$

The pencil box holds exactly $30$ cubic centimeter blocks.

What happens when all sides of the box are the exact same length?

A **cube** is a special box where length, width, and height are all equal.

For a block with sides of $3\text{ cm}$, multiply $3 \times 3 \times 3 = 27\text{ cm}^3$.

<!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>Calculating Volume of a Cube</title>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.9/katex.min.css">
  <script src="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.16.9/katex.min.js"></script>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
    }

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

    .stepper-nav {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 480px;
      justify-content: center;
      margin-bottom: 8px;
    }

    .step-btn {
      flex: 1;
      background: #f1f5f9;
      border: 1px solid #e2e8f0;
      color: #64748b;
      padding: 6px 4px;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      text-align: center;
      transition: all 0.2s ease;
      white-space: nowrap;
    }

    .step-btn.active {
      background: #8b5cf6;
      border-color: #7c3aed;
      color: #ffffff;
      box-shadow: 0 2px 6px rgba(139, 92, 246, 0.3);
    }

    .stage {
      position: relative;
      width: 100%;
      max-width: 380px;
      height: 220px;
      display: flex;
      align-items: center;
      justify-content: center;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    .cube-face {
      transition: opacity 0.35s ease, transform 0.35s ease;
    }

    .cube-top { fill: #c4b5fd; stroke: #7c3aed; stroke-width: 1; stroke-linejoin: round; }
    .cube-left { fill: #8b5cf6; stroke: #7c3aed; stroke-width: 1; stroke-linejoin: round; }
    .cube-right { fill: #6d28d9; stroke: #7c3aed; stroke-width: 1; stroke-linejoin: round; }

    .cube-ghost {
      opacity: 0.12;
    }

    .cube-ghost .cube-top { fill: #cbd5e1; stroke: #94a3b8; }
    .cube-ghost .cube-left { fill: #94a3b8; stroke: #64748b; }
    .cube-ghost .cube-right { fill: #64748b; stroke: #475569; }

    .dim-label {
      font-size: 12px;
      font-weight: 700;
      fill: #475569;
    }

    .formula-card {
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px 14px;
      width: 100%;
      max-width: 440px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 4px;
      text-align: center;
      margin-top: 4px;
    }

    .math-main {
      font-size: 17px;
      color: #1e2945;
      font-weight: 600;
    }

    .math-sub {
      font-size: 13px;
      color: #64748b;
      font-weight: 500;
    }

    .tag {
      display: inline-block;
      padding: 2px 8px;
      border-radius: 6px;
      font-size: 12px;
      font-weight: 700;
      background: #ede9fe;
      color: #7c3aed;
    }

    .tag.alert {
      background: #fee2e2;
      color: #dc2626;
    }
  </style>
</head>
<body>

  <div class="stepper-nav">
    <button class="step-btn active" id="btn0" onclick="setStep(0)">1. Row</button>
    <button class="step-btn" id="btn1" onclick="setStep(1)">2. Layer</button>
    <button class="step-btn" id="btn2" onclick="setStep(2)">3. Full Cube</button>
  </div>

  <div class="stage">
    <svg id="cubeSvg" viewBox="-160 -125 320 225">
      
      <g id="dimensionGuides"></g>
      
      <g id="cubesGroup"></g>
    </svg>
  </div>

  <div class="formula-card">
    <div id="formulaMain" class="math-main"></div>
    <div id="formulaSub" class="math-sub"></div>
  </div>

  <script>
    const stepsData = [
      {
        btn: "1. Row",
        tag: "1D Length",
        count: "3 blocks",
        math: "3 \\times 1 \\times 1 = 3\\text{ cm}^3",
        sub: "1 row of 3 unit blocks (Length)",
        cubes: (x, y, z) => y === 0 && z === 0
      },
      {
        btn: "2. Layer",
        tag: "2D Base Area",
        count: "9 blocks",
        math: "3 \\times 3 \\times 1 = 9\\text{ cm}^3",
        sub: "3 rows make 1 bottom layer (Area = 3 × 3)",
        cubes: (x, y, z) => y === 0
      },
      {
        btn: "3. Full Cube",
        tag: "3D Volume",
        count: "27 blocks",
        math: "3 \\times 3 \\times 3 = 27\\text{ cm}^3",
        sub: "3 identical layers stacked high (Volume)",
        cubes: (x, y, z) => true
      }
    ];

    let currentStep = 0;
    const S = 25; // cube size scale
    const ISO_X = Math.cos(Math.PI / 6) * S; // ~21.65
    const ISO_Y = Math.sin(Math.PI / 6) * S; // 12.5

    // Project (x, y, z) to 2D isometric point
    // x: depth to right (+X)
    // z: width to left (+Z)
    // y: height up (+Y)
    function project(x, y, z) {
      const px = (x - z) * ISO_X;
      const py = (x + z) * ISO_Y - y * S;
      return [px, py];
    }

    function createCubeSVG(x, y, z, isActive) {
      const g = document.createElementNS('http://www.w3.org/2000/svg', 'g');
      g.setAttribute('class', isActive ? 'cube-face' : 'cube-face cube-ghost');

      const p = (dx, dy, dz) => project(x + dx, y + dy, z + dz);

      // Top face (+Y normal)
      const topPts = [p(0,1,0), p(1,1,0), p(1,1,1), p(0,1,1)].map(pt => pt.join(',')).join(' ');
      const top = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
      top.setAttribute('points', topPts);
      top.setAttribute('class', 'cube-top');

      // Left face (+Z normal)
      const leftPts = [p(0,0,1), p(0,1,1), p(1,1,1), p(1,0,1)].map(pt => pt.join(',')).join(' ');
      const left = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
      left.setAttribute('points', leftPts);
      left.setAttribute('class', 'cube-left');

      // Right face (+X normal)
      const rightPts = [p(1,0,0), p(1,1,0), p(1,1,1), p(1,0,1)].map(pt => pt.join(',')).join(' ');
      const right = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
      right.setAttribute('points', rightPts);
      right.setAttribute('class', 'cube-right');

      g.appendChild(right);
      g.appendChild(left);
      g.appendChild(top);

      return g;
    }

    function renderScene() {
      const g = document.getElementById('cubesGroup');
      g.innerHTML = '';

      const isIncluded = stepsData[currentStep].cubes;

      // Render order: bottom to top (y: 0->2), back to front (x+z: 0->4)
      for (let y = 0; y < 3; y++) {
        for (let sum = 0; sum <= 4; sum++) {
          for (let x = 0; x <= 2; x++) {
            const z = sum - x;
            if (z >= 0 && z <= 2) {
              const active = isIncluded(x, y, z);
              // In step 0 & 1, render inactive as ghosts so structure is clear
              const cubeEl = createCubeSVG(x, y, z, active);
              g.appendChild(cubeEl);
            }
          }
        }
      }

      // Update dimension guides
      const guides = document.getElementById('dimensionGuides');
      guides.innerHTML = `
        
        <path d="M ${project(0, 0, 3)[0] - 8} ${project(0, 0, 3)[1] + 8} L ${project(0, 0, 0)[0] - 8} ${project(0, 0, 0)[1] + 8}" stroke="#64748b" stroke-width="1.5" stroke-dasharray="3,3" />
        <text x="${project(0, 0, 1.5)[0] - 22}" y="${project(0, 0, 1.5)[1] + 20}" class="dim-label">3 cm</text>

        
        <path d="M ${project(0, 0, 3)[0] - 6} ${project(0, 0, 3)[1] + 12} L ${project(3, 0, 3)[0] - 6} ${project(3, 0, 3)[1] + 12}" stroke="#64748b" stroke-width="1.5" stroke-dasharray="3,3" />
        <text x="${project(1.5, 0, 3)[0] + 10}" y="${project(1.5, 0, 3)[1] + 22}" class="dim-label">3 cm</text>

        
        <path d="M ${project(3, 0, 3)[0] + 10} ${project(3, 0, 3)[1] + 4} L ${project(3, 3, 3)[0] + 10} ${project(3, 3, 3)[1] + 4}" stroke="#64748b" stroke-width="1.5" stroke-dasharray="3,3" />
        <text x="${project(3, 1.5, 3)[0] + 16}" y="${project(3, 1.5, 3)[1] + 4}" class="dim-label">3 cm</text>
      `;

      // Update Math
      const data = stepsData[currentStep];
      const mainEl = document.getElementById('formulaMain');
      if (window.katex) {
        katex.render(data.math, mainEl, { throwOnError: false });
      } else {
        mainEl.textContent = data.math;
      }
      document.getElementById('formulaSub').innerHTML = `<span class="tag">${data.count}</span> ${data.sub}`;

      // Update button classes
      [0, 1, 2].forEach(i => {
        document.getElementById('btn' + i).className = 'step-btn' + (i === currentStep ? ' active' : '');
      });
    }

    function setStep(idx) {
      currentStep = idx;
      renderScene();
    }

    // Auto-advance with calm pacing
    let timer = setInterval(() => {
      currentStep = (currentStep + 1) % 3;
      renderScene();
    }, 3800);

    // Pause on manual interaction
    document.querySelectorAll('.step-btn').forEach(btn => {
      btn.addEventListener('click', () => {
        clearInterval(timer);
      });
    });

    // Initial render
    window.addEventListener('load', () => {
      renderScene();
    });
  </script>
</body>
</html>

Be careful not to add the sides together — $3 + 3 + 3 = 9$ only counts a few edges, but multiplying gives all $27$ blocks inside.

How do we measure huge spaces like a bedroom or a shipping truck?

For large rooms, we use **cubic meters**, written as **$\text{m}^3$**.

If a storage room is $4\text{ m}$ long, $3\text{ m}$ wide, and $2\text{ m}$ high, its volume is $4 \times 3 \times 2 = 24\text{ m}^3$.

<!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>Volume of Cuboids</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: transparent;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      padding: 10px;
      gap: 8px;
    }

    .formula-bar {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      font-size: 1.15rem;
      font-weight: 700;
      background: #ffffff;
      padding: 8px 16px;
      border-radius: 12px;
      box-shadow: 0 2px 8px rgba(30, 41, 69, 0.06);
      border: 1px solid #e2e8f0;
      flex-wrap: wrap;
    }

    .val-l { color: #2563eb; }
    .val-w { color: #d97706; }
    .val-h { color: #7c3aed; }
    .val-v { color: #10b981; }

    .stage {
      width: 100%;
      max-width: 440px;
      height: 230px;
      position: relative;
      display: flex;
      align-items: center;
      justify-content: center;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
    }

    .controls {
      display: flex;
      flex-direction: column;
      gap: 8px;
      width: 100%;
      max-width: 440px;
    }

    .presets {
      display: flex;
      justify-content: center;
      gap: 6px;
    }

    .btn {
      appearance: none;
      border: 1px solid #e2e8f0;
      background: #ffffff;
      color: #1e2945;
      font-weight: 600;
      font-size: 0.8rem;
      padding: 5px 12px;
      border-radius: 8px;
      cursor: pointer;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
      transition: background-color 0.15s, border-color 0.15s;
    }

    .btn.active {
      background: #10b981;
      color: #ffffff;
      border-color: #10b981;
    }

    .sliders {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
      background: #ffffff;
      padding: 8px 12px;
      border-radius: 10px;
      border: 1px solid #e2e8f0;
    }

    .slider-group {
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 4px;
    }

    .slider-label {
      font-size: 0.75rem;
      font-weight: 700;
    }

    input[type="range"] {
      width: 100%;
      height: 6px;
      accent-color: #10b981;
      cursor: pointer;
    }

    #range-l { accent-color: #2563eb; }
    #range-w { accent-color: #d97706; }
    #range-h { accent-color: #7c3aed; }
  </style>
</head>
<body>

  <div class="formula-bar">
    <span class="val-l" id="txt-l">4</span>
    <span>×</span>
    <span class="val-w" id="txt-w">3</span>
    <span>×</span>
    <span class="val-h" id="txt-h">2</span>
    <span>=</span>
    <span class="val-v" id="txt-v">24 m³</span>
  </div>

  <div class="stage">
    <svg id="iso-svg" viewBox="0 0 440 230"></svg>
  </div>

  <div class="controls">
    <div class="presets">
      <button class="btn active" id="btn-room" onclick="setDimensions(4,3,2,this)">4 × 3 × 2</button>
      <button class="btn" id="btn-cube" onclick="setDimensions(3,3,3,this)">3 × 3 × 3</button>
      <button class="btn" id="btn-box" onclick="setDimensions(5,2,3,this)">5 × 2 × 3</button>
    </div>

    <div class="sliders">
      <div class="slider-group">
        <span class="slider-label val-l">L: <span id="lbl-l">4</span>m</span>
        <input type="range" id="range-l" min="1" max="5" value="4" oninput="onSliderChange()">
      </div>
      <div class="slider-group">
        <span class="slider-label val-w">W: <span id="lbl-w">3</span>m</span>
        <input type="range" id="range-w" min="1" max="5" value="3" oninput="onSliderChange()">
      </div>
      <div class="slider-group">
        <span class="slider-label val-h">H: <span id="lbl-h">2</span>m</span>
        <input type="range" id="range-h" min="1" max="5" value="2" oninput="onSliderChange()">
      </div>
    </div>
  </div>

  <script>
    let L = 4, W = 3, H = 2;

    const svg = document.getElementById('iso-svg');
    const txtL = document.getElementById('txt-l');
    const txtW = document.getElementById('txt-w');
    const txtH = document.getElementById('txt-h');
    const txtV = document.getElementById('txt-v');
    const lblL = document.getElementById('lbl-l');
    const lblW = document.getElementById('lbl-w');
    const lblH = document.getElementById('lbl-h');
    const rangeL = document.getElementById('range-l');
    const rangeW = document.getElementById('range-w');
    const rangeH = document.getElementById('range-h');

    function setDimensions(l, w, h, btn) {
      L = l; W = w; H = h;
      rangeL.value = L;
      rangeW.value = W;
      rangeH.value = H;
      document.querySelectorAll('.presets .btn').forEach(b => b.classList.remove('active'));
      if (btn) btn.classList.add('active');
      render();
    }

    function onSliderChange() {
      L = parseInt(rangeL.value, 10);
      W = parseInt(rangeW.value, 10);
      H = parseInt(rangeH.value, 10);
      document.querySelectorAll('.presets .btn').forEach(b => b.classList.remove('active'));
      if (L === 4 && W === 3 && H === 2) document.getElementById('btn-room').classList.add('active');
      else if (L === 3 && W === 3 && H === 3) document.getElementById('btn-cube').classList.add('active');
      else if (L === 5 && W === 2 && H === 3) document.getElementById('btn-box').classList.add('active');
      render();
    }

    function render() {
      txtL.textContent = L;
      txtW.textContent = W;
      txtH.textContent = H;
      txtV.textContent = `${L * W * H} m³`;
      lblL.textContent = L;
      lblW.textContent = W;
      lblH.textContent = H;

      const maxDim = Math.max(L + W, H * 1.5, 6);
      const s = Math.min(26, 175 / maxDim);
      const cos30 = 0.866025;
      const sin30 = 0.5;

      const cx = 220 - (L - W) * s * cos30 * 0.5;
      const cy = 115 + (H * s - (L + W) * s * sin30) * 0.5;

      function pt(x, y, z) {
        return [
          cx + (x - y) * s * cos30,
          cy + (x + y) * s * sin30 - z * s
        ];
      }

      function pathD(pts) {
        return pts.map((p, i) => `${i === 0 ? 'M' : 'L'}${p[0].toFixed(1)},${p[1].toFixed(1)}`).join(' ') + 'Z';
      }

      let html = '';

      for (let z = 0; z < H; z++) {
        for (let sum = 0; sum <= (L - 1) + (W - 1); sum++) {
          for (let x = 0; x < L; x++) {
            const y = sum - x;
            if (y < 0 || y >= W) continue;

            const isTop = (z === H - 1);
            const isRight = (y === W - 1);
            const isLeft = (x === L - 1);

            if (isTop) {
              const pTop = [pt(x, y, z + 1), pt(x + 1, y, z + 1), pt(x + 1, y + 1, z + 1), pt(x, y + 1, z + 1)];
              html += `<path d="${pathD(pTop)}" fill="#6ee7b7" stroke="#059669" stroke-width="0.8" opacity="0.95" />`;
            }

            if (isRight) {
              const pRight = [pt(x, y + 1, z), pt(x + 1, y + 1, z), pt(x + 1, y + 1, z + 1), pt(x, y + 1, z + 1)];
              html += `<path d="${pathD(pRight)}" fill="#10b981" stroke="#047857" stroke-width="0.8" />`;
            }

            if (isLeft) {
              const pLeft = [pt(x + 1, y, z), pt(x + 1, y + 1, z), pt(x + 1, y + 1, z + 1), pt(x + 1, y, z + 1)];
              html += `<path d="${pathD(pLeft)}" fill="#059669" stroke="#065f46" stroke-width="0.8" />`;
            }
          }
        }
      }

      const p000 = pt(0, 0, 0);
      const pL00 = pt(L, 0, 0);
      const pLW0 = pt(L, W, 0);
      const p0W0 = pt(0, W, 0);
      const pLWH = pt(L, W, H);

      const off = 10;
      const dimL_1 = [p0W0[0] + off * cos30, p0W0[1] + off * sin30];
      const dimL_2 = [pLW0[0] + off * cos30, pLW0[1] + off * sin30];

      const dimW_1 = [pL00[0] - off * cos30, pL00[1] + off * sin30];
      const dimW_2 = [pLW0[0] - off * cos30, pLW0[1] + off * sin30];

      const dimH_1 = [pLW0[0] + off, pLW0[1]];
      const dimH_2 = [pLWH[0] + off, pLWH[1]];

      html += `
        
        <line x1="${dimL_1[0]}" y1="${dimL_1[1]}" x2="${dimL_2[0]}" y2="${dimL_2[1]}" stroke="#2563eb" stroke-width="2" stroke-linecap="round" />
        <circle cx="${dimL_1[0]}" cy="${dimL_1[1]}" r="2.5" fill="#2563eb" />
        <circle cx="${dimL_2[0]}" cy="${dimL_2[1]}" r="2.5" fill="#2563eb" />
        <text x="${(dimL_1[0] + dimL_2[0]) / 2 + 6}" y="${(dimL_1[1] + dimL_2[1]) / 2 + 12}" fill="#2563eb" font-size="12" font-weight="700" text-anchor="middle">${L}m</text>

        
        <line x1="${dimW_1[0]}" y1="${dimW_1[1]}" x2="${dimW_2[0]}" y2="${dimW_2[1]}" stroke="#d97706" stroke-width="2" stroke-linecap="round" />
        <circle cx="${dimW_1[0]}" cy="${dimW_1[1]}" r="2.5" fill="#d97706" />
        <circle cx="${dimW_2[0]}" cy="${dimW_2[1]}" r="2.5" fill="#d97706" />
        <text x="${(dimW_1[0] + dimW_2[0]) / 2 - 8}" y="${(dimW_1[1] + dimW_2[1]) / 2 + 12}" fill="#d97706" font-size="12" font-weight="700" text-anchor="middle">${W}m</text>

        
        <line x1="${dimH_1[0]}" y1="${dimH_1[1]}" x2="${dimH_2[0]}" y2="${dimH_2[1]}" stroke="#7c3aed" stroke-width="2" stroke-linecap="round" />
        <circle cx="${dimH_1[0]}" cy="${dimH_1[1]}" r="2.5" fill="#7c3aed" />
        <circle cx="${dimH_2[0]}" cy="${dimH_2[1]}" r="2.5" fill="#7c3aed" />
        <text x="${dimH_1[0] + 12}" y="${(dimH_1[1] + dimH_2[1]) / 2 + 4}" fill="#7c3aed" font-size="12" font-weight="700">${H}m</text>
      `;

      svg.innerHTML = html;
    }

    render();
  </script>
</body>
</html>

Next time you look at any box, just multiply its three sides to instantly find how much it can hold.

math

Calculating Volume of Cubes and Cuboids. Apply V = l × w × h to compute rectangular prism volume in cm³ and m³.

Volume of 3D Shapes - Cubes and Cuboids (CfE Third Level Maths)

Volume of a Rectangular Prism and Cube

Volume of Rectangular Prisms and Cubes: Lesson & Interactive Practice

Although the prompt header mentions Early Level (P1), standard MNU 3-11a and formulaic volume calculations ($V = l \times w \times h$) belong to Curriculum for Excellence Third Level (secondary S1–S3, approx. ages 11–14). The pedagogical approach connects the concrete visual representation of counting unit cubes in horizontal layers to the abstract algebraic formula $V = l \times w \times h = A_{\text{base}} \times h$, cementing dimensional reasoning before students progress to oblique prisms and cylinders.

Calculating Volume of Cubes and Cuboids

The Unit Cube

The Volume Formula