Lua is so underrated | Noë Flatreaud

26 Dec, 2024

The more I learn about Lua’s design and implementation, the more impressed I am. It’s very rare to see software that does so much with so little code.

Unfortunately, Lua doesn’t have the same level of marketing and hype as some other languages. This lack of promotion means that fewer developers are aware of Lua’s capabilities and benefits. It is often perceived as a niche language, primarily used in gaming and embedded systems.

Consequently, Lua may not receive the attention it deserves, even though it has a lot to offer ;

Lua is easy to understand

Lua is a free, reflexive and imperative scripting language. Created in 1993, designed to be embedded within other applications to extend them. The interpreter was developed by Brazillian engineers and has been updated many times since.

Its design is clean, and the code is fast.

The C API is easy to use and gives good performance, and yet encapsulates enough of the VM’s implementation that C modules are source and binary compatible with both Lua and LuaJIT. Its syntax is clean and minimalistic, making it accessible even for beginners, yet is incredibly easy to master.

Lua is extremely embeddable.

Lua is designed to be easily embedded into applications written in other languages, particularly C and C++. This makes it an excellent choice for scripting and extending games and embedded applications. In C for example, embedding Lua is as :

#include 
#include 
#include 

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dofile(L, "./myscript.lua");
    lua_close(L);
    return 0;
}

Multi-paradigm support

Standalone or with the right libraries, Lua supports multiple programming paradigms, including imperative, functional, and object-oriented programming. This flexibility does allow us to use the one that best suits our needs.

Yet, not everything might suit everyone…

Indexing conventions

In Lua, indexing generally starts at index 1, but is only a convention. Arrays can be indexed by 0, negative numbers, or any other value (anything but nil).

Error handling

While I personally like how Lua handles errors, it might be less intuitive for developers coming from other languages. In Lua, errors may be handled as values, just like in Go :

function risky_function()
    error("Something went wrong!")
end

local status, err = pcall(risky_function)
if not status then
    print("Error: " .. err)
end

Nil-Terminated Arrays

The one that bothers me the most, might be the fact that arrays (tables used as arrays) are nil-terminated, meaning the end of the array is marked by a nil value. This can lead to unexpected behavior if not handled properly:

local arr = {10, 20, 30, nil, 50}
for i, v in ipairs(arr) do
    print(v)  -- Output: 10, 20, 30 (nil terminates the array)
end

The ipairs function stops iterating when it encounters a nil value, which can be surprising if you expect it to continue iterating over the entire table.

Tldr ;

Lua is a powerful, efficient, and versatile programming language that deserves, for me, more recognition. Its simplicity, embeddability, and performance make it an excellent choice for a wide range of applications like games and embedded systems. However, its perception as a niche language and competition from more popular languages have contributed to its underrated status.

If you’re looking for a straightforward, efficient scripting language, just give it a try, you’d be surprised.

FYI : Lua is used in nvim for plugins since 0.5.0, you bet it’s efficient !