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 a moving box completely with identical 1-inch wooden blocks. How many blocks could you pack inside without leaving any empty gaps?

That total count of unit cubes is what we call **volume** — the amount of 3D space an object occupies.

A **rectangular prism** is a solid 3D shape bounded by six flat rectangular faces meeting at right angles.

To find how many unit cubes fit inside, we first lay a single flat layer along the bottom of length $l$ and width $w$, which gives $l \times w$ cubes.

Then, we stack identical layers upward until we reach the full height $h$, giving us the formula $V = l \times w \times h$.

<!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 Rectangular Prisms</title>
  <link rel="stylesheet" href="{{VENDOR_CDN}}/katex.min.css">
  <script src="{{VENDOR_CDN}}/katex.min.js"></script>
  <script src="{{VENDOR_CDN}}/classace-diagram.js"></script>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; font-family: system-ui, -apple-system, sans-serif; }
    body {
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 12px;
      gap: 10px;
      min-height: 100%;
      user-select: none;
    }
    .stepper {
      display: flex;
      gap: 6px;
      flex-wrap: wrap;
      justify-content: center;
      width: 100%;
      max-width: 480px;
    }
    .step-btn {
      flex: 1 1 70px;
      padding: 6px 10px;
      background: #ffffff;
      border: 1.5px solid #e2e8f0;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
      cursor: pointer;
      text-align: center;
      transition: all 0.2s ease;
    }
    .step-btn.active {
      background: #e0f2fe;
      border-color: #0284c7;
      color: #0369a1;
      box-shadow: 0 1px 3px rgba(2, 132, 199, 0.15);
    }
    .stage {
      position: relative;
      width: 100%;
      max-width: 480px;
      height: 220px;
      background: #ffffff;
      border-radius: 12px;
      border: 1px solid #e2e8f0;
      display: flex;
      align-items: center;
      justify-content: center;
      overflow: hidden;
    }
    svg {
      width: 100%;
      height: 100%;
    }
    .cube-top { fill: #38bdf8; stroke: #0284c7; stroke-width: 1; transition: fill 0.3s ease; }
    .cube-left { fill: #0284c7; stroke: #0369a1; stroke-width: 1; transition: fill 0.3s ease; }
    .cube-right { fill: #0ea5e9; stroke: #0284c7; stroke-width: 1; transition: fill 0.3s ease; }
    
    .layer-1 .cube-top { fill: #60a5fa; stroke: #2563eb; }
    .layer-1 .cube-left { fill: #2563eb; stroke: #1d4ed8; }
    .layer-1 .cube-right { fill: #3b82f6; stroke: #2563eb; }

    .layer-2 .cube-top { fill: #38bdf8; stroke: #0284c7; }
    .layer-2 .cube-left { fill: #0284c7; stroke: #0369a1; }
    .layer-2 .cube-right { fill: #0ea5e9; stroke: #0284c7; }

    .layer-3 .cube-top { fill: #818cf8; stroke: #4f46e5; }
    .layer-3 .cube-left { fill: #4f46e5; stroke: #3730a3; }
    .layer-3 .cube-right { fill: #6366f1; stroke: #4f46e5; }

    .dim-label {
      font-size: 11px;
      font-weight: 700;
      fill: #475569;
    }
    .dim-line {
      stroke: #64748b;
      stroke-width: 1.5;
      stroke-dasharray: 3 3;
    }

    .formula-card {
      width: 100%;
      max-width: 480px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 10px 14px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      min-height: 48px;
    }
    .formula-math {
      font-size: 15px;
      color: #0f172a;
    }
    .count-badge {
      font-size: 14px;
      font-weight: 700;
      color: #0284c7;
      background: #f0f9ff;
      padding: 4px 10px;
      border-radius: 6px;
      border: 1px solid #bae6fd;
    }
    .controls {
      display: flex;
      align-items: center;
      gap: 12px;
    }
    .play-btn {
      background: none;
      border: none;
      font-size: 18px;
      cursor: pointer;
      color: #64748b;
      padding: 2px 6px;
      border-radius: 4px;
    }
    .play-btn:hover {
      color: #0f172a;
      background: #f1f5f9;
    }
  </style>
</head>
<body>

  <div class="stepper">
    <button class="step-btn active" id="btn-0">1. Unit</button>
    <button class="step-btn" id="btn-1">2. Length</button>
    <button class="step-btn" id="btn-2">3. Layer</button>
    <button class="step-btn" id="btn-3">4. Height</button>
  </div>

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

  <div class="formula-card">
    <div class="controls">
      <button class="play-btn" id="play-btn" title="Auto play">▶</button>
      <div id="formula" class="formula-math"></div>
    </div>
    <div id="unit-count" class="count-badge"></div>
  </div>

  <script>
    const L = 4; // length (x)
    const W = 3; // width (y)
    const H = 3; // height (z)

    // Isometric projection constants
    const ox = 170;
    const oy = 150;
    const dx = 22; // x direction (down-right)
    const dy = 13;
    const wx = -18; // y direction (down-left)
    const wy = 10;
    const hz = 20; // z height (straight up)

    function project(x, y, z) {
      return {
        px: ox + x * dx + y * wx,
        py: oy + x * dy + y * wy - z * hz
      };
    }

    function cubeSVG(x, y, z, layerClass) {
      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);

      return `
        <g class="${layerClass}">
          
          <polygon class="cube-left" points="${p000.px},${p000.py} ${p010.px},${p010.py} ${p011.px},${p011.py} ${p001.px},${p001.py}" />
          
          <polygon class="cube-right" points="${p000.px},${p000.py} ${p100.px},${p100.py} ${p101.px},${p101.py} ${p001.px},${p001.py}" />
          
          <polygon class="cube-top" points="${p001.px},${p001.py} ${p101.px},${p101.py} ${p111.px},${p111.py} ${p011.px},${p011.py}" />
        </g>
      `;
    }

    const steps = [
      {
        title: "1 Unit Cube",
        cubes: [[0, 0, 0]],
        formula: "V = 1\\text{ cm}^3",
        count: "1 unit³",
        dims: { l: 1, w: 1, h: 1 }
      },
      {
        title: "1 Row (Length)",
        cubes: [[0,0,0], [1,0,0], [2,0,0], [3,0,0]],
        formula: "l = 4\\text{ cm}",
        count: "4 cubes",
        dims: { l: 4, w: 1, h: 1 }
      },
      {
        title: "1 Layer (Base)",
        cubes: (function() {
          const arr = [];
          for (let y = 0; y < W; y++) {
            for (let x = 0; x < L; x++) {
              arr.push([x, y, 0]);
            }
          }
          return arr;
        })(),
        formula: "4 \\times 3 = 12\\text{ cm}^2",
        count: "12 cubes",
        dims: { l: 4, w: 3, h: 1 }
      },
      {
        title: "Full Prism",
        cubes: (function() {
          const arr = [];
          for (let z = 0; z < H; z++) {
            for (let y = 0; y < W; y++) {
              for (let x = 0; x < L; x++) {
                arr.push([x, y, z]);
              }
            }
          }
          return arr;
        })(),
        formula: "V = 4 \\times 3 \\times 3 = 36\\text{ cm}^3",
        count: "36 cm³",
        dims: { l: 4, w: 3, h: 3 }
      }
    ];

    let currentStep = 0;
    let autoPlayInterval = null;

    function renderScene(stepIdx) {
      currentStep = stepIdx;
      const step = steps[stepIdx];

      // Update button styles
      for (let i = 0; i < 4; i++) {
        document.getElementById('btn-' + i).classList.toggle('active', i === stepIdx);
      }

      // Sort cubes for isometric painter's algorithm:
      // draw from back (max y, min x, min z) to front
      const sorted = [...step.cubes].sort((a, b) => {
        if (a[2] !== b[2]) return a[2] - b[2]; // bottom z first
        if (a[1] !== b[1]) return b[1] - a[1]; // back y first
        return a[0] - b[0];                    // left x first
      });

      let svgHtml = '';

      // Draw cubes
      sorted.forEach(([x, y, z]) => {
        const layerClass = `layer-${(z % 3) + 1}`;
        svgHtml += cubeSVG(x, y, z, layerClass);
      });

      // Dimension annotations
      const dl = step.dims.l;
      const dw = step.dims.w;
      const dh = step.dims.h;

      if (stepIdx >= 1) {
        // Length label along front-right edge
        const pStart = project(0, 0, 0);
        const pEnd = project(dl, 0, 0);
        const midX = (pStart.px + pEnd.px) / 2 + 8;
        const midY = (pStart.py + pEnd.py) / 2 + 14;
        svgHtml += `<text x="${midX}" y="${midY}" class="dim-label" text-anchor="middle">l = ${dl} cm</text>`;
      }

      if (stepIdx >= 2) {
        // Width label along front-left edge
        const pStart = project(0, 0, 0);
        const pEnd = project(0, dw, 0);
        const midX = (pStart.px + pEnd.px) / 2 - 14;
        const midY = (pStart.py + pEnd.py) / 2 + 12;
        svgHtml += `<text x="${midX}" y="${midY}" class="dim-label" text-anchor="middle">w = ${dw} cm</text>`;
      }

      if (stepIdx >= 3) {
        // Height label along vertical edge
        const pBase = project(dl, 0, 0);
        const pTop = project(dl, 0, dh);
        const midX = pBase.px + 16;
        const midY = (pBase.py + pTop.py) / 2 + 4;
        svgHtml += `<text x="${midX}" y="${midY}" class="dim-label" text-anchor="start">h = ${dh} cm</text>`;
      }

      document.getElementById('prism-svg').innerHTML = svgHtml;

      // KaTeX math rendering
      const formulaEl = document.getElementById('formula');
      katex.render(step.formula, formulaEl, { throwOnError: false });

      // Badge
      document.getElementById('unit-count').textContent = step.count;
    }

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

    function toggleAutoPlay() {
      const btn = document.getElementById('play-btn');
      if (autoPlayInterval) {
        clearInterval(autoPlayInterval);
        autoPlayInterval = null;
        btn.textContent = '▶';
      } else {
        btn.textContent = '⏸';
        autoPlayInterval = setInterval(() => {
          const next = (currentStep + 1) % steps.length;
          setStep(next);
        }, 3200);
      }
    }

    // Bind step buttons
    for (let i = 0; i < 4; i++) {
      document.getElementById('btn-' + i).addEventListener('click', () => {
        if (autoPlayInterval) toggleAutoPlay();
        setStep(i);
      });
    }

    document.getElementById('play-btn').addEventListener('click', toggleAutoPlay);

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

Notice that because we multiply three lengths measured in linear units like centimeters ($\text{cm}$), the resulting volume is measured in **cubic units** like cubic centimeters ($\text{cm}^3$).

How do we apply this formula to solve real-world problems with standard measurements?

Let's find the volume of an aquarium that measures $8\text{ cm}$ long, $5\text{ cm}$ wide, and $4\text{ cm}$ high.

Substitute the dimensions into the formula: $$V = 8\text{ cm} \times 5\text{ cm} \times 4\text{ cm} = 160\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">
<style>
  * { box-sizing: border-box; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
  :root {
    --primary: #22b7ff;
    --length-col: #3b82f6;
    --width-col: #10b981;
    --height-col: #f59e0b;
    --text: #1e2945;
    --muted: #6b7280;
    --bg: #f8f9fa;
  }
  body {
    background: transparent;
    color: var(--text);
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: space-between;
    min-height: 100%;
    padding: 10px;
    user-select: none;
    -webkit-user-select: none;
  }
  .controls {
    display: flex;
    flex-wrap: wrap;
    gap: 12px;
    justify-content: center;
    width: 100%;
    max-width: 500px;
  }
  .slider-box {
    display: flex;
    flex-direction: column;
    align-items: center;
    background: #ffffff;
    padding: 6px 12px;
    border-radius: 10px;
    box-shadow: 0 1px 3px rgba(0,0,0,0.08);
    flex: 1;
    min-width: 100px;
  }
  .slider-label {
    font-size: 13px;
    font-weight: 600;
    margin-bottom: 4px;
    display: flex;
    align-items: center;
    gap: 4px;
  }
  .slider-label.length { color: var(--length-col); }
  .slider-label.width { color: var(--width-col); }
  .slider-label.height { color: var(--height-col); }
  
  input[type="range"] {
    width: 100%;
    accent-color: var(--primary);
    cursor: pointer;
  }
  .slider-box.l input { accent-color: var(--length-col); }
  .slider-box.w input { accent-color: var(--width-col); }
  .slider-box.h input { accent-color: var(--height-col); }

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

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

  .formula-card {
    background: #ffffff;
    padding: 8px 16px;
    border-radius: 12px;
    box-shadow: 0 2px 6px rgba(0,0,0,0.06);
    font-size: 17px;
    font-weight: 700;
    display: flex;
    align-items: center;
    gap: 8px;
    margin-top: 4px;
  }
  .val-l { color: var(--length-col); }
  .val-w { color: var(--width-col); }
  .val-h { color: var(--height-col); }
  .val-total { color: #8b5cf6; }

  .mode-toggle {
    display: flex;
    gap: 6px;
    margin-bottom: 6px;
  }
  .btn-layer {
    font-size: 12px;
    font-weight: 600;
    padding: 4px 10px;
    border: none;
    border-radius: 6px;
    background: #e2e8f0;
    color: var(--text);
    cursor: pointer;
  }
  .btn-layer.active {
    background: var(--primary);
    color: white;
  }
</style>
</head>
<body>

<div class="mode-toggle">
  <button class="btn-layer active" id="btnSolid" onclick="setViewMode('cubes')">Unit Cubes</button>
  <button class="btn-layer" id="btnLayer" onclick="setViewMode('layers')">Layers</button>
</div>

<div class="view-container">
  <svg id="prismSvg" viewBox="-180 -140 360 280">
    <g id="drawGroup"></g>
  </svg>
</div>

<div class="controls">
  <div class="slider-box l">
    <span class="slider-label length">Length: <span id="txtL">4</span></span>
    <input type="range" id="rangeL" min="1" max="6" value="4" oninput="update()">
  </div>
  <div class="slider-box w">
    <span class="slider-label width">Width: <span id="txtW">3</span></span>
    <input type="range" id="rangeW" min="1" max="5" value="3" oninput="update()">
  </div>
  <div class="slider-box h">
    <span class="slider-label height">Height: <span id="txtH">2</span></span>
    <input type="range" id="rangeH" min="1" max="4" value="2" oninput="update()">
  </div>
</div>

<div class="formula-card">
  <span>V = </span>
  <span class="val-l" id="fL">4</span>
  <span>×</span>
  <span class="val-w" id="fW">3</span>
  <span>×</span>
  <span class="val-h" id="fH">2</span>
  <span>=</span>
  <span class="val-total" id="fTotal">24 cm³</span>
</div>

<script>
  let viewMode = 'cubes';

  function setViewMode(mode) {
    viewMode = mode;
    document.getElementById('btnSolid').classList.toggle('active', mode === 'cubes');
    document.getElementById('btnLayer').classList.toggle('active', mode === 'layers');
    update();
  }

  function isoProject(x, y, z) {
    const scale = 22;
    const angX = Math.PI / 6;
    const angY = Math.PI / 6;
    const px = (x * Math.cos(angX) - y * Math.cos(angY)) * scale;
    const py = (x * Math.sin(angX) + y * Math.sin(angY) - z) * scale;
    return [px, py];
  }

  function update() {
    const L = parseInt(document.getElementById('rangeL').value);
    const W = parseInt(document.getElementById('rangeW').value);
    const H = parseInt(document.getElementById('rangeH').value);

    document.getElementById('txtL').textContent = L + " cm";
    document.getElementById('txtW').textContent = W + " cm";
    document.getElementById('txtH').textContent = H + " cm";

    document.getElementById('fL').textContent = L;
    document.getElementById('fW').textContent = W;
    document.getElementById('fH').textContent = H;
    document.getElementById('fTotal').textContent = (L * W * H) + " cm³";

    renderPrism(L, W, H);
  }

  function renderPrism(L, W, H) {
    const g = document.getElementById('drawGroup');
    g.innerHTML = '';

    const midX = L / 2;
    const midY = W / 2;
    const midZ = H / 2;

    const layerGap = viewMode === 'layers' ? 0.35 : 0;

    for (let z = 0; z < H; z++) {
      const zOffset = z * (1 + layerGap);

      for (let y = W - 1; y >= 0; y--) {
        for (let x = 0; x < L; x++) {
          const cx = x - midX;
          const cy = y - midY;
          const cz = zOffset - midZ * (1 + layerGap);

          const p0 = isoProject(cx, cy, cz);
          const p1 = isoProject(cx + 1, cy, cz);
          const p2 = isoProject(cx + 1, cy + 1, cz);
          const p3 = isoProject(cx, cy + 1, cz);
          const p4 = isoProject(cx, cy, cz + 1);
          const p5 = isoProject(cx + 1, cy, cz + 1);
          const p6 = isoProject(cx + 1, cy + 1, cz + 1);
          const p7 = isoProject(cx, cy + 1, cz + 1);

          const topPath = `M ${p4[0]} ${p4[1]} L ${p5[0]} ${p5[1]} L ${p6[0]} ${p6[1]} L ${p7[0]} ${p7[1]} Z`;
          const rightPath = `M ${p1[0]} ${p1[1]} L ${p2[0]} ${p2[1]} L ${p6[0]} ${p6[1]} L ${p5[0]} ${p5[1]} Z`;
          const leftPath = `M ${p2[0]} ${p2[1]} L ${p3[0]} ${p3[1]} L ${p7[0]} ${p7[1]} L ${p6[0]} ${p6[1]} Z`;

          const topEl = document.createElementNS("http://www.w3.org/2000/svg", "path");
          topEl.setAttribute("d", topPath);
          topEl.setAttribute("fill", "#60a5fa");
          topEl.setAttribute("stroke", "#1d4ed8");
          topEl.setAttribute("stroke-width", "0.75");
          topEl.setAttribute("opacity", "0.95");

          const rightEl = document.createElementNS("http://www.w3.org/2000/svg", "path");
          rightEl.setAttribute("d", rightPath);
          rightEl.setAttribute("fill", "#3b82f6");
          rightEl.setAttribute("stroke", "#1d4ed8");
          rightEl.setAttribute("stroke-width", "0.75");
          rightEl.setAttribute("opacity", "0.95");

          const leftEl = document.createElementNS("http://www.w3.org/2000/svg", "path");
          leftEl.setAttribute("d", leftPath);
          leftEl.setAttribute("fill", "#2563eb");
          leftEl.setAttribute("stroke", "#1d4ed8");
          leftEl.setAttribute("stroke-width", "0.75");
          leftEl.setAttribute("opacity", "0.95");

          g.appendChild(leftEl);
          g.appendChild(rightEl);
          g.appendChild(topEl);
        }
      }
    }

    if (viewMode === 'layers') {
      for (let z = 0; z < H; z++) {
        const cz = (z * (1 + layerGap)) - midZ * (1 + layerGap) + 0.5;
        const pos = isoProject(L - midX + 0.4, 0 - midY, cz);
        const text = document.createElementNS("http://www.w3.org/2000/svg", "text");
        text.setAttribute("x", pos[0] + 8);
        text.setAttribute("y", pos[1] + 4);
        text.setAttribute("fill", "#f59e0b");
        text.setAttribute("font-size", "11");
        text.setAttribute("font-weight", "bold");
        text.textContent = `${L * W}`;
        g.appendChild(text);
      }
    }
  }

  update();
</script>

</body>
</html>

What happens if the problem gives you measurements in different units, like meters and centimeters?

Before you multiply, **all dimensions must share the same unit**. Never multiply meters directly by centimeters.

Consider a storage chest with length $1.2\text{ m}$, width $50\text{ cm}$, and height $40\text{ cm}$.

Convert $1.2\text{ m}$ into centimeters first ($1.2 \times 100 = 120\text{ cm}$), then calculate $$V = 120\text{ cm} \times 50\text{ cm} \times 40\text{ cm} = 240{,}000\text{ cm}^3$$

Alternatively, converting all dimensions to meters gives $1.2\text{ m} \times 0.5\text{ m} \times 0.4\text{ m} = 0.24\text{ m}^3$.

A common mistake is writing volume in square units like $\text{cm}^2$ instead of cubic units like $\text{cm}^3$. Remember: area covers a 2D surface, while volume fills 3D space.

Whenever you tackle a 3D geometry problem, check your units first, multiply all three perpendicular dimensions, and write your answer with cubic units.

math

Volume of Rectangular Prisms. Calculate the volume of rectangular prisms using V = l × w × h with appropriate units.

Volume of a Rectangular Prism or Box Examples

Volume and Surface Area of Cuboids and Prisms

Volume of Cubes and Rectangular Prisms: Year 9 Maths Practice

Pedagogical strategy for Year 9–10 mastery: Anchor students' concrete understanding of 3D unit cubes before transitioning to the algebraic formula $V = l \times w \times h$. Explicitly connect this to the generalised prism concept $V = A_{\text{base}} \times h$ to set up subsequent lessons on triangular prisms and cylinders (AC9M9M01). Emphasise real-world modeling tasks involving non-matching linear units, capacity conversions, and inverse algebraic reasoning.

Volume of Rectangular Prisms

Building the Formula

Worked Example: Calculating Volume