# What's the limitation that requires Solidity array dimensions to be declared backwards?

From docs:

In Solidity, array dimensions are declared backwards from the way you might be used to declaring them in C or Java, but they are access as in C or Java.

For example, int8[][5] somearray; are 5 dynamic int8 arrays.

The reason for this is that T[5] is always an array of 5 T's, no matter whether `T` itself is an array or not (this is not the case in C or Java).

The question is why must in Solidity "T[5] is always an array of 5 T's" ?

There is no any limitation, this is just syntactic feature. It is quite unusual but has some rationale behind it.

E.g. in C language `int8 x[5]` reads as "x is an array of 5 int8 elements". And this one `int8 y[5][4]` is "y is an array of 5 arrays of 4 int8 elements each".

Note that order of terms `x`, `int8`, `5`, `4` in declaration and in English explanation is not the same.

In Solidity `int8[5][4] x` reads as "x is array of 4 arrays of 5 int8 elements each". You need to read backwards but order of terms is now consistent.

Go language goes one step further — it has terms in order and does not require you to read backwards: `var a [5][4]int` is "variable a is array of 5 arrays of 4 int elements each".

So, "T[5] is always an array of 5 T's" means that for any type `T` (be it `int8` or `bool[3][2]`) `T[5]` will always be array of 5 elements. This is not true for some languages like C: `T[5]` could be

• array of 5 ints: `int x[5]` (T is `int x`)
• array of 4 arrays of ints: `int x[4][5]` (T is `int x[4]`)
• ...