I'm building a matrix multiplication calculator as a side project (/) to help students learn linear algebra. Currently, I'm using the standard O(n³) algorithm to multiply matrices:

function calculateMatrixProduct() {
    const matrixA = getMatrixValues('A');
    const matrixB = getMatrixValues('B');
    
    // Check compatibility
    if (matrixA[0].length !== matrixB.length) {
        return;
    }
    
    const result = [];
    const steps = [];
    
    for (let i = 0; i < matrixA.length; i++) {
        const resultRow = [];
        for (let j = 0; j < matrixB[0].length; j++) {
            let sum = 0;
            let stepDetails = [];
            
            for (let k = 0; k < matrixA[0].length; k++) {
                const term = matrixA[i][k] * matrixB[k][j];
                sum += term;
                stepDetails.push(`A[${i+1},${k+1}]×B[${k+1},${j+1}] = ${term.toFixed(2)}`);
            }
            
            resultRow.push(sum);
            steps.push({
                position: `C[${i+1},${j+1}]`,
                calculation: stepDetails.join(' + '),
                result: `= ${sum.toFixed(2)}`
            });
        }
        result.push(resultRow);
    }
}

While this works for small matrices (max 5x5), I want to support larger matrices and improve performance while maintaining the ability to show calculation steps.

I've researched Strassen's algorithm which has O(n^2.807) complexity, but I'm unsure if it's worth implementing for an educational tool where I need to maintain step-by-step explanations. I've also considered Web Workers for background processing, but I'm concerned about the complexity of implementation.

I'm trying to balance performance optimization with educational clarity. I was expecting to find standard JavaScript optimizations for matrix operations or libraries that support both performance and step tracking, but most libraries seem focused solely on performance without exposing calculation steps.