|  |  |
| --- | --- |
|  |  *See artikkel on programmeerimiskeelest Lua; teiste tähenduste kohta vaata lehte Lua (täpsustus)* |

---

**Lua** ( [/ˈluːə/] [loo-ə], portugali keeles lua [ˈlu.(w)ɐ] tähendab Kuud) on mitmeparadigmaline programmeerimiskeel, mis on eeskätt loodud välja kutsumiseks teiste programmeerimiskeelte ja -keskkondade seest. Lua keel on alates loomisest platvormiülene ja on ANSI standardile vastavas C-programmeerimiskeeles ning omab suhteliselt lihtsat C-rakendusliidest.

Lua loodi aastal 1993 ning oli mõeldud tarkvararakenduste üha kasvavate vajaduste täitmiseks. See tagas põhilised võimalused enamikule protseduurilistele programmeerimiskeeltele, kuid piiratumate ning valdkonnapõhiste programmeerimiskeelte omadusi ei ole kaasatud. Lua sisaldab keelt laiendavaid mehhanisme, lubades arendajal keele omadusi implementeerida. Kuigi Lua oli kavandatud olema üldine integreeritav keelelaiendus, siis Lua disainerid suunasid tähelepanu ka selle kiirusele, porditavusele, laiendatavusele ja kasutusmugavusele arenduses.

Ajalugu
-------

Lua programmeerimiskeele lõid 1993. aastal Roberto Ierusalimschy, Luiz Henrique de Figueiredo ja Waldemar Celes ning Computer Graphics Technology Group (Techgraf) liikmed Rio de Janeiro Piiskoplikus Katoliku Ülikoolis (Pontifical Catholic University of Rio de Janeiro) Brasiilias.

Aastatel 1977–1992 kehtisid Brasiilias arvutitarkvarale ja -riistvarale tugevad kaubandustõkked. Nende piirangute tõttu ei olnud Tecgrafi klientidel võimalik (ei poliitilistel ega rahalistel põhjustel) osta kohandatavat tarkvara välismaalt. Nende asjaolude tõttu implementeeris Tecgraf põhilised vahendid iseseisvalt.

Lua ajalooline "isa ja ema" olid andmete kirjeldus/konfiguratsiooni keel *SOL* (Simple Object Language) ja *DEL* (Data-Entry Language). Neid on iseseisvalt arendanud Tecgraf aastatel 1992–1993, lisades paindlikkust kahte projekti (mõlemad olid interaktiivsed graafilised programmid ettevõtte Petrobras rakenduste jaoks). Neis oli puudus igasugustest voo reguleerimise struktuuridest SOL-is ja DEL-is ja Petrobras tundis kasvavat vajadust lisada rakendustesse täiendavaid programmeeritavaid võimalusi.

Lua 1.0 oli disainitud nii, et selle objekti konstruktorid, olles nii vähesel määral erinevad praegusest kergusest ja paindlikkuse laadist, inkorporeeritud SOLi andmekirjelduse süntaksiga (siit tuleneb ka nimi "Lua". *Sol tähendab* portugali keeles 'päikest', seega *sobis arendatava keele nimeks sõna "Lua" -* 'Kuu'). Lua kontrollstruktuuride süntaksist oli suurem osa laenatud Modulast (if, while, repeat/until), aga samuti oli võetud mõjutusi CLU-st (korduvad ülesanded ja korduv tagastamine funktsioonide väljakutsumisel kui lihtsam alternatiiv viitparameetritele või kaudsetele viitadele), C++ keelest (" lokaalse muutuja deklareerimine ainult seal, kus me vajame seda), SNOBOL-ist ja AWK-st (assotsiatiivne massiiv). Artiklis, mis avaldati Dr. Dobb's Journalis, väitsid *Lua keele loojad, et LISP ja Scheme kui nende ainsad üldlevinud andmete struktureerimise mehhanismid (list) olid tugevalt mõjutatud nende otsusest arendada tabelit kui tähtsaimat Lua andmestruktuuri.*

Lua semantika on enim mõjutatud Scheme poolt, eriti seoses anonüümsete funktsioonide kasutuselevõtuga ja täieliku sõnastiku kindlaksmääramisega.

Lua versioonid enne versiooni 5.0 olid välja lastud BSD-litsentsiga sarnase litsentsi alusel. Alates versioonist 5.0 on Lua olnud MIT litsentsi all. Mõlemad on leebed vaba tarkvara litsentsid ja peaaegu identsed.

Funktsionaalsus
---------------

Luad on tavaliselt kirjeldatud kui "mitmeparadigmalist" keelt, toetades väikest hulka üldisi funktsioone, millega saab laiendada sobivust eri tüüpi probleemidele, selle asemel et toetada palju keerulisemat ja ranget spetsifikatsiooni, sobitamaks ühte paradigmat. Näiteks Lua ei sisalda ilmset päriluse tuge, aga lubab seda implementeerida koos metatabelitega. Lisaks lubab Lua programmeerijal implementeerida nimeruume, klasse ja teisi seotud funktsioone, kasutades selle üksiku tabeli implementeerimist. Esimese klassi funktsioonid, mis võimaldavad töötamist paljude funktsionaalse programmeerimise tehnikatega ja täielik staatiline skoopimine võimaldavad tihedat informatsiooni peitmist, täites väiksema privileegi printsiipi.

Üldiselt püüab Lua tagada lihtsust ning paindlikke metafunktsioone, mis võivad olla vajadusel sisseehitatud, selle asemel et varustada funktsiooni seadistamise spetsiifikaga üht programmeerimisparadigmat. Tulemuseks olev baaskeel on kerge – interpretaatori maht on kompileeritult ainult umbes 180 kB ning on lihtsasti kohandatav laiale rakenduste valikule.

Lua keel võimaldab dünaamilist tüüpimist ja on mõeldud kasutamiseks kui keelelaiendus või skriptimiskeel ning on piisavalt kompaktne, et sobib erinevate platvormidega. See toetab ainult väikest osa elementaarseid andmestruktuure nagu tõeväärtuse väärtused, numbrid (kahekohalise täpsusega ujukomaarvud tavaliselt) ja sõned. Enamlevinud andmestruktuure nagu massiive, hulki, liste ja kirjeid saab taasesitada Lua ainsat omaenda andmestruktuuri – tabelit – kasutades, Tabel näol on tegu põhimõtteliselt heterogeenne assotsiatiivse massiiviga.

Lua implementeerib väikest hulka kõrgetasemelisi funktsioone nagu esimese klassi funktsioonid, "prügikorjajad" (garbage collection), sulundid, sabakutse (tail call), tüübiteisendus (automaatne muutmine sõne ja numbri vahel), kaasprogrammid (ühise multitegumitöötlusega) ja dünaamiline mooduli laadimine.

Sisaldades ainult minimaalset hulka andmetüüpe, Lua püüdis saavutada tasakaalu jõudluse ja mahu vahel.

### Koodi näidis

Klassikalist programmi "Tere maailm" saab kirjutada järgmise koodiga:

```
print("Tere maailm!")

```

Seda sama programmi saab kirjutada ka sedamoodi:

```
io.write('Tere maailm!\n')

```

Seda programmi saab luua ka nii nagu Lua veebilehel.

```
io.write("Hello world, from ", \_VERSION, "!\n")

```

Kommentaarides kasutatakse järgmist süntaksit, mis sarnaneb programmeerimiskeelte Ada, Eiffeli, Haskelli, SQL-i ja VHDL-i omadega:

```
--Kommentaar keeles Lua algab kahe sidekriipsuga ja on kuni rea lõpuni.

--[[ Mitmerealised sõned ja kommentaarid
 on ümbritsetud kahekordsete kandiliste sulgudega. ]]

--[=[ Seda tüüpi kommentaaridesse on teine --[[kommentaar]] pesastatud. ]=]

```

Faktoriaali funktsioon on implementeeritud, nii nagu järgmises näites näidatud.

```
function factoriaal(n)
  local x = 1
  for i = 2, n do
    x = x \* i
  end
  return x
end

```

### Tsüklid

Lua keeles on nelja tüüpi tsükleid: while-tsükkel, repeat tsükkel (sarnane do-while tsükliga), numbriline for tsükkel ja üldine for tsükkel.

```
--tingimus = true

while tingimus do
  --käsud
end

repeat
  --käsud
until tingimus

for i = esimene,viimane,samm do     --samm võib olla negatiivne, lubades for-tsüklil loendada alla või üles. Samm näitab, kui palju on järgmine väärtus eelmisest suurem. Näiteks kui samm on 1, i esimene väärtus on 1, siis järgmine on 1+1=2
  --käsud
  --näiteks väljastame i väärtuse: print(i)
end

```

Üldine for-tsükkel:

```
for key, value in pairs(\_G) do
  print(key, value)
end

```

Üldine for-tsükkel itereerib üle tabeli \_G, kasutades standardset iteraatori funktsiooni pairs, kuni see tagastab tühiväärtuse null.

### Funktsioonid

Lua funktsioonikäsitluses on esimese klassi funktsioonide väärtused, mis on näidatud järgnevas näites, kus print-funktsiooni käitumine on modifitseeritud:

```
do
  local oldprint = print
  -- varu praeguse print funktsioon kui oldprint
  function print(s)
    --[[ Defineeri uuesti print function, tavalist print funktsiooni saab endiselt kasutada
 läbi oldprint. Uuel on ainult üks argument]]
    oldprint(s == "foo" and "bar" or s)
  end
end

```

Iga tulevane print-käsu väljakutse hakkab nüüd olema suunatud läbi uue funktsiooni ja tulenevalt Lua staatilisest skoopimisest on vana print funktsioon kättesaadav ainult uue modifitseeritud print jaoks.

Lua samuti toetab sulundeid, mida on demonstreeritud järgmises koodis:

```
function addto(x)
  --tagastab uue funktsiooni, mis lisab x-i argumendiks
  return function(y)
    --[=[ kui me viitame muutujale x, mis on väljaspool seda skoopi ja mille
 eluperiood on lühem kui sellel anonüümsel funktsioonil,
 Lua loob sulundi.]=]
    return x + y
  end
end
fourplus = addto(4)
print(fourplus(3))  -- väljastab 7

--Seda saab saavutada ka funktsiooni järgmisel viisil välja kutsudes:
print(addto(4)(3))
--[[ See on nii, sest me oleme kutsumas tagastatud funktsiooni `addto(4)' koos argumendiga `3' otse.
 See aitab ka vähendada andmehinda ja tõsta kasutust, kui oleme kutsunud iteratiivselt.
]]

```

Muutuja x uus sulund on loodud igal korral, kui addto kutsutakse välja, nii et iga uus anonüümne funktsioon naaseb alati juurdepääsuga oma x-parameetrile. Sulundit haldab Lua "prügivedaja" just nagu iga teist objekti. 

### Tabelid

Tabelid on kõige tähtsamad andmestruktuurid (ja disainilt ainus sisseehitatud liitandmetüüp) Lua keeles ning on alus kõigile kasutaja loodud tüüpidele. Need sarnanevad kontseptuaalselt assotsiatiivse massiiviga PHP-s, sõnastikuga Pythonis ja räsidele Rubys või Perlis.

Tabel on kogum võtmete ja andmete paaridest, kus andmetele viitavad võtmed. Teiste sõnadega on see räsitud heterogeenne assotsiatiivne massiiv. Võti (indeks) võib omada iga väärtust, aga mitte NaN. Numbrilist võtit 1 peetakse erinevaks sõnelisest võtmest "1". i

Tabeleid luuakse kasutades `{}` konstruktorit:

```
a\_table = {} -- Loome uue tabeli nimega a\_table

```

Tabelid saavad viidata ka üksteisele:

```
a\_table = {x = 10}  -- Loome uue tabeli koos ühe kirje kujutusega, kus "x" on seotud 10-ga.
print(a\_table["x"]) -- Väljastame sõnelise võtmega seotud väärtuse, mis on praegusel juhul 10.
b\_table = a\_table
b\_table["x"] = 20   -- Väärtuse muutmine tabelis. Uus väärtus on 20.
print(b\_table["x"]) -- Väljastame 20.
print(a\_table["x"]) -- Samuti väljastab 20, sest a\_table ja b\_table mõlemad viitavad samale tabelile.

```

#### Kirje

Tabelit on tihti kasutatud nagu struktuuri (või kirjet),kus on kasutatud sõnesid kui võtmeid, sest selline kasutus on väga tavaline. Lua funktsioonid on spetsiaalse süntaksiga, tegelemiseks selliste väljadega. Seda näitab järgmine koodinäide:

```
point = { x = 10, y = 20 }   -- Loome uue tabeli.
print(point["x"])            -- Väljastame 10.
print(point.x)               -- See rida on enamvähem sama, mis eelmine, kuid lihtsam lugeda.
                             -- .

```

Tsiteerides Lua 5.1 manuaali:

"Süntaks var.Name on süntaktiline suhkur süntaksist var['Name'];"

#### Nimeruum

Seotud funktsioonide salvestamiseks kasutatavaid tabeleid saab näidatu kui nimeruumi.

```
Point = {}

Point.new = function(x, y)
  return {x = x, y = y}  -- return {["x"] = x, ["y"] = y}
end

Point.set\_x = function(point, x)
  point.x = x  -- point["x"] = x;
end

```

#### Massiiv

Numbrilise võtme kasutamise korral sarnaneb tabel massiivi andmetüübiga. Lua massiivid on 1-baasil. Erinevalt paljudest programmeerimiskeeltest, kus esimene indeks on 0, on siin esimene indeks 1 (kuigi on lubatud kasutada ka indeksit 0).

Lihtne sõnemassiiv:

```
array = { "a", "b", "c", "d" }   -- Indeksid määratakse automaatselt
print(array[2])                  -- Väljastab "b". Automaatne indekseerimine Luas hakkab 1-st.
print(#array)                    -- Väljastab 4. # See on pikkuse määramise operaator tabelitel ja sõnedel.
array[0] = "z"                   -- 0 on legaalne indeks.
print(#array)                    -- Jätkuvalt väljastab 4, Lua massiivid on 1-põhised.

```

Tabeli t pikkus on defineeritud olema iga täisarvuline indeks n nii, et t[n] ei ole tühi ja t[n+1] on tühi; veel enam, kui t[1] on tühi, siis n on 0. Regulaarse massiivi üks mitte-null väärtustest antakse muutujale n, Selle pikkus on sel juhul täpselt n ehk viimase indeksi väärtus. Kui massiivil on "auke" (tühjad väärtused on mittetühjade väärtuste vahel), siis #t saab olla iga indeks, mis on vahetult eelnev tühjale väärtusele (see tähendab, et ta võib iga sellist tühja väärtust pidada massiivi lõpuks).

Kahedimensiooniline tabel:

```
ExampleTable =
{
     {1,2,3,4},
     {5,6,7,8}
}
print(ExampleTable[1][3]) -- Väljastab "3"
print(ExampleTable[2][4]) -- Väljastab "8"

```

Objektide massiiv:

```
function Point(x, y)        -- "Point" objekti konstruktor
  return { x = x, y = y }   -- Loome ja tagastame uue objekti (tabel)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- Loome punktide massiivi
                        -- massiiv = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };
print(array[2].y)                                         -- Väljastab 40

```

Kasutades kujutust normaalse massiivi järgitegemiseks on aeglasem kui kasutada seda tegeliku massiivina. Siiski on Lua tabelid optimeeritud kasutama neid nagu massiive.

### Metatabelid

Laiendatud semantikas on Lua võtmefunktsioon ja metatabeli kontseptsioon lubab Lua tabeleid kohandada võimsaimasse olekusse. Järgnev näide demonstreerib "lõpmatut" tabelit. Iga {\displaystyle n}, fibs[n] annab {\displaystyle n}-inda Fibonacci jada liikme kasutades dünaamilist programmeerimist ja tabeli pidamist, mis on optimeerimise tehnika.

```
fibs = { 1, 1 }                                -- esialgne väärtus fibs[1]'le ja fibs[2]'le.
setmetatable(fibs, {
  \_\_index = function(values, n)                --[[ \_\_index on funktsioon, mis on eeldefineeritud Lua poolt,
 See kutsutakse välja, kui võtit "n" ei eksisteeri. ]]
    values[n] = values[n - 1] + values[n - 2]  -- Calculate and memoize fibs[n].
    return values[n]
  end
})

```

### Objektorienteeritud programmeerimine

Lua keeles ei ole sisseehitatud klasse, kuid sellegipoolest on võimalik objektorienteeritult programmeerida. Selleks tuleb kasutada kaht Lua keele funktsiooni: esimese klassi funktsioone ja tabeleid. Objekti saab luua funktsioonide ja soetud andmete tabelisse paigutamisega. Metatabeli mehhanismi abil saab implementeerida pärilust.

Luas ei ole sellist mõistet nagu "klass" koos nende tehnikatega: pigem on kasutusel prototüübid nagu programmeerimiskeeltes Self ja JavaScript. Uusi objekte luuakse nii tehase meetodiga (see konstrueerib uued objektid nullist) kui ka kloonides eksisteerivat objekti.

Lua toetab mõnda süntaktilist suhkrut, et aidata kaasa objekti orientatsioonile. Deklareerides liikmefunktsiooni prototüübi tabelisse sisse, saab kasutada koodi function table:func(args), millega on samaväärne kood function table.func(self, args). Klassimeetodeid saab samuti kutsuda kooloni abil. Kood object:func(args) on samaväärne koodiga object.func(object, args).

Loome tavalise vektori objekti:

```
local Vector = {}
Vector.\_\_index = Vector

function Vector:new(x, y, z)    -- konstruktor
  return setmetatable({x = x, y = y, z = z}, Vector)
end

function Vector:magnitude()     -- teine meetod
  -- viitab varjatud objektile kasutades iseennast
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local vec = Vector:new(0, 1, 0) -- Loome vektori
print(vec:magnitude())          -- Kutsume välja (output: 1)
print(vec.x)                    -- Ligipääs mälus olevale väärtusele (output: 0)

```

Sisemus
-------

Lua programmid ei ole otseselt interpreteeritud Lua tekstifailidest, aga on kompileeritud baitkoodi, mis töötab Lua virtuaalmasinas. Kompileerimise protsess on tüüpiliselt nähtamatu kasutajale ja on sooritatud käitamisaja kestel, aga seda saab teha ühenduseta, et kasvatada laadimiskiirust või vähendada rakenduse keskkonna mälu "jalajälge" kompilaatorit välja jättes. Lua baitkood saab samuti olla produtseeritud ja täidetud Luaga kasutades minemaviskamise funktsiooni sõne teegist ja load/loadstring/loadfile funktsioone. Lua versioon 5.3.3 on implementeeritud umbes 24 000 rea C-keele koodiga.

 
Nagu enamik keskprotsessoreid (CPU) ja erinevalt enamikust virtuaalmasinatest, mis on pinupõhised, Lua virtuaalmasin on registripõhine ja järelikult palju enam sarnane päevakajalise riistvara disainiga. Registri arhitektuur väldib nii ülemäärast väärtuste kopeerimist kui ka vähendab kogu instruktsioonide arvu funktsiooni kohta. Lua 5 virtuaalmasin on üks esimesi puhtalt registripõhiseid virtuaalmasinaid omades laia kasutust. Perli Parrot ja Androidi Dalvik on kaks teist teada-tuntud registripõhist virtuaalmasinat.

See näide on baitkoodi list faktoriaali funktsioonist, mis sai defineeritud ülal (nagu näha luac 5.1 kompilaatori poolt):

```
function <factorial.lua:1,7> (9 instructions, 36 bytes at 0x8063c60)
1 param, 6 slots, 0 upvalues, 6 locals, 2 constants, 0 functions
	1	[2]	LOADK 	1 -1	; 1
	2	[3]	LOADK 	2 -2	; 2
	3	[3]	MOVE  	3 0
	4	[3]	LOADK 	4 -1	; 1
	5	[3]	FORPREP 	2 1	; to 7
	6	[4]	MUL  	1 1 5
	7	[3]	FORLOOP 	2 -2	; to 6
	8	[6]	RETURN 	1 2
	9	[7]	RETURN 	0 1
```

C API
-----

Lua on kavandatud olema sisseehitatud teistese rakendustesse ja C API toetab seda eesmärki. API on jagatud kaheks osaks: Lua südamikuks ja Lua abiteegiks.

Lua API disain elimineerib vajaduse manuaalseks viidete haldamiseks C koodis, erinevalt Pythoni API-st. Keeltel nagu see on API minimalistlik. Arenenud funktsionaalsus on toetatud abiteegi poolt, mis koosneb suurel määral eeltöödeldud makrodest, mis abistavad koos liittabeli operatsioonidega.

### Kuhi

Lua C API põhineb kuhjal. Lua tagab funktsioonide tõukamist ja esiletoomist enamikus lihtsates C andmetüüpides (näiteks täisarvud, reaalarvud ja nii edasi) ning kuhjas. Lisaks ka funktsioonid töötlevad tabeleid läbi kuhja. Lua kuhi erineb mõnevõrra traditsioonilisest kuhjast. Kuhi saab olla indekseeritud otse. Negatiivsed indeksid kalduvad kõrvale kuhja ülemisest otsast. Kui −1 on üleval (viimati uuendatud väärtus), kuna positiivsed indeksid annavad märku nihkest alumises otsas (vanad väärtused).

C ja Lua vaheliste andmete kogumise funktsioonid on samuti tehtud kasutades kuhja. Kutsudes Lua funktsiooni, argumendid on surutud kuhja peale ja siis lua\_call on kasutatud kutsumaks tegelikku funktsiooni. Kui C-keeles kirjutatud funktsiooni otseselt kutsuda Lua keeles, siis argumendid on loetud kuhjast.

### Näide

Siin on näide sellest, kuidas kutsuda välja Lua funktsiooni C-keeles.

```
#include <stdio.h>
#include <lua.h> //Lua main library (lua\_\*)
#include <lauxlib.h> //Lua auxiliary library (luaL\_\*)

int main(void)
{
 //loome Lua seisundi
 lua\_State \*L = luaL\_newstate();

 //lae ning täida string
 if (luaL\_dostring(L, "function foo (x,y) return x+y end")) {
 lua\_close(L);
 return -1;
 }

 //lükka globaalne väärtus "foo" (funktsioon on eelnevalt defineeritud)
 //kuhja, jälgitud täisarvude 5 ja 3 poolt.
 lua\_getglobal(L, "foo");
 lua\_pushinteger(L, 5);
 lua\_pushinteger(L, 3);
 lua\_call(L, 2, 1); //kutsu funktsioon koos kahe argumendiga ja tagasta üks väärtus.
 printf("Result:%d\n", lua\_tointeger(L, -1)); //väljastame väärtuse
 lua\_close(L); //sulgeme lua seisundi.
 return 0;
}

```

Näite käitamine annab: 

```
$ cc -o example example.c -llua
$ ./example
Result: 8

```

### Spetsiaalsed tabelid

C API samuti tagab mõned spetsiaalsed tabelid lokaliseeritult mitmesuguste "pseudo-indeksitega" Lua kuhjas. LUA\_GLOBALSINDEX enne Lua 5.2 on üldises tabelis. \_G on peamine nimeruum. Seal on samuti registriga määratud LUA\_REGISTRYINDEX, kus C programmid saavad salvestada Lua väärtusi hilisema vajaduse jaoks.

### Laiendus ja seos

Lua API-t kasutades on võimalik kirjutada laiendmooduleid. Laiendmoodulid on jagatud objektid, mis on harjunud laiendama interpreteerija funktsionaalsust, tagades algupärase hõlpsuse Lua skriptidele. Selline moodul ilmub, kui nimeruumi tabelis hoitakse vastavaid funktsioone ja muutujaid. Lua skriptid võivad laadida laiendusmooduleid kasutades require, just nagu moodulid oleks kirjutatud Lua keeles endas.

Kasvav moodulite kollektsiooni teatakse kui "rocks", mis on saadaval paketihaldussüsteemi LuaRocks kaudu, CPAN vaimus, RubyGems, Python Eggs.

Eelkirjutatud Lua seosed eksisteerivad enamikus populaarsetes programmeerimiskeeltes, sealhulgas skriptimiskeeltes nagu C++. Seal on mitu mallipõhist juurdepääsu ja mõni automaatne seosegeneraator.

Rakendused
----------

### Videomängud

Videomängude arenduses on Lua mängude programmeerijate poolt laialdaselt kasutatud kui skriptimiskeel ehk tänu selle tajutud lihtsuses manustamisel, kiirel täitmisel ja lühikesel õppimiskõveral.

2003. aastal korraldatud GameDev.neti küsitlus näitas, et Lua on kõige populaarsem skriptimiskeel mängude programmeerimisel. Lua kuulutati 12. jaanuaril 2012 Front Line Award 2011 võitjaks ajakirjas Game Developer kategoorias "Programmeerimisvahendid".

### Muid rakendusi

Muud rakendused, mis on loodud Lua keelega:

* 3DMLW plugin, kasutatakse Lua 3D-animatsioonide skriptimiseks ja käsitlemaks erinevaid sündmusi.
* Adobe Photoshop Lightroom, kasutab Lua'd oma kasutaja kasutajaliideses.
* Aerospike Database, kasutab Lua'd kui oma sisemist skriptimiskeelt oma "UDF" (User Defined Function) suutlikkuse jaoks – sarnased protseduurid.
* Apache HTTP Server, saab kasutada Lua keelt igal pool päringuprotsessis (alates versioon 2.3, läbi tuumse mod\_lua mooduli).
* Artweaver, graafika redaktor kasutab Lua'd skriptimisfiltrina.
* Autodesk Stingray, mängumootor, mis kasutab Lua'd videomängude arendamiseks.
* Awesome, aknahaldur, mis on kirjutatud osaliselt Lua keeles, samuti kasutatakse seda konfiguratsioonifailivorminguna.
* bozohttpd, vaikimisi veebiserver koos NetBSD-ga, on integreeritud Lua toega dünaamilise sisu loomiseks.
* The Canon Hack Development Kit (CHDK), avaliku lähtekoodiga püsivara Canoni kaameras, kasutatakse Lua kui ühte kahest skriptimiskeelest.
* Celestia, astronoomia hariduslik programm, kasutab Lua keelt kui oma skriptimiskeelt.
* Cheat Engine, mälu redaktor/silur, lubab Lua skripte manustada oma "cheat table" failidesse. Lisaks sisaldab GUI disainijat.
* Cisco, kasutab Lua'l implementeerida dünaamilise juurdepääsu poliise Adaptive Security Appliance'i piires.
* Conky, Linux süsteemiseire rakendus, mis kasutab Lua arenenud graafika jaoks.
* Cocos2d, kasutab Lua'd mängude ehitamises koos nende Cocos Code IDE-ga.
* Codea, Lua redaktor iOS-i operatsioonisüsteemile.
* Creative Technology Zen X-Fi2 kohandatud rakendused nagu kaasaskantav meediamängija on loodud Lua keeles.
* Damn Small Linux, kasutab Lua keelt toetamaks ekraani-sõbraliku kasutajaliidese käsurea vahendeid ilma ohverdamata palju kettaruumi.
* darktable avatud lähtekoodiga fotograafia töövoo rakendus, mis on skriptitav Lua'ga.
* Dolphin Computer Access, kasutab Lua skriptimist, tegemaks ligipääsmatuid rakendusi ligipääsetavaks nägemiskahjustusega arvutikasutajatele ekraanilugereid – SuperNova.
* Eyeon'i Fusion komponeerija kasutab sisseehitatud Lua'd ja LuaJIT sisemist ja välimiste skriptide jaoks ning samuti laienduste prototüüpimiseks.
* NES emulator FCE Ultra haru, mida kutsutakse FCEUX-iks, lubab laiendusteks ja mängumodifikatsioonideks kasutada Lua skripte.
* Flame, suur ja kõrge keerukusega pahavara osa on kasutatud küberkuritegevuses.
* Foldit – teadusele orienteeritud proteiinide kokkupanemise mäng, mis kasutab Lua'd oma skriptides. Mõned selle rakenduse skriptidest on olnud artikli PNAS eesmärk.
* FreePOPs, meili vahendaja laiendus, mis kasutab Lua'd oma veebi front-end osa jõudluse parandamiseks.
* Freeswitch, avatud lähtekoodiga telefoniplatvorm, mis on disainitud hõlbustama heliloomingu loomist ja sõidu ajal rääkimist võimaldavaid tooteid, milles Lua'd kasutatakse kui skriptimiskeelt kõneprotokollide ja kõnevoogude ja teiste asjade jaoks.
* Geany, koodiredaktor, omab Lua pluginaid, GeanyLua.
* Ginga, Brasiilia digitaaltelevisiooni süsteemi (SBTVD või ISDB-T) vahevara, kasutab Lua'd kui skriptimiskeelt oma deklaratiivses keskkonnas. Ginga-NCL. Ginga-NCL-is Lua on integreeritud kui meediaobjektid (kutsutakse NCLua) NCL-i (Nested Context Language) dokumentides.
* GrafX2, piksel-joonistamise redaktor, saab käitada Lua skripte lihtsa pildi töötlemiseks või üldiseks illustreerimiseks.
* HAProxy, pöördproksi tarkvara, võib olla laiendus koos Luaga alates versioonist 1.6.
* iClone, reaalajas animeerimise 3D-stuudio loomaks animafilme, kasutab Lua'd oma uues füüsikasimulatsiooni juhtsüsteemis.
* Joonistamisredaktor Ipe (peamiselt kasutatud jooniste töötlemiseks LaTeX-i märgistamisega). Kasutab Lua'd oma funktsionaalsuses ja skriptitud laiendustes.
* Lego Mindstorms NXT ja NXT 2.0 saab skriptida Lua'ga kasutades kolmanda osapoole tarkvara.
* lighttpd veebiserver, kasutab Lua'd haakimaks skripte sama hästi kui tänapäevane asendus Cache Meta Language'ks.
* Logitechi profiili haldamise tarkvara versioon 2.01 G15 mänguklaviatuur kasutab Lua keelt kui oma skriptimiskeelt.
* luakit püüab olla kiire ja lihtne WebKiti-põhine brauseri raamistik, Lua poolt laiendatav.
* LuaTeX, määratud pdfTeX-i järglaseks, lubab laiendusi kirjutada Lua keeles.
* LuCI, vaikimisi brauseri kasutajaliides OpenWrt. See on kirjutatud peamiselt keeles Lua.
* MediaWiki kasutab Lua kui uut šabloonkeelt, mis on kasutusel Wikipedias ja teistes vikides.
* Moonbridge Network Server for Lua Applications kombinatsioonis WebMCPiga, veebiarendamise raamistik, lubab keerulisi veebirakendusi kirjutada Lua keeles (kasutatud LiquidFeedbacki poolt).
* MySQL Workbench, kasutab Lua keelt oma laienduste jaoks.
* NetBSD, omab Lua draiverit, mis saab luua ja kontrollida Lua seisundit kerneli sees. See lubab Lual olla kasutatud pakettide filtreerimiseks ja loomaks seadme draivereid.
* Nginx, omab jõuliselt sisse kinnitatud Lua mooduleid, mis tagavad API ligipääsu Nginx abivahenditele nagu soketi käitlemine.
* nmap, internetiturvalisuse kontrollija kasutab Lua keelt kui põhja oma skriptimiskeelele *nse*.
* NodeMCU, kasutab Lua keelt riistvaras. NodeMCU on open source riistvara platvorm, mis saab käitada Luad otse ESP8266 Wi-Fi SoC'd.
* Sierra Wireless AirLink ALEOS GSM / CDMA / LTE juurdepääs lubab kasutaja rakendustel olla kirjutatud Lua keeles.
* OpenResty on dünaamiline veebiplatvorm, mis põhineb NGINX-il ja LuaJIT-l. .
* Perimeta seansipiirangukontroller Metaswitch Networksilt kasutab Lua keelt kui skriptimiskeelt, manipuleerimaks SDP andmetega lennult.
* PowerDNS pakub laiendatud Lua keeles skriptimist teenindamiseks ja DNS-i vastuste muutmiseks, parandamaks katkisi servereid ja DoS-i kaitset.
* Project Dogwaffle Professional pakub Lua skriptimist tegemaks filtreid läbi DogLua filtri. Lua filtreid saab jagada Project Dogwaffle, GIMP, Pixarra Twistedbrush ja ArtWeaveri vahel.
* Prosody on platvormiülene Jabber/XMPP server, mis on kirjutatud keeles Lua.
* QSC Audio Products toetab Lua keeles skriptimist väliste seadmete kontrollimisel ja teistel kõrgema funktsionaalsusega Q-SYS Designeris.
* Quartz Composer, visuaalse programmeerimise tööriist Apple'ilt, saab skriptida Lua keeles läbi tasuta plugina, mis on toodetud Boinx Software poolt.
* REAPER digitaalse audio tööjaam toetab laienduste funktsionaalsuse Lua keeles skriptimist.
* Reason digitaalse audio tööjaam, Lua keelt kasutatakse Remote codec'i kirjeldamiseks.
* Redis, on avatud lähtekoodiga võtmeväärtusega andmebaas, milles Lua'd saab kasutada (alates versioonist 2.6) keeruliste funktsioonide kirjutamiseks, mis käitab serveris iseennast, seega laiendab oma funktsionaalsust.
* RetroShare krüptitud failijagamine, serverivaba e-post, hetketeated, jututuba ja BBS tarkvara, põhineb sõbralt-sõbrale võrgul, omab Lua pluginat automatiseerimiseks ja kontrollimiseks.
* Rockbox, avatud lähtekoodiga digitaalse audio püsivara, toetab pluginaid, mis on kirjutatud Lua keeles.
* RPM, tarkvarapakettide haldamise süsteem, kõigepealt välja töötatud Red Hat Linuxi jaoks.
* Uus versioon SciTE redaktorist saab laiendada kasutades Lua'd.
* SAS integreerib Lua PROC LUA seisundiga
* Snort sissetungi tuvastamise süsteem sisaldab Lua interpretaatorit alates 3.0 beetaväljalaskest.
* Squeezebox muusika mängijad Logitechilt toetavad pluginaid, mis on kirjutatud Lua'ga hiljutistele mudelitele (Kontroller, Raadio ja Puutuja).
* Tarantool kasutab Lua keelt kui salvestamise protseduuri keelt oma NoSQL-i andmebaasi haldamise süsteemiga ning tegutseb kui Lua rakenduste server.
* TeamSpeak omab Lua keeles skriptimise pluginat modifikatsioonide jaoks.
* TI-Nspire kalkulaatorid sisaldavad Lua keeles kirjutatud rakendusi alates sellest ajast, kui TI lisas Lua skriptimise toe koos kalkulaatorispetsiifilise API-ga OS 3+'is.
* Torch on avatud lähtekoodiga süvaõppe teek Lua keeles.
* Transformice – iseseisev mitmikmäng tasuta mängitaval veebiplatvormil brauseri mäng, mis kasutab Lua keelt programmeerimaks minimänge.
* Varnish saab käitada Lua skripte nõutud protsessis, laiendades VCL läbi Lua VMOD (Varnish moodul).
* Vim omab Lua keeles skriptimise tuge alates versioonist 7.3.
* VLC media player kasutab Lua keelt tagamaks skriptimise toe.
* WeeChat IRC klient aktsepteerib skripte, mis on kirjutatud Lua keeles.
* WinGate proksi server lubab sündmuste töötlemise ja Lua skriptide täitmise poliitika ligipääsuga sisemistele WinGate objektidele.
* Wiresharki võrgupaketi analüüsija lubatud protokolli lahutaja on kirjutatud Lua-ga.
* ZeroBrane Studio Lua IDE, mis on kirjutatud Lua keeles ja kasutab Lua'd oma laiendustes.

Fakte Lua keele kohta
---------------------

* Lua on ainus arengumaalt pärit programmeerimiskeel, mis on saavutanud globaalse tähtsuse.

Vaata ka
--------

* Programmeerimiskeel

Viited
------

1. 1 2  Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Filho, Waldemar Celes (juuni 1996). "Lua—An Extensible Extension Language". *Software: Practice and Experience*. **26** (6): 635–652. DOI:10.1002/(SICI)1097-024X(199606)26:6<635::AID-SPE26>3.0.CO;2-P. Vaadatud 24. oktoober 2015.
2. 1 2 3  "About Lua". Lua.org. Vaadatud 11.08.2011.
3. ↑  Yuri Takhteyev (21. aprill 2013). "From Brazil to Wikipedia". *Foreign Affairs*. Vaadatud 25. aprill 2013.
4. 1 2 3  Ierusalimschy, R.; Figueiredo, L. H.; Celes, W. (2007). "The evolution of Lua" (PDF). *Proc. of ACM HOPL III*. Lk-d 2–1–2–26. DOI:10.1145/1238844.1238846. ISBN 978-1-59593-766-7.
5. ↑  "The evolution of an extension language: a history of Lua". 2001. Vaadatud 18.12.2008.
6. ↑  Figueiredo, L. H.; Ierusalimschy, R.; Celes, W. (detsember 1996). "Lua: an Extensible Embedded Language. A few metamechanisms replace a host of features". *Dr. Dobb's Journal*. Kd 21, nr 12. Lk-d 26–33.
7. ↑  "Lua 5.1 Reference Manual". 2014. Vaadatud 27.02.2014.
8. ↑  "Lua 5.1 Reference Manual". 2012. Vaadatud 16.10.2012.
9. ↑  "Lua 5.1 Source Code". 2006. Vaadatud 24.03.2011.
10. ↑  Ierusalimschy, R.; Figueiredo, L. H.; Celes, W. (2005). "The implementation of Lua 5.0". *J. Of Universal Comp. Sci*. **11** (7): 1159–1176.
11. ↑  Kein-Hong Man (2006). "A No-Frills Introduction to Lua 5.1 VM Instructions" (PDF).
12. 1 2  "Lua 5.2 Reference Manual". Lua.org. Vaadatud 23.10.2012.
13. ↑  "LuaRocks". LuaRocks wiki. Vaadatud 24.05.2009.
14. ↑  url= |date=20 August 2013 |title=Why is Lua considered a game language?
15. ↑  url= |date=7 December 2003 |title=Poll Results
16. ↑  url= |date=15 June 2013 |title=Front Line Award Winners Announced
17. ↑  "how to setup a web server". *wiki.netbsd.org*. Vaadatud 28.10.2016.
18. ↑  "bozohttpd – NetBSD Manual Pages". *netbsd.gw.com*. Originaali arhiivikoopia seisuga 28.10.2016. Vaadatud 28.10.2016.
19. ↑  "Using Lua with darktable".
20. ↑  Zetter, Kim (28. mai 2012). "Meet 'Flame,' The Massive Spy Malware Infiltrating Iranian Computers". Wired News.
21. ↑  "Algorithm discovery by protein folding game players".
22. ↑
23. ↑  "pbLua Scriptable Operating Systems with Lua". Originaali arhiivikoopia seisuga 8. detsember 2008. Vaadatud 30. jaanuaril 2017.
24. ↑  "LuaTeX". *luatex.org*. Vaadatud 21. aprill 2015.
25. ↑  "LuCI". Vaadatud 2. juuli 2015.
26. ↑  Technology report, *Wikipedia Signpost* (30 January 2012)
27. ↑  "Public Software Group e. V. – LiquidFeedback Frontend". *public-software-group.org*. Public Software Group. Vaadatud 3. aprill 2015.
28. ↑  "LUA(4) Man Page". netbsd.gw.com. Originaali arhiivikoopia seisuga 4.03.2016. Vaadatud 21.04.2015.
29. ↑  "NPF Scripting with Lua EuroBSDCon 2014" (PDF).
30. ↑  "Scriptable Operating Systems with Lua" (PDF). Dynamic Languages Symposium 2014.
31. ↑  "HttpLuaModule". Wiki.nginx.org. Vaadatud 17.07.2013.
32. ↑  "Nmap Scripting Engine". Vaadatud 10.04.2010.
33. ↑  Huang R. "NodeMCU devkit". *Github*. Vaadatud 3. aprill 2015.
34. ↑  "Know Your SBCs" (PDF). Originaali (PDF) arhiivikoopia seisuga 7.03.2014. Vaadatud 8.03.2014.
35. ↑  "Redis Lua scripting".
36. ↑  "Lua for RPM". Originaali arhiivikoopia seisuga 10. veebruar 2009. Vaadatud 30. jaanuaril 2017.
37. ↑  "Arhiivikoopia". Originaali arhiivikoopia seisuga 19. november 2016. Vaadatud 30. jaanuaril 2017.`{{netiviide}}`: CS1 hooldus: arhiivikoopia kasutusel pealkirjana (link)
38. ↑  "Lua in Snort 3.0". Originaali arhiivikoopia seisuga 27.05.2010. Vaadatud 10.04.2010.
39. ↑  "VMOD Lua for Varnish 3.0". Vaadatud 29.02.2016.
40. ↑  "Vim documentation: if\_lua". Vaadatud 17.08.2011.
41. ↑  "Lua in Wireshark". Vaadatud 10.04.2010.

Lisalugemist
------------

|  |  |
| --- | --- |
| Raamatud
* Gutschmidt, T. (2003). *Game Programming with Python, Lua, and Ruby*. Course Technology PTR. ISBN 1-59200-077-0.
* Schuytema, P.; Manyen, M. (2005). *Game Development with Lua*. Charles River Media. ISBN 1-58450-404-8.
* Jung, K.; Brown, A. (2007). *Beginning Lua Programming*. Wrox Press. ISBN 0-470-06917-1.
* Figueiredo, L. H.; Celes, W.; Ierusalimschy, R. toim-d (2008). *Lua Programming Gems*. Lua.org. ISBN 978-85-903798-4-3.
* Takhteyev, Yuri (2012). *Coding Places: Software Practice in a South American City*. The MIT Press. ISBN 0-262-01807-1. Chapters 6 and 7 are dedicated to Lua, while others look at software in Brazil more broadly.
* Varma, Jayant (2012). *Learn Lua for iOS Game Development*. Apress. ISBN 1-4302-4662-6.
* Ierusalimschy, R. (2013). *Programming in Lua* (3rd ed.). Lua.org. ISBN 85-903798-5-X. (The 1st ed. is available online.)

 | Artiklid
* Matheson, Ash (29. aprill 2003). "An Introduction to Lua". GameDev.net. Vaadatud 3. jaanuar 2013.
* Fieldhouse, Keith (16. veebruar 2006). "Introducing Lua". *ONLamp.com*. O'Reilly Media.
* Streicher, Martin (28. aprill 2006). "Embeddable scripting with Lua". *developerWorks*. IBM.
* Quigley, Joseph (1. juuni 2007). "A Look at Lua". *Linux Journal*.
* Hamilton, Naomi (11. september 2008). "The A-Z of Programming Languages: Lua". *Computerworld*. IDG. Interview with Roberto Ierusalimschy.
* Ierusalimschy, Roberto; de Figueiredo, Luiz Henrique; Celes, Waldemar (12. mai 2011). "Passing a Language through the Eye of a Needle". *ACM Queue*. ACM. How the embeddability of Lua impacted its design.
* Lua papers and theses

 |

Välislingid
-----------

* Lua ametlik veebileht
* Lua Users, kommuun
* eLua, Embedded Lua
* Projects in Lua
* SquiLu, Squirrel modifitseeritud koos Lua teekidega
* Ravi, Lua 5.3 derivatiiv koos limiteeritud valikulise staatilise tüüpimisega ja LLVM-il põhinev JIT kompilaator