Why Lua Arrays Start at Index 1 Instead of 0

If you have written any code in a C-derived language, you were taught that the first element of an array lives at index 0. It is so baked into modern programming that off-by-one errors are a running joke, and many developers assume zero indexing is simply how arrays work. Then they open Lua for the first time, write something that expects the first element, and discover that Lua is different. In Lua, the first element of an array sits at index 1, and that choice was deliberate, not an accident. Understanding why reveals a lot about how Lua was designed and about a philosophy that is willing to break convention when it makes the language more consistent.

Lua was created in 1993 at the Pontifical Catholic University of Rio de Janeiro by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes. It grew out of earlier languages the same team had built, notably a data-description language called SOL, and it was written in Brazil rather than in the US or Europe. The designers came from a context where FORTRAN, a language that has always indexed arrays from 1, was a familiar influence. For them, one-based indexing was not an exotic quirk but a natural and mathematically conventional way to refer to the first position in a sequence, closer to how you would number items on a handwritten list.

There is also a consistency argument that the Lua team found compelling. In Lua, a table is the single universal data structure, standing in for arrays, records, objects, and maps all at once. The designers wanted array behavior to feel natural alongside the language's other conventions, and they saw one-based indexing as one small way to make the whole system hang together. It also makes some common operations read the way people actually think. Deleting the first element removes element 1. A loop over one to the length of a list uses the same numbers. For many tasks, especially the data-entry and configuration work Lua was first built for, indexing from one avoided a whole class of confusion.

For a senior developer, the practical consequences are worth taking seriously. If you move between ecosystems, the difference is a constant source of subtle bugs. In Lua, the first element is list[1], not list[0], and an empty table still reports a length of 0. Iterating a sequence usually means calling ipairs, which starts at index 1. Some people working with Lua eventually adopt a little helper or a mental rule to keep themselves anchored: always remember you are in Lua, and the off-by-one is on the other side of the fence from most C-style languages.

There is a deeper lesson here, and it is one of the most valuable things a framework or language can teach you. Conventions like zero indexing feel inevitable only because they are everywhere. Lua shows they are a choice, and that a choice made for genuinely defensible reasons can serve a community for decades even when it contradicts the mainstream. Lua has stayed tiny, consistent, and beloved in niches where its embedding model shines, partly because it was willing to make principled decisions rather than blindly copying the dominant languages of its era.

So the next time you write list[1] in Lua and pause, remember it is not a mistake and it is not a quirk the maintainers forgot to fix. It is a deliberate design decision with roots in the language's academic origins and its FORTRAN-flavored heritage, chosen to keep Lua internally consistent. Learning to see it that way, instead of as an annoyance, is a small but meaningful step in thinking like someone who appreciates design tradeoffs rather than just tolerating them.