On September 24, 2026, Microsoft announced Excel’s support of nested arrays. This feature allows arrays to be stored in a single cell. It also allows arrays to be nested inside other arrays.

For example, here’s a spilled array of four numbers:

We can wrap this in braces to nest this 2×2 array into a 1×1 array, like this:

When you nest an array, you get an icon in the cell. Clicking the icon shows the card (the dark area to the right of B2 in the image above). Note the formula.

Frequently, when talking about arrays, I’ll think in terms of ‘levels’. In the example above, the top level is a 1×1 array, with the only element in that top-level being the 2×2 array created by SEQUENCE(2,2).

We can continue to nest arrays in this way. Here’s another example:

In this example, the top level is a 1×2 array (i.e. 1 row and 2 columns). In that top level array, the first element at index [1,1] is the 2×2 array created by SEQUENCE(2,2) and the second element at index [1,2] is the 2×2 array created by SEQUENCE(2,2,5), which is to say four successive integers starting at 5.

And we can wrap this array in a 1×1, like this:

This gives us a 1×1 array containing 2 2×2 arrays. On the card, clicking either will “drill-in” to that array’s contents. Note that the card shows the shape of the currently visible array.

Indexing nested arrays

Frequently we’ll want to access individual elements of an array. Remember that for a range or spilled array like this:

We can extract an element with a formula like INDEX(B2#, 2, 2), which gives us the element from the 2nd row and the 2nd column of the reference in the first argument (the spilled array B2#), which is 4.

For the simple case where we have nested the above array in a 1×1:

The top level is ignored by INDEX and the indexing happens on the level below (the 2×2 array nested within). This may seem odd at first, but think about it: if we also had to INDEX the top level, we would have to include INDEX(ref, 1, 1) in every formula (in order to get the 1st row, 1st column of that top-level array). So the above formula would otherwise need to be this: =INDEX(INDEX(B2,1,1),2,2). That could get annoying pretty quickly.

In the next example, it’s the 1×2 array, where each element contains a 2×2 array. The first call to INDEX operates on the top level. So calling INDEX(B2#,1,1) returns the array in the 1st row and 1st column:

Note that this is NOT returning a 2×2 array nested inside a 1×1 array, it is simply returning a 2×2 array, so that array uses the default behavior of spilling to the grid. If we wanted it to remain in a single cell, we would need to wrap that call to INDEX in braces, like this: ={INDEX(B2#, 1, 1)}.

If we want to return a single value from one of the arrays in the nested array in B2# above, we would need to call INDEX again on one of those nested arrays.

In this way, you can see that each level requires a call to INDEX in order to pull an element from that level. In the example above, we have 2 2×2 arrays inside a 1×2 array, and we need to call INDEX twice to return a value from the bottom level, so we can say that the nested array in B2# has a depth of 2.

Here’s another depth 2 nested array:

The first formula returns the array at position [2,2] and the second formula returns the value from that array at position [2,2], i.e. 16. Hopefully this is clear.

Note that when we wrap the above in a 1×1, it becomes a depth-3 nested array, but the formulas still return the same results.

Just for clarity, all of the above is not limited to formulas defining arrays, values are also valid. The SEQUENCE formula above returns the same values as this:

={{{1,2;3,4},{5,6;7,8};{9,10;11,12},{13,14;15,16}}}

I’ll use that formula in the examples in the next section.

But before we go there, let’s simplify indexing a little with a LAMBDA.

NESTEDINDEX=LAMBDA(t,coords,
    REDUCE(
        t,
        SEQUENCE(ROWS(coords)),
        LAMBDA(a,n,
            INDEX(
                a,
                INDEX(coords,n,1),
                INDEX(coords,n,2)
            )
        )
    )
);

This formula can be called like this:

The coords argument in the first call is {1,2}. This means ‘return the value at row 1, column 2 at the first indexing level.’ It returns the array in B6.

In the second call, the coords argument is {1,2;2,1} – this is saying “return the value from row 2, col 1 from the array at row 1, col 2”, which is just the value 7.

Think of each coordinate pair, x,y, separated by a comma as operating on a level of nesting. When we see a semicolon, the next coordinate pair operates on the value returned by the preceding coordinate pair.

Anyway, let’s move on!

Addition over nested arrays

Take a look at these formulas.

When we apply a simple aggregate function like SUM (or MAX, MIN, and others) to a nested array, it will traverse the bottom level, or the maximum depth of the nested array, meaning in this example it’s summing all of the individual integers in the nested array in B3, which sum to 136.

When we use SCAN, the function skips the 1×1 level then applies its function argument (SUM in this case) to each of the four elements at the next level. So, the input to SCAN can be thought of as the 2×2 array at the second level of the nested array above. Each of those elements itself contains a 2×2 array and these are summed, passing each successive sum as the accumulated value to the next pass.

That’s a little cryptic, so look at it this way:

// Pass 1:
SUM(0,{1,2;3,4})=10

// Pass 2:
SUM(10,{5,6;7,8})=36

// Pass 3:
SUM(36,{9,10;11,12})=78

// Pass 4:
SUM(78,{13,14;15,16})=136

And of course REDUCE operates the same way, and returns the final accumulated value 136.

Summary

There is an immense amount of examples to explore with nested arrays, so let’s call it a day for now and talk in more detail later. Perhaps these few reminders will help:

• Arrays can be nested to (almost) arbitrary depth
• A single call to INDEX will find a value (array or otherwise) at the top level of its first argument
• The NESTEDINDEX LAMBDA function allows you to extract values (array or otherwise) from any depth of a nested array
• Simple aggregates like SUM, MIN, MAX and so on will use the leaf values at the lowest level of a nested array
• Higher-order functions like SCAN and REDUCE will apply their accumulation function on the array elements at the current level of their input array