A blog on software engineering by Trevor Brown

Introduction to Lua

This was a talk I gave at the Sarasota Software Engineers User Group in Sarasota on August 26, 2015

  • Abstract: Most popular scripting languages now contain many paradigm specific and platform specific features that increase the complexity of the language. Few of these languages are simple enough to be embedded in existing applications easily. Lua’s extensibility and simplicity makes it an ideal choice for embedded scripting. Lua is often embedded in video games, desktop GUI applications, server software, and even mobile applications. This talk covers the basics of the Lua. I will demonstrate how Lua’s simplicity allows for quick development of small utility scripts. I will also show how Lua’s powerful meta-mechanisms allow for rapid development of software in prototypal OO, classical OO, and functional paradigms. At the end of the talk I will integrate Lua into an existing application.
  • Slides:

I started learning Lua at the end of 2013 for a project that I was going to be working on. At the beginning of 2014 I started on the project - using Corona SDK to develop a simple native mobile app for Android and iOS. Development took about two months to complete. Corona SDK has a Lua API that allows you to write native iOS and Android apps in Lua code. Overall Corona SDK works pretty well. The documentation seems to be out of date in some places but in general was pretty good. The API did have a few quirks but it is more than sufficient for mobile games. Business apps are more of a challenge as the API is oriented more towards game type functionality, such as sprites, 2D physics and sound. In this post I am not going to talk about Corona but rather Lua, programming language itself.

I have really enjoyed programming in Lua. I only used it for about two months and it took me less than 2 weeks to learn.

Lua is a lightweight, interpreted programming language implemented in ANSI C. It is multi-paradigm, allowing you to write procedural, object-oriented, or prototypal code. It was created in 1993 by Roberto Ierusalimschy. It’s open source and has been released under the MIT license. While Lua is often embedded in larger applications to allow for extension via Lua scripting, it’s not limited to just that. It’s efficiency and extensibility make it possible to write large standalone applications in Lua. Lua is also one of the easiest languages to learn.

In this post I want to highlight the strengths of Lua as well as list the some well known applications that use it.

##Where is Lua Used? Here is a list of a few prominent pieces of software that use Lua for scripting/plugins/extensions:

  • Adobe Photoshop Lightroom - for the UI and plugins
  • Freeswitch - embedded scripting
  • Lego Mindstorms NXT - scripting
  • Redis - embedded scripting
  • NeoVim - plugins
  • Wireshark - plugins
  • Both Nginx and Apache have Lua modules.

This isn’t a complete list! Lua seems to appear almost everywhere. Many other enterprise applications have a embedded Lua interpreters for scripting. Lua is also commonly used in game development due to it’s performance and short learning curve. Dozens of games use Lua for plugins and extensions, as well as core game logic.

##Strengths of Lua


The first thing you will notice when learning Lua is how simple it is. The syntax is very clean and feels similar to Ruby or Basic. The control structures are simple and there are only a few of them. There are only a handful of data types. The complete list is: nil, boolean, number, string, table, function, userdata and thread. That’s it. There aren’t different types of numbers, they are all just numbers (they are stored as IEEE 754 floats). There aren’t arrays, tuples, and associative arrays, there are only tables. Tables are simple collections of key-value pairs that can be treated as arrays, objects or any other sort of compound data structure. Here is a short example of the different types and how they work (note that comments are started with “–”):

-- numbers
local one = 1
local one_and_a_half = 1.5

-- strings
local greeting = "Hello World"

-- tables
local empty_table = {}
local translations = {
    'one' = 1,
    'two' = 2,
    'three' = 3,
    'four' = 4,
    'five' = 5
-- table functioning like an array
local array_like = { "a", "b", "c" }
-- table indexes start at 1
print(array_like[1]) --> "a"

-- functions
local function word_to_number(word)
    local number = translations[word]
    if not number then
      return "word must be greater than 5"
      return number
-- invoke the function
word_to_number('three') --> 3

Those are the most commonly used first class values in Lua. There isn’t really anything else. Everything else can be created with some combination of tables, functions and the other data types. Control structures are very simple as well. There are if statements and while, repeat, and for loops. There are also break and return commands. Lua does not have a case statements but haven’t ever found myself needing them. Pretty much everything you would do with a case statement can be done with if/elseif statements or lookup tables.

-- if/elseif/else
if a => 1 then
  return "too big"
elseif a =< 0 then
  return "too small"
  return "somewhere between 0 and 1"

-- for loops
-- numeric for loop
for i = 1, math.huge() do
  -- this will loop forever unless a = true
  if a then

-- generic for loop
for k, v in pairs(translations) do
  -- loops over all the numbers in translations table and print key-value pairs one at a time
  print(k, v)

Lua’s simplicity and it’s similarity to JavaScript make it a great first programming language. With the libraries and game frameworks out there anyone new to the language can quickly put there skills to use building simple applications. Lua’s simplicity also makes it a very easy language teach.


Lua’s simplicity also makes Lua relatively flexible. You can write procedural or object-oriented applications. You can create classical or prototypal objects. Since there are no classes or objects, you might think that implementing any sort of classical object oriented functionality in Lua would be difficult. This is not the case, using Lua’s tables and metatables it is relatively simple to create classes. Lua does tend to lend itself to a more prototypal object model but that doesn’t mean we can’t create our own classes. In order to understand how classes are created we first need to know how metatables work:

-- metatables are similiar to JavaScript prototypes and provide
-- a sort of operator overloading.
-- metatables can contain various attributes that are read by Lua when
-- performing certainly operations. For example,
-- __index is a metatable attribute Lua checks when a key is missing in a table.
defaults = {favorite_language = 'Lua'}
defaults.__index = defaults
user = {}

-- If we set `defaults` as the metatable Lua will check the table assigned
-- to the metatables `__index` attribute if a key is missing.
setmetatable(user, defaults)
print(getmetatable(user)) --> table: 0x15ebe60
print(user.favorite_language) --> 'Lua'

-- there are many other metatable attributes - __newindex, __mode, __call, __metatable,
-- __tostring, __len, __gc, __eq, __lt, __le, __unm, __add, __sub, __mul, __div,
-- __mod, __pow, __concat

Metatables are very powerful and are used for many things. Now that we have seen how they work let’s use them to create a class:

-- With metatables creating objects and classes is easy.
local User = {}
User.__index = User

function User:new(first_name, last_name, favorite_language)
    local user = {
        first_name = first_name,
        last_name = last_name,
        favorite_language = favorite_language
    setmetatable(user, User)
    return user

-- This:
function User:display_name()
    return self.first_name .. ' ' .. self.last_name

-- Is shorthand for this:
function User.display_name(self)
    return self.first_name .. ' ' .. self.last_name

-- The display_name function will be used to print the user
User.__tostring = User.display_name

local u = User:new('Joe', 'Armstrong', 'Erlang')
print(u:display_name()) --> 'Joe Armstrong'
print(u) --> 'Joe Armstrong'

That is pretty much all there is to creating classes. Of course this is a very simple example. Other object-oriented features like inheritance and information hiding can also be implemented with a combination of metatables and closures.

Lua can also be extended easily with C/C++. It has really easy to use C interface and there are many open source libraries for interfacing between Lua and other programming languages.


Lua is one of the fastest interpreted languages out there today. It is often significantly faster Ruby or Python. This is no doubt due in part to Lua’s simplicity. LuaJIT makes it even faster.


Lua runs on any architecture that can execute ANSI C code. That means Lua runs nearly everywhere. Almost any platform you can think of can run Lua. In addition to all the major desktop operating systems, Lua runs on Android, iOS, Kindle, Nook, Xbox, Playstation, Raspberry Pi, Adruino, and more. Since Lua is so portable it is a great choice for any piece of software that needs to run on multiple platforms. This is one of the reasons Lua is often used for cross-platform games.


Lua is a great language with some very unique strengths. It’s hard to beat Lua’s combination of flexibility, simplicity and performance.

Hopefully this has post has gotten you interested in Lua. If you haven’t ever used it before I encourage you to give it a try. If you are an experienced programmer you will likely find a few things annoying (one-based indexes for tables for example). And while you won’t likely end up writing large pieces of software in Lua there is a chance something in your large applications could benefit from a little Lua code (HTTP request preprocessing in nginx or Apache perhaps?). If your new to programming Lua’s simplicity will make it easy to learn the basics and become familiar with the programming constructs that are present in most other languages.