Lua (programozási nyelv)

Lua
Paradigma	Imperatív
Jellemző kiterjesztés	lua luna lunaire anair
Megjelent	1993
Tervező	Roberto Ierusalimschy Waldemar Celes Luiz Henrique de Figueiredo
Fejlesztő	Roberto Ierusalimschy
Utolsó kiadás	5.4.7 (stabil verzió, 2024. június 25.)
Dialektusok	Metalua, Idle, GSL Shell
Megvalósítások	Lua, LuaJIT, LLVM-Lua, Lua Alchemy
Hatással volt rá	C++, CLU, Modula, Scheme, SNOBOL
Befolyásolt nyelvek	Io, GameMonkey, Squirrel, Falcon, MiniD
Operációs rendszer	többplatformos
Licenc	MIT-licenc
Weboldal

A Lua (portugálul: hold) egy nyílt forráskódú, beágyazható szkriptnyelv, amelyet 1993-ban fejlesztettek ki a brazíliai Katolikus Teológiai Egyetemen. Készítői fontosnak tartották az együttműködést a C nyelvű programokkal, programkönyvtárakkal. Platformfüggetlen; a programok futás előtt bájtkódra fordulnak. Bár önállóan is használható, de inkább beágyazott nyelvként tartják számon, ahogy a Tcl nyelvet is. Más script nyelvekhez képest nagy sebessége, bővíthetősége és 120 kB-os mérete népszerűvé tette a fejlesztők között.

Az értelmező egy C könyvtárból érhető el, ami API-ként szolgál, ha C programból hívják. Ez lehetővé teszi a két nyelv kevert használatát: a Lua is hívhat C függvényeket, és fordítva, a C is meghívhat Lua függvényeket.

ANSI C-ben készült, és az imperatív és a funkcionális paradigmákat támogatja; az objektumorientáltsághoz nem nyújt nyelvi eszközöket, mégis lehet objektumokat készíteni a tábla adattípus felhasználásával.

Szintaxisa

Nyelvi elemek

Az azonosítók betűkből, számokból, aláhúzásjelekből építkezhetnek, ahol az első jel nem lehet szám. A betűkészlet a helyi beállításoktól függ. Egy jel betű volta ellenőrizhető az isalpha, szám volta az isalnum függvénnyel.

A számok tartalmazhatnak törtrészt és decimális exponenst. A tizenhatos számrendszert a 0x előtag jelzi, ahol az x lehet kis- vagy nagybetűs is.

A Lua forráskódban a kis- és nagybetűk nem minősülnek azonosnak.

Típusok

A Lua beépített típusai:

• nil
• boolean
• number
• string
• table
• function
• userdata
• thread

Egy nil típusú változónak egyetlen lehetséges értéke van, a nil. Ez a globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket nil-re állítjuk.

Egy logikai változónak két lehetséges értéke van: true és false. Fontos hibaforrás, hogy a Rubyhoz hasonlóan csak a nil és a false hamis, az üres string vagy a nulla nem. A logikai műveletek: and, or, not.

A számok alapértelmezetten dupla pontosságú lebegőpontos számok. Nincs külön egész típus. A számokon végezhető műveletek operátorai: +, -, *, /, és a hatványozás jele, a ^. Az összehasonlításra a ==, ~= (nem egyenlő), <, >, <=, >= operátorok szolgálnak.

A függvények tárolhatók változókban, és átadhatók paraméterként. A C-ben írt programkönyvtárak felhasználásának elősegítésére a C függvények is kezelhetők így. Függvényhíváskor akkor is ki kell tenni a zárójelet, ha nem adunk meg paramétereket. A Javaban megszokott this itt self. Metódusok hívásakor az objektumot is fel kellene sorolni a paraméterek között:

objektum.metódus(objektum, paraméterek)

de létezik egy szintaktikus cukor ennek a lerövidítésére:

objektum:metódus(paraméterek)

A thread a többszálú programozás programszálainak típusa.

A rövid stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók hosszú szöveg> formában is. A hosszú stringekben levő utasítások, escape sorozatok nem hajtódnak végre. Minden fajta string tárolhat tetszőleges Unicode karaktereket, amik a C fordító char típusára képeződnek le. A fájlokat azonban mindig binárisan érdemes kezelni, mivel a nyelv az stdio C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését.

Az escape sorozatok ugyanazok, mint C-ben.

A userdata C-ben megvalósított adattípusokat tárol. Módosítani, rajta műveleteket végrehajtani csak C függvényekkel lehet, a Lua csak értékadást és egyenlőségvizsgálatot biztosít hozzá.

Táblák

A table a Lua egyetlen összetett típusa, asszociatív tömb. A kulcsok lehetnek számok (ajánlottan csak egészek), stringek, másik táblák vagy függvények. A táblák automatikus indexelése a modernebb nyelvekhez hasonlóan 1-től kezdődik, mivel a 0 index hiánya nem igényel kihasználatlan helyfoglalást.

Bejárásuk kétféle módon lehetséges: csak az egész típusú kulcsokat (és a hozzájuk tartozó értékeket) nézzük végig 1-től az első nem létező kulcsig (ipairs) vagy az összes kulcs-érték párt (pairs).

Táblák létrehozhatók így:

x = {3.14, "ez egy string"}

Ilyenkor az egyes értékeket sorban az 1, 2, 3, ... kulcsokhoz rendeli.

String kulcsokat így lehet használni:

x =
{
  nev = "Kovács János",
  kor = 46,
  fizetes = {ertek = 10000, penznem = "Ft"}
}

A táblák referencia szerint adódnak át:

a_table = {x = 10}  -- Új tábla, egy kulcs-érték pár: "x" kulcs a 10-es számhoz.
print(a_table["x"]) -- A string kulcshoz tartozó érték kiíratása; itt 10.
b_table = a_table
b_table["x"] = 20   -- Az "x"-hez tartozó érték megváltoztatása 20-ra.
print(b_table["x"]) -- Az új érték kiíratása: 20.
print(a_table["x"]) -- ez is 20-at ír, mert az a_table és a b_table ugyanarra a táblára hivatkozik.

Kulcsok, értékek beszúrása, eltávolítása:

myTable = {"a", "b"}
table.insert(myTable, "c")
print(unpack(myTable)) -- eredménye: a   b   c
table.remove(myTable, 2)
print(unpack(myTable)) -- eredménye: a   c

Megjegyzések

Egysoros megjegyzés:

-- Megjegyzés

Többsoros megjegyzés:

--[[Ide egy
többsoros
megjegyzés
került]]

Változók

A változók nevükkel hivatkozhatók.

A táblában levő értékek hivatkozhatók a tömböknél megszokott módon, pl. a[4]. Ha a kulcs string, akkor használható az a["nev"] és a.nev alak is.

A változók láthatóság szempontjából háromfélék lehetnek: globális, lokális, és táblamezők. A változók deklarációjuktól kezdve egészen a legkisebb befoglaló blokk végéig láthatók. Egy változó lokálissá tehető, ha local kulcsszóval deklaráljuk. A függvények paraméterei is lokálisnak tekinthetők. Minden más változó globális. A deklarált, de értéket még nem kapott változók értéke nil. A függvények látják hívási helyük lokális változóit.

Elágazás

A Lua csak a kétirányú elágazást ismeri, a többágú elágazás valójában csak szintaktikus cukor:

if kifejezes then
    blokk
else
    blokk
end

if kifejezes then
    blokk
elseif kifejezes then
    blokk
elseif kifejezes then
    blokk
...
else
    blokk
end

Ciklusok

Elöltesztelő ciklus

Addig hajtja végre a ciklusmagot, amíg a feltétel igaz.

while feltétel do
    -- Utasítások
end

Hátultesztelő ciklus

repeat
    -- Utasítások
until feltétel

A ciklusmagot egyszer mindenképpen végrehajtja, majd utána addig hajtja végre a ciklust, amíg a feltétel hamis (igazzá nem válik). Az until ciklus valójában csak szintaktikus cukor, nem hoz létre új láthatósági tartományt.

Számláló ciklus

for index = start, finish, delta do
    -- Utasítások
end

Az index ciklusváltozót kezdetben start-ra állítja, majd minden iteráció után delta lépésközzel megnöveli. Addig fut, amíg a ciklusváltozó kisebb vagy egyenlő, mint a finish.

Ha delta = 1, akkor a lépésköz elhagyható:

for index = start, finish do
    -- Utasítások
end

Iteráló ciklus

A Luában kétféle iteráló ciklus van. Az ipairs 1-től kezdve a kapott tábla összes egész szám kulcsán sorban végigiterál, egészen addig, amíg nil értéket nem kap. A konvenció szerint ha egy változót kell valahol használni, aminek az értékét soha nem olvassuk (ez esetben a kulcs helyén), akkor az _ nevet adjuk neki.

for _, value in ipairs(lista) do
    -- Utasítások
end

A pairs a kapott tábla összes kulcs-érték párján végigiterál, függetlenül a kulcsok típusától.

for key, value in pairs(lista) do
    -- Utasítások
end

Függvények

A Luában a függvények átadhatók paraméterként, sőt, visszatérési értékek is lehetnek, ahogy a következő példa mutatja:

do
  local oldprint = print   -- a jelenlegi print függvény eltárolása oldprint néven
  function print(s)        -- a print függvény újradefiniálása, itt lehet a szokásos print függvényt használni
    if s == "foo" then
      oldprint("bar")
    else
      oldprint(s)
    end
  end
end

A régi print függvény csak az új print függvényen keresztül érhető el.

A Lua a lezártakat is támogatja:

function hozzaad (x)
  -- visszatér egy új funkcióval, ami hozzáadja x-et a paraméterhez
  return function(y)
    --[[Amikor az x változóra hivatkozunk, ami kívül van az aktuális láthatósági tartományon
        és az élettartama hosszabb, mint ennek a névtelen függvénynek,
        akkor a Lua egy lezártat (closure)  hoz létre]]
    return x + y
  end
end

negyplusz = hozzaad(4)
print(negyplusz(3))  --> kiirja a 7-et

Valahányszor meghívódik a hozzaad, annyiszor új lezárt jön létre az x változóhoz. Így a névtelen függvény mindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be.

Metatáblák

A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példa egy végtelen táblát mutat be. Minden n-re fibs[n] az n-edik Fibonacci-számot adja a dinamikus programozás és a memorizálás segítségével:

fibs = { 1, 1 }                          -- fibs[1] fibs[2] kezdőértékei.

setmetatable(fibs, {
  __index = function(name, n)            -- Ezt hívja, ha még nincs fibs[n].
    name[n] = name[n - 1] + name[n - 2]  -- Kiszámolja és megjegyzi fibs[n]-et.
    return name[n]
  end
})

Egy másik példa: a __call metametódus az objektumorientáltság érzetét adja:

  newPerson = {}                         -- Új tábla 'newPerson' néven.

  setmetatable(newPerson, {
  __call = function(table,name,age)      -- A newPerson táblát functable-lé teszi.
    local person = {Name = name, Age = age} -- Lokális változó a később létrehozandó person attributumaival
    return person                        -- A person tábla visszaadása, a person tábla változóinak beállítása
  end
})

Bill = newPerson("Bill Raizer", 21)    -- Új Person-t hoz létre
print(Bill.Name, Bill.Age)             -- A name és az age attributumok kiíratása.

Struktúrák

Bár a Luában nincs adatszerkezet rekordok létrehozására, mint például C-ben a struct, a táblák erre a célra is használhatók. Ezt a használatot a nyelv szintaktikusan támogatja:

pont = { x = 10, y = 20 }   -- Új tábla
print(pont["x"])            -- Az "x" koordináta kiíratása, itt 10
print(pont.x)               -- Ugyanaz, mint az előző sorban, csak másként.

Névterek

A táblák összetartozó függvényeket is tárolhatnak, ezzel átvehetik a névterek szerepét, objektumorientáltság érzetét adva:

Point = {}                       -- Új névtér létrehozása
Point.new = function (x, y)      -- Konstruktor
  return {x = x, y = y}
end
Point.set_x = function (self, x)
  self.x = x
end
Point.get_x = function (self)
  return self.x
end

Tömbök

A Lua táblák tömbökként is használhatók:

array = { "a", "b", "c", "d" }   -- Az indexek automatikusan számozódnak.
print(array[2])                  -- A "b"-t írja ki. A Lua 1-től kezdi a tömbelemek indexelését.
print(#array)                    -- 4, a tábla hossza. A # operátor adja meg a táblák és a stringek hosszát.
array[0] = "z"                   -- A 0 index használata.
print(#array)                    -- Most is 4, a nulladik index nem számítódik bele a hosszba.

Objektumok tömbjeként:

function newPoint(x, y)          -- A "Point" objektum konstruktora
  return { x = x, y = y }   -- Új objektum létrehozása és visszaadása
end
array = { newPoint(10, 20), newPoint(30, 40), newPoint(50, 60) } -- Pontok tömbje
print(array[2].y)                -- 40-et ír ki

A Lua táblák tömbrésszel és assziociatív tömbrésszel vannak implementálva. Korábban az egészet asszociatív tömbbel valósították meg, de ez az ábrázolás gyorsabb.

Felhasználói modulok

A Lua lehetővé teszi új modulok létrehozását. A modulok kezelésére rendelkezésre áll a Luarocks modulkezelő.

Néhány modul a leggyakoribbak közül:

Modul	Leírás
LuaFileSystem	Hozzáférés a könyvtárszerkezethez és a fájlok jogaihoz
LuaDoc	Dokumentációs eszköz a Lua-kódhoz.
LuaSocket	Lua interfész a hálózati protokollokhoz: HTTP, FTP, SMTP, MIME, URL és LTN12.
LuaSQL	Lua interfész a következőkhöz: PostgreSQL, ODBC, MySQL, SQLite, Oracle és az OLE DB.
stdlib	Gyakori feladatok programkönyvtára a listákhoz, táblákhoz, a funkcionális és az objektumorientált programozáshoz, meg a reguláris kifejezésekhez.
MD5	Egyszerű kriptográfia
Copas	Párhuzamosság támogatása, a korutinok képességeinek bővítése
LuaZip	A .zip fájlok kezeléséhez.
LuaInterface	Kapcsolatot teremt a Lua és a Microsoft .NET Common Language Runtime (CLR) között.
LuaBitOps	C nyelvű kiterjesztés a számokon végzett bitenkénti műveletekhez.
LuaXML	Az XML és a Lua társítása.
Lanes	Több Lua környezet párhuzamos futtatása
Penlight	Táblák, tömbök, stringek, fájlok, könyvtárak, adatok és funkcionális eszközök kezelelésének egyszerűsítése.
Oil	Egyszerű és hatékony Object Request Broker (CORBA).

Hello, World!

A klasszikus Hello World! program Lua nyelven:

print("Hello World!")

A program futtatása

A virtuális gép nem közvetlenül a Lua szkriptet hajtja végre, hanem futás közben bájtkódra fordítja, és ez fut. A szkriptek futtatás nélkül is fordíthatók. Maga a fordítás átlátható.

A Lua virtuális gép regiszteres, ezért a legtöbb virtuális gépnél jobban hasonlít a hardver felépítéséhez. Ez csökkenti az értékek átmásolásának és a függvényenkénti utasítások számát. A Lua 5 az egyik legrégibb regiszteres virtuális gép. Az Android Dalvikja és a több nyelvre, köztük Perlre tervezett Parrot is ilyen.

Így fordítja a luac 5.1 virtuális gép a faktoriális függvényt:

function <factorial.lua:1,6> (10 instructions, 40 bytes at 003D5818)
1 param, 3 slots, 0 upvalues, 1 local, 3 constants, 0 functions
        1       [2]     EQ              0 0 -1  ; – 0
        2       [2]     JMP             2       ; to 5
        3       [3]     LOADK           1 -2    ; 1
        4       [3]     RETURN          1 2
        5       [5]     GETGLOBAL       1 -3    ; factorial
        6       [5]     SUB             2 0 -2  ; – 1
        7       [5]     CALL            1 2 2
        8       [5]     MUL             1 0 1
        9       [5]     RETURN          1 2
        10      [6]     RETURN          0 1

C API

A Luát alkalmazásokba ágyazott nyelvnek fejlesztették, ezért könnyen használható, robusztus C API-val látták el. Az API két részből áll: ezek a Lua core és a Lua auxiliary library. Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonlóan minimalisztikus; a funkcionalitás bővítéséért az auxiliary library felelős, ami preprocesszor makrókkal egyszerűsíti a táblakezelést.

Verem

A Lua C API verem alapú. A veremműveleteket Lua függvények valósítják meg, továbbá léteznek táblakezelő függvények is, amik a veremből is hívhatók. Ez a verem indexelhető is. A Python tömbökhöz hasonlóan negatív indexek is használhatók; ezek a verem tetejétől (-1 a legfelső elem), a pozitív indexek a verem aljától számítódnak.

A C és a Lua közötti kommunikációt szintén a verem valósítja meg. A Lua függvénynek átadott argumentumok a verembe kerülnek, és az aktuális függvény lua_call utasítással hívható. Ha C függvényt hívunk Luából, akkor az a verem tetejéről veszi a paramétereket.

Példa

Lua függvény hívása C-ből:

#include <stdio.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

int main()
{
    lua_State *L = luaL_newstate();
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) exit(1);
    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1);
    printf("Result: %d\n", lua_tointeger(L, -1));
    return 0;
}

Fordítás és futtatás:

$ gcc -o hello -llua hello.c
$ ./hello
Result: 8

Speciális táblák

A C API speciális táblákat is elérhetővé tesz, amik pszeudoindexekkel hivatkozhatók a Lua veremből. A LUA_GLOBALSINDEX tárolja a globális változókat, _G a fő névtér. A LUA_REGISTRYINDEX-ben tárolják a C függvények a Lua értékeket későbbi felhasználásra.

Kiterjesztés és kötés

Kiterjesztő modulok is készíthetők a Lua API használatával. Ezek a könyvtárak kiterjesztik az értelmező funkcionalitását. A Lua szempontjából ezek névterek, vagyis táblák a maguk változóival és függvényeivel. Ezek a modulok a require kulcsszóval tölthetők be.

A LuaRocks csomagkezelő rendszerből egyre több modul érhető el, a CPANhoz, a RubyGemshez és a Python Eggshez hasonlóan. További források a LuaForge és a lua-users.org wiki Lua Addonsa.

Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, a fájltömörítéshez és még sok máshoz. A legtöbb népszerű nyelvhez vannak Lua kötések, például más szkript nyelvekhez. A C++ megközelítés sablon alapú, és automatikus generátorokat használ.

Alkalmazásai

Manapság a videójátékok nagy része rendelkezik Lua scriptelési lehetőséggel, ezen kívüli alkalmazások:

• A videójátékok fejlesztésében a játékfejlesztők elterjesztették a Luát, mivel gyors, könnyen beágyazható és könnyen tanulható. 2012 januárjában a Game Developer Magazine a Luát hirdette győztesnek a Programming Tools kategóriában, és a Front Line Award 2011-et adományozta neki. Egy példa a népszerű Minecraft videójáték; a hozzá készült Computercraft mod számítógépei is Lua nyelvet használnak.
• A 3DMLW plugin Luát használ háromdimenziós megjelenítésre és eseménykezelésre.
• Az Adobe Photoshop Lightroom felhasználói interfésznek.
• Az Apache HTTP Server a 2.3 verziótól kezdve képes Lua használatára bárhol a lekérési folyamatban.
• Az Artweaver képszerkesztőben szkriptelésre.
• Az Awesome ablakkezelő részben Luában íródott. Konfigurációs fájlja is Lua szkript.
• A The Canon Hack Development Kit (CHDK) nyílt forrású Canon kamerakezelőben a Lua a kettő közül az egyik szkript nyelv.
• A Celestia csillagászat témájú tanítóprogram szkriptnyelve.
• A Cisco ezen a nyelven implementálja a Dynamic Access Policiest az Adaptive Security Appliance-ban.
• A Creative Technology Zen X-Fi2 hordozható médialejátszó beállításai Luában is szerkeszthetők.
• A Damn Small Linux Luát használ mind az ablakozó rendszer, mind a parancssor kényelmi funkcióihoz.
• A Dolphin Computer Accessben a SuperNova képernyőolvasó is Lua szkript.
• A Fusion szerkesztő Luát használ szkriptelésre és plugin prototípushoz.
• A NES emulator FCE Ultra forkja, a FCEUX lehetővé teszi a játékok szerkesztését Lua szkriptekkel.
• A Flame, egy hírhedt számítógépes kémkedésre használt program.
• A Foldit, egy fehérjehajtogató játék, lehetővé teszi a Luában írt felhasználói szkriptek alkalmazását.
• A FreePOPs levelezőrendszer webes felülete.
• A Brazilian Digital Television System Ginga middleware-je Luát használ deklaratív környezetének szkript nyelveként.
• A GrafX2 pixel-art szerkesztő képes Lua szkripteket futtatni képgeneráláshoz és képfeldolgozáshoz.
• A Garry’s Mod videójátékban lehet a Lua segítségével úgynevezett "szkriptelt fegyvereket" készíteni, de objektumok is létrehozhatók.
• Az Ipe képszerkesztő szkript és funkcionális kiterjesztései.
• A Lego Mindstorms NXT és az NXT 2.0 is bírja a Luát.
• A lighttpd webszerver Luát használ a hook szkriptekhez a Cache Meta Language modern helyetteseként.
• A Logitech G15 2.01 verziójának profilkezelője.
• A LuaTeX, a pdfTeX tervezett utóda ismeri a Luát.
• A MediaWiki új sablonnyelve.
• A MikroTik RouterOS bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.
• A Multimedia Fusion Developer 2 Lua kiegészítője lehetővé teszi, hogy a játékok Lua szkripteket futtassanak.
• A MySQL Workbench elfogad Lua nyelvű kiterjesztéseket.
• Az Nginx beágyazott Lua modulja API-t nyújt az Nginx eszközeihez, például a socketkezeléshez.
• Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.
• A Wavecom GSM Open AT OS firmware-je elfogad Lua nyelvű felhasználói alkalmazásokat.
• A Project Dogwaffle Professional Lua nyelvű szűrők létrehozását segíti. Ezt a DogLua szűrő segíti, és a szűrők megoszthatók a Project Dogwaffle, GIMP, Pixarra Twistedbrush és az ArtWeaver között.
• A Prosody egy keresztplatformos Jabber/XMPP szerver Luában íródott.
• A Reason Digital Audio Workstationben Luával írhatók le a távoli objektumok.
• A Redis nyílt forrású adatbázisban a szerveren Lua szkriptek futtathatók, ezzel bővítve annak funkcionalitását.
• A Rockbox nyílt forrású hanglejátszó támogatja a Lua nyelvű pluginokat.
• A SciTE új verziója bővíthető Lua szkriptekkel.
• A Snort a 3.0-tól kezdve tartalmaz Lua értelmezőt.
• A Logitech Squeezebox zenelejátszója támogat Lua nyelvű pluginokat.
• A Tarantool/Box NoSQL tárolt eljárásainak nyelve.
• A TI-Nspire számológépek Lua alkalmazásokat tartalmaz specifikus API-val.
• A Vim a 7.3-as verziójától kezdve támogatja a Lua szkriptelést.
• A VLC a Luával segíti a szkriptelést.
• A WeeChat IRC kliens elfogad Lua szkripteket.
• A WinGate proxyszerver eseménykezelője és házirendje Luával éri el a belső WinGate objektumokat.
• A Wireshark hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.

Irodalom

• Lua 5.1 Reference Manual. Lua.org (2006). ISBN 85-903798-3-3 
• Programming in Lua, 2nd, Lua.org (2006). ISBN 85-903798-2-5  (1st ed. is available online)
• Lua Programming Gems. Lua.org (2008). ISBN 978-85-903798-4-3 
• Game Programming with Python, Lua, and Ruby. Course Technology PTR (2003). ISBN 1-59200-077-0 
• Game Development with Lua. Charles River Media (2005). ISBN 1-58450-404-8 
• Beginning Lua Programming [archivált változat]. Wrox Press (2007). ISBN 0-470-06917-1. Hozzáférés ideje: 2012. június 3. [archiválás ideje: 2013. október 22.] 
• Quigley, Joseph (2007. június 1.). „A Look at Lua”. Linux Journal. 
• Streicher, Martin: Embeddable scripting with Lua. developerWorks. IBM, 2006. április 28.
• Hamilton, Naomi. „The A-Z of Programming Languages: Lua”, Computerworld, IDG, 2008. szeptember 11.. [2012. június 12-i dátummal az eredetiből archiválva] (Hozzáférés: 2012. június 3.)  – Interview with Roberto Ierusalimschy
• (2011. május 12.) „Passing a Language through the Eye of a Needle”. ACM Queue, Kiadó: ACM.  – How the embeddability of Lua impacted its design
• http://nyelvek.inf.elte.hu/leirasok/Lua/
• Roberto Ierusalimschy: Programmieren mit Lua, September 2006, ISBN 3-937514-22-8
• Roberto Ierusalimschy: Lua 5.1 Reference Manual, August 2006, ISBN 85-903798-3-3
• Kurt Jung, Aaron Brown: Beginning Lua Programming, 2007, ISBN 0-470-06917-1
• Paul Schuytema, Mark Manyen: Game Development with Lua, 2005, ISBN 1-58450-404-8

További információk

• Lua.org