Lua

Lua est un langage de script libre, réflexif et impératif.

Lua
Date de première version	1993
Paradigme	Multi-paradigme : procédural, orienté objet à prototype et fonctionnel
Auteur	Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes
Dernière version	5.4.7 (25 juin 2024)
Typage	dynamique, faible
Influencé par	BASIC, C, C++
A influencé	Micro Lua DS
Implémentations	Lua, LuaJIT, LLVM-Lua, LuaCLR, Nua, Lua Alchemy, MicroLua, Mochalua, Jill, luaj, LuaRT
Écrit en	C
Système d'exploitation	Multiplate-forme
Licence	Licence MIT
Site web	lua.org
Extension de fichier	lua, luna, lunaire et anair

Créé en 1993, il est conçu de manière à pouvoir être embarqué au sein d'autres applications afin d'étendre celles-ci. Lua (du portugais : Lua [ˈlu.ɐ], au Brésil : [ˈlu.a], signifiant « Lune ») a été développé par Luiz Henrique de Figueiredo, Roberto Ierusalimschy (en) et Waldemar Celes, membres du groupe de recherche TeCGraf, de l'université pontificale catholique de Rio de Janeiro au Brésil.

L'interpréteur Lua est écrit en langage C ANSI strict, et de ce fait est compilable sur une grande variété de systèmes. Il est également très compact, la version 5.0.2 n'occupant que 95 ko à 185 ko selon le compilateur utilisé et le système cible. Il est souvent utilisé dans des systèmes embarqués tels qu'OpenWrt où cette compacité est très appréciée. Il profite de la compatibilité que possède le langage C avec un grand nombre de langages pour s'intégrer facilement dans la plupart des projets. Il intègre un ramasse-miettes.

Il est particulièrement apprécié pour l'embarqué, le développement réseau et les jeux vidéo.

Le Lua est utilisé dans des jeux vidéo comme : Minetest, Transformice, World of Warcraft, Roblox, Garry's Mod, Onset, ComputerCraft (mod de Minecraft), Multi Theft Auto (mod multijoueur de Grand Theft Auto: San Andreas), FiveM (mod multijoueur de Grand Theft Auto V), Factorio, Project Zomboid, nanos world, ainsi que les moteurs de jeu vidéo tels que le SourceEngine, CryENGINE, LÖVE, ou encore les Fantasy consoles, tel que Pico-8.

Il est également utilisé au niveau réseau comme hook sur Apache, Lighttpd (par défaut), Nginx (via OpenResty), dans les routeurs Cisco, dans l'analyseur de paquets Wireshark, l'antispam Rspamd, l'autocommutateur téléphonique privé Asterisk (optionnel), pour les scripts de MediaWiki.

Généralités

Commentaires

En Lua, les commentaires débutent par -- et finissent à la fin de la ligne, comme en Ada. Si la première ligne commence par #! (shebang) elle est aussi traitée comme un commentaire. Les commentaires multilignes sont également disponibles avec la syntaxe

--[[...]]

Variables

Les variables peuvent contenir nil (la valeur nulle, vide), un booléen, une chaîne de caractères, un nombre (pas de différence entre entier et flottants), une table ou une fonction. Il existe aussi d'autres types comme userdata ou thread moins souvent rencontrés. Le type userdata est très pratique, il correspond à un objet C/C++ défini par l'utilisateur : il est donc possible de créer une structure C ou une classe C++, et d'utiliser des objets de ce type dans un script Lua, après avoir attaché à cet objet une métatable qui se charge d'appeler les fonctions de la classe C++. On peut donc imaginer de créer les classes métier de base d'un programme en C, et coder l'application elle-même en Lua, ce qui accélère considérablement son développement grâce aux outils de haut niveau fournis par le langage.

En interne on peut aussi rencontrer les proto, une sorte de prototype de fonction, le bytecode de cette fonction étant chargé mais ce dernier n'a pas été exécuté. On rencontrera les protos quand un fichier est chargé (compilé) mais pas exécuté ou bien avec les closures.

Par défaut, lorsqu'on déclare une variable, elle est globale à tout l'environnement d'exécution, sauf si elle est précédée du mot-clef local.

Les chaînes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire la marque de chaîne littérale

 [[...]]

(multiligne, pas de caractère spécial).

L'opérateur de concaténation de chaînes se représente par deux points (..).

Les fonctions

Les fonctions sont considérées comme des variables. Cela apporte une grande flexibilité : il est par exemple possible de créer des fonctions locales à une autre fonction, de passer une fonction comme paramètre d'une autre fonction (ou comme valeur de retour) ou de mettre des fonctions dans des tables. Si on affecte nil à une fonction (eg. print = nil), la fonction n'existe plus, n'est plus appelable.

Un avantage des fonctions en Lua est qu'elles peuvent prendre un nombre indéfini de paramètres mais aussi qu'elles peuvent retourner plusieurs valeurs.

Les tables, métatables

Les tables sont une structure Lua qui permet de stocker des variables indexées par une clef (comme en PHP par exemple). Les tables servent à beaucoup de choses en Lua.

Ces dernières sont utilisées de deux manières différentes :

• Une liste (avec un index commençant à 1 et non à 0)
• Une hashtable (faisant office de struct), pouvant prendre en clé et en valeur tout type de variable non nil.

Il est tout à fait possible (mais fortement déconseillé pour des questions de qualité de code) d'avoir une table qui mêle liste et hashtable.

La convention veut qu'on parcoure une liste avec l'itérateur ipairs et la hashtable avec l'itérateur pairs .

Dans une table, il est impossible d'assigner une variable à nil ou l’indexer à la clé nil.

Les métatables sont des tables pour lesquelles on a associé une fonction à chaque opérateur de base (+, -, (), []...). Ce mécanisme est très proche de la surcharge des opérateurs en C++. Par exemple, si la variable x contient une table associée à une métatable appropriée, l'appel de fonction x(arguments) sera valide car Lua cherchera alors dans la métatable comment traiter cet appel.

C'est ainsi qu'on peut implémenter l'héritage entre tables. Si un champ n'est pas trouvé lorsqu'il est demandé, Lua cherchera dans la métatable quelle table est parente et demandera à la table parente de fournir l'élément approprié.

Exemples

Condition

La première méthode est d'écrire en toutes lettres le mot "AND".

if condition1 and condition2 then
 -- instructions exécutées si les conditions 1 et 2 sont vraies
elseif condition1 then
 -- instructions exécutées si la condition 1 est vraie et la condition 2 est fausse
elseif condition2 then
 -- instructions exécutées si la condition 2 est vraie et la condition 1 est fausse
else
 -- instructions exécutées si les deux conditions sont fausses
end

La seconde méthode est d'écrire && à la place de "AND".

if condition1 && condition2 then
    -- code
end

Boucles

repeat
 -- code
until condition

et

while condition do
 -- code
end

ainsi que

for var = start, valend, step do
 -- code
end

ou

for var_1, ..., var_n in explist do
 -- code
end

Déclaration de fonctions

function mafonction(arg1, arg2, ...)
 -- code
 return résultat1, résultat2
end

ou

mafonction = function (arg1, arg2, ...)
 -- code
 return résultat1, résultat2
end

Appels de fonction

res1, res2 = mafonction(var)

Blocs inconditionnels

Les blocs inconditionnels servent par exemple à déclarer des variables locales à ce bloc :

do
 local mavariable = "chaîne" -- déclaration de variable, optionnel
 -- code utilisant mavariable
end

Déclaration de table

Table à indices numériques consécutifs (En Lua, le premier indice d'une table est 1) :

a = { 5, "foo", [[C:\Lua\Lua.exe]], 'bar', 42 }

Table à indices explicites, indiqués entre crochets (les indices qui sont des chaînes ayant la syntaxe d'une variable n'ont pas besoin de guillemets ni de crochets) :

a = { d = 5, [12] = "foo", ['chaîne avec espace'] = true }

Quand on assigne une variable a une autre, si la valeur de celle-ci n'est pas un nombre, une chaîne de caractères ou un booléen alors la référence de celle-ci est copiée. Donc, dans le cas des tables, si une variable a possède une table et qu'on assigne à la variable b la variable a, alors toutes les modifications subies par a seront directement visibles sur b :

local a = {1,"b",3}
local b = a
a.foo = "bar"
print(b.foo) -- bar
-- b et a ont la même référence

Table stockant des variables complexes : autres tables, fonctions, références croisées… Lorsque les valeurs en tant qu'indices ne sont pas des nombres, des chaînes de caractères ou des booléens, alors l'indice sera la référence de la variable en question :

 fonction = function (a, b) return (a + b) / a * b end
t =
{
	b =
	{
		-- Fonction comme clé
		-- La référence de la fonction agira comme clé
		[fonction] = 'Fonction !',
		-- Index numérique
		[5] = 42,
		-- Index chaîne simple (c.-à-d. la syntaxe d'une variable)
		ls =  [[Valeur
Multiligne]] ,
		-- Index chaîne quelconque
		['Expression rationnelle'] = [[(?:\d{1,3}\.){3}\d{1,3}]],
		[ [[C:\Lua\Lua.exe]] ] = true,
	},
	-- Stockage d'une fonction
	f = function () return math.random(100) end,
	ff = fonction,
	-- Table comme clé
	-- La table étant anonyme, aucune référence à cette table est stockée et la valeur stockée est donc inaccessible
	[ { 'a', 'b' } ] = { "aa", "bb" },
}
-- Référence dans la table
t.reference = t.a
t.self = t -- Référence à soi-même
t.self.reference = t.a
print(t[ { t.a, t.b } ]) -- nil car aucune valeur n'a pour clé la référence de cette nouvelle table, l'ancienne table a une référence différente

Les fonctions

Les fonctions mathématiques

La fonction math.pi retourne la valeur de pi.

print(math.pi) --> Affiche dans la console la valeur de pi (3.1415926535898)

La fonction math.min(liste) retourne le plus petit nombre contenu dans une liste

print(math.min(6,4,2,9,1)) --> Affiche 1 dans la console étant donné que 1 est le plus petit nombre de la liste.

La fonction math.max(liste) retourne le plus grand nombre contenu dans une liste

print(math.max(4,6,7,9,1)) --> Affiche 9 dans la console étant donné que ce nombre est le plus grand de sa liste.

La fonction math.floor(x) retourne la partie entière de x.

print(math.floor(1.5)) --> Retourne dans la console le nombre 1
print(math.floor(1.5 + 0.5)) --> Retourne dans la console le nombre 2

La fonction math.abs(x) retourne la valeur absolue de x.

print(math.abs(-100)) --> Retourne dans la console le nombre 100.

La fonction math.pow(x, y) retourne x à la puissance de y. On peut aussi utiliser l'expression x^y

print(math.pow(6,8)) --> Retourne dans la console le nombre 1679616.
-- On peut également utiliser:
print(6^8)

La fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.

local x = 1
local y = 10

print(math.random(x, y)) --> Retourne dans la console un nombre entier aléatoire entre 1 et 10.

La fonction math.sqrt(x) retourne la racine carrée de x.

local x = 6
print(math.sqrt(x)) --> Retourne la racine carrée de x(6) donc 2.4494897427832.

Les fonctions os

La fonction os.time() retourne le nombre de secondes entre le 1^er janvier 1970 à 00:00 et la seconde à laquelle vous appelez la fonction.

print(os.time())

La fonction os.date() retourne le jour, le mois, le numéro du mois, l'heure, les minutes, les secondes et l'année à laquelle vous êtes quand vous appelez cette "fonction"

print(os.date()) --> Retourne Thu Jul 1 14:52:59 2021

La fonction os.clock() retourne le temps écoulé en seconde depuis que Lua a été lancé.

print(os.clock()) --> Retourne dans la console 853312.913685

La fonction type

La fonction type(x) permet de donner le type de x.

local a = "Bonjour"
local b = 5
local c = true
local d

print(type(a)) --> Retourne dans la console "string" car la variable est de type string.
print(type(b)) --> Retourne dans la console "number" car la variable est de type number.
print(type(c)) --> Retourne dans la console "boolean" car la variable est une valeur booléene
print(type(print)) --> Retourne dans la console "function" car print est une fonction.
print(type(d)) --> Retourne nil dans la console "nil" car la variable d ne contient pas de valeur.

Les fonctions table

En lua, il existe 9 fonctions table.

La fonction table.insert(x, y, z) permet d'insérer une valeur y dans un tableau x. On peut aussi lui donner une position à laquelle s'ajouter en rajoutant un argument z. Si aucun argument z n'est donné, la valeur s'affichera en dernière position de la table.

local tableau = {"je", "suis", "un", "utilisateur", "du"}
table.insert(tableau, "wiki") --> Insert dans la variable tableau enla valeur wiki. Le troisième argument pour donner la position n'est pas donné donc la valeur se positionnera en dernière place du tableau.

La fonction table.remove(x, y) permet de retirer du tableau x une valeur en indiquant la position de la valeur y.

local tableau = {"je", "suis", "un", "faux", "utilisateur"}

table.remove(tableau, 4) --> Retire la valeur "faux" du tableau qui était en 4ème position. Malheureusement, on ne peut pas retirer de valeur en indiquant le nom de la valeur, si vous voulez retirer une valeur sans connaître le numéro de position, merci de suivre le paragraphe si dessous avec les boucles pairs().

La fonction table.sort(x) permet de trier et modifier la position des éléments du tableau x.

local tableau = {6, 4, 5, 3, 2, 1}
table.sort(tableau) --> Va venir trier les valeurs du tableau et le modifier en {1, 2, 3, 4, 5, 6}

La fonction table.concat(x, y) permet de regrouper l'ensemble des valeurs d'un tableau et les transforme en chaines de caractères. Le y est un argument facultatif qui peuvent servir de séparateur entre chaque groupement de valeurs.

local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau)

print(concatTableau) --> Retourne dans la console la valeur unrenardcachédans1arbre

On peut aussi ajouter un séparateur lors du trie (y).

local tableau = {"un", "renard", "caché", "dans", 1, "arbre"}
local concatTableau = table.concat(tableau, " | ")

print(concatTableau) --> Retourne dans la console: un | renard | caché | dans | 1 | arbre. L'argument y était " | " donc y a été ajouté entre chaque valeurs transformées.

La fonction table.foreach(x, z) ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles pairs(), voir ci-dessous.

-- Maintenant obsolète.

La fonction table.foreachi(x, y) ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles ipairs().

-- Maintenant obsolète.

La fonction table.getn(x) permet d'afficher la taille d'un tableau x.

local tableau = {"un", "renard", "gentil"}
local longueur = table.getn(tableau)

print(longueur) --> Retourne dans la console la longueur du tableau "tableau" donc 3.

Les fonctions strings

Les fonctions strings permettent de traiter les strings, il en existe 15.

Le string.find(x, y) permet de rechercher des caractères y dans le string x. Si ça retourne nil, rien a été trouvé, en revanche, si quelque chose est trouvé, ça va indiquer à partir de quel emplacement les caractères recherchés ont été trouvés.

local variable = "Bonjour, je m'appelle Lua."
local find = string.find(variable, "our")

if find then -- Si find n'est pas égal à nil est donc il a trouvé quelque chose alors
    print(find) -- Retourne le numéro de commencement des caractères recherchés. En l’occurrence, 5.
end

On peut aussi ajouter un argument z qui permet de commencer à chercher les caractères y à partir d'un certain caractère.

local MA_VARIABLE = "Je suis quelqu'un qui suis une autre personne."
local resultat = string.find(MA_VARIABLE, "is", 17)

if resultat then -- S'il a trouvé dans le string à partir du caractère 17 un mot contenant is alors:
    print(resultat) -- Retourne la position du premier caractère recherché. En l’occurrence, 25. 
end

Le string.byte(x, y, z) permet de retourner le code numérique des caractères (Code ASCII) de la string x.

local MA_VARIABLE = "Je suis une gentille personne"
local RESULTAT_ASCII = string.byte(MA_VARIABLE)

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion de la string en code numérique ASCII

Il est aussi possible d'utiliser l'argument y pour définir un début de conversion ainsi que l'argument z pour définir la fin de conversion (numéro de caractère).

local MA_VARIABLE = "Je suis une gentille personne"
local RESULTAT_ASCII = string.byte(MA_VARIABLE, 1, 10) --> Retourne la conversion du caractère 1 à 10 de la string

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion en ASCII du caractère 1 à 10 de la string.

Le string.char(x) permet de convertir le code numérique x qui est en code ASCII en caractères normaux.

local ASCII_CODE = 74
local RESULTAT = string.char(ASCII_CODE)

print(RESULTAT) --> Retourne dans la console la conversion du code numérique ASCII en caractères numériques (de la variable ASCII_CODE)

Le string.dump(x) permet de convertir la fonction x en représentation binaire pour pouvoir ensuite être appelé par la fonction loadString(y).

function demonstration()
    print("Lancement de la fonction")
end

local dumped = string.dump(demonstration)
assert(loadstring(dumped)) ()

--> Retourne dans la console "Lancement de la fonction."

Le string.format() permet de retourner une chaine de caractères formatée.

print(string.format("Je suis %s, j'adore les %s, et j'aime le nombre %i", "gentil", "bananes", 15))
--> Je suis gentil, j'adore les bananes, et j'aime le nombre 15

--> %s permet de rajouter des strings
--> %i permet de rajouter des nombres

Le string.gmatch(x, y) permet de retourner une sous-chaîne de la chaîne principale x.

for i in string.gmatch("Je suis quelqu'un de gentil", "%a+") do
	print(i)
end

Je
suis
quelqu
un
de
gentil

Le string.gsub(x, y, z) permet de remplacer les mots y d'une string x par un autre mot z.

print(string.gsub("Je suis une personne", "une personne", "un zombie")) -- string.gsub(x(la string), y(mot à remplacer), z(mot qui remplace))
-->
Je suis un zombie

Le string.upper(x) permet de retourner le texte d'une string x en modifiant les minuscules en MAJUSCULES (sauf caractères spéciaux).

local MA_STRING = "Je suis un éléphant Rose"
print(string.upper(MA_STRING))

-->
JE SUIS UN éLéPHANT ROSE

Le string.lower(x) permet de retourner le texte d'une string x en modifiant les MAJUSCULES par des minuscules.

local MA_STRING = "JE SUIS QUELQU'UN"
print(string.lower(MA_STRING))

-->
je suis quelqu'un

Le string.reverse(x) permet de retourner le texte d'une string x en inversant la chaîne de caractères.

local MA_STRING = "je suis un scripter"
print(string.reverse(MA_STRING))

-->
retpircs nu sius ej

Le string.sub(x, y, z) permet de retourner une sous-chaîne de la string x en gardant uniquement le caractère s. S'il y a un argument z, ça va récupérer la sous-chaîne du caractère y au caractère z. Si l'argument y est négatif, ça va commencer à l'envers et prendre la fin de phrase.

local MA_STRING = "je suis un scripter"
print(string.sub(MA_STRING, 1, 7))

-->
je suis

print(string.sub(MA_STRING, -2))

--> 
er

Le string.rep(x, y) permet de multiplier le contenu de la string x avec le nombre de y.

local MA_STRING = "je suis "
print(string.rep(MA_STRING, 5))

-->
je suis je suis je suis je suis je suis

Le string.match(x, y, z) permet de retourner une sous-chaîne de caractères de la string x en prenant ce qui est ouhaitait en y commençant avec le caractère z. Z étant facultatif.

local MA_STRING = "Je suis un scripter"
print(string.match(MA_STRING, "s..."))

-->
suis

local DEUXIEME_STRING = "Je suis un scripter"
print(string.match(MA_STRING, "s...", 12))

-->
scri

La fonction pairs()

La fonction pairs(x) permet de chercher différents éléments d'un tableau. Elle sert actuellement à remplacer la fonction table.foreach qui est erronée depuis la version de lua 5.1. Son utilisation est simple, elle vient prendre le premier argument après le mot for pour faire en sorte que ce soit l'index, donc qu'il porte le numéro de position dans le tableau. Et après, le deuxième argument qu'on appelle souvent v pour value qui indique la valeur. Ce qui donne for i, v in pairs(x) do. Le i est le numéro de position de la valeur dans le tableau et le v est la valeur.

Pour trouver une valeur dans le tableau, on va donc insérer un argument qui sera le nom du tableau x.

local tableau = {"premier", "second", "troisième", "quatrième", "cinquième"}

for i, v in pairs(tableau) do
    print(i, v)
end

--> Résultat dans la console:
1 premier
2 second
3 troisième
4 quatrième
5 cinquième

Pour pouvoir retirer une valeur d'un tableau, on utilise aussi cette fonction, en les traitant jusqu'à récupérer le bon numéro:

local tableau = {"un", "deux", "trois", "quatre", "cinq"}

for index, value in pairs(tableau) do
    if value == "trois" then
        table.remove(tableau, index) -- Retire du tableau la valeur trois.
        break -- Arrêt de la boucle.
    end
end

La fonction pcall()

La fonction pcall() est utilisée pour isoler les erreurs contenus dans une fonction. Cela permet d'empêcher l'arrêt du script et d'afficher s'il y a une erreur ou non avec possibilité de voir de quelle erreur il s'agit.

 pcall(function()
	print(table.find("s")) --> est une erreur.
	print("Salut")
end)

print("Je suis quelqu'un de gentil")

--> Dans la console:
Je suis quelqu'un de gentil

La fonction pcall() peut aussi être mise en fonction avec deux variables précédentes

local success, error = pcall(function()
	print(table.find("s")) --> est une erreur.
	print("Ca marche")
end)

print("Je suis quelqu'un de gentil")

if not success then -- S'il n'y a pas de succès et donc a une erreur, alors :
    print(error)
end

--> Dans la console:

Je suis quelqu'un de gentil
Script:2: invalid argument #1 to 'find' (table expected, got string)

Hello World

print('Hello World!')
----------------------------
io.write("Hello World!")

Usages

Consoles

Lua a été embarqué dans la PlayStation Portable de Sony, grâce au programme Lua Player, et plus récemment Lua Player HM et Lua Player Euphoria qui permettent de lire des applications écrites avec Lua afin d'étendre les capacités de la console. Viendra plus tard l'XtreamLua Player, destiné à la création de jeux vidéo. Une modification (non officielle) du micrologiciel de la PSP permettait de lancer des programmes non-signés par Sony d'où la création d'un interpréteur Lua adapté pour la PSP.

Lua Player Euphoria reprend la syntaxe du Lua Player original et exécute le script à une vitesse fulgurante comparé au Lua Player HM. Cependant, Lua Player Euphoria est moins complet que son homologue plus ancien.

Lua Player One, un des derniers Lua Player mis à jour pour PSP, est un Lua Player développé au sein d'une communauté de développeurs espagnols ; il permet, entre autres, de gérer la 3D sur PSP. Un jeu de mini-golf dans l'espace a été développé à l'aide de cet outil.

Lua Player Plus (LPP) est sorti sur PlayStation Vita le 16 août 2015. Ce Lua Player permet de créer des jeux pour la console.

Lua est inclus dans la console de poche open-source Pocket Chip (projet Kickstater). En effet cette dernière embarque le programme de console virtuel Pico-8 qui permet de jouer et de créer des jeux en Lua.

Extensions de jeux vidéo

Parmi les jeux vidéo de bac à sable qui l'utilisent figurent Garry's Mod, Roblox, Core, Stormworks (en) et Minecraft. Pour ce dernier, ComputerCraft, un mod du jeu Minecraft, utilise Lua pour concevoir des programmes graphiques ou consoles et des « robots » autonomes à l'intérieur du jeu, permettant d'automatiser de nombreuses tâches répétitives ; Minetest, un jeu sandbox sous licence LGPL similaire à ce dernier, utilise Lua comme langage pour l'écriture d'extensions et à l'intérieur même du jeu (via certains modes) via la programmation de microcontrôleur ou de FPGA.

Il existe également un moteur de jeu utilisant Lua comme langage de programmation (une sorte de Pygame pour Lua) : LÖVE.

Beaucoup d'autres jeux vidéo l'utilisent, comme World of Warcraft de Blizzard Entertainment, Far Cry (et le moteur CryEngine en général) de Crytek Studios, le logiciel multijoueurs de GTA:SA Multi Theft Auto, SimCity 4 et Natural Selection 2 de Unknown Worlds Entertainment (qui a entre autres développé Decoda, un IDE pour Lua). Enfin, certains scripts de Zoo Tycoon 2 (Blue Fang Games) sont également présents sous des formes non compilées dans les fichiers du jeu. The Binding of Isaac: Afterbirth+ est un DLC pour le jeu The Binding of Isaac: Rebirth qui permet le support de mods écrits en Lua.

Autres logiciels

Lua est également utilisé pour l'extension des capacités du lecteur multimédia VLC, dans les gestionnaires de fenêtres EFL Edje d'Enlightenment, dans NeoVim pour sa configuration, ainsi que Awesome (comme langage de configuration et de script).

Le PABX Asterisk propose Lua comme alternative pour étendre son plan de numérotation.

MediaWiki et les sites Wikimedia utilisent Lua comme langage de script pour les modèles (appelés modules).

Le logiciel CraftStudio utilise Lua pour programmer les éléments dynamiques des modèles.

Le logiciel libre d'interface neuronale directe OpenVibE (en) utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.

Le robot IRC irccd utilise Lua pour la création de plugins.

L'antispam Rspamd utilise également Lua pour son interface de programmation.

Lua est le langage de scripting principalement utilisé pour le système d'exploitation embarqué OpenWrt fonctionnant sur de nombreux routeurs. L'interface graphique d'administration LuCI est entièrement écrite en Lua.

Lua est le langage natif de Domoticz, logiciel de domotique open source. Il permet le scripting avec des fonctionnalités avancées : Domoticz déclenche automatiquement ces scripts sur les changements d’états, en fonction du temps, etc.

Lua est également le langage natif de NSBase, logiciel de gestion de bases données. Le scripting permet de dynamiser les formulaires, rapports. Lua ainsi intégré permet de créer de véritables applications de gestion de bases de données.

Le logiciel de simulation de vol spatial Orbiter et ses add-ons (UCGO, UMmu) utilisent Lua pour permettre la création aisée d'écrans de contrôle (MFD - Multi Function Display), de missions ou de vaisseaux. La création de vaisseaux, en particulier, à la différence de modules DLL, ne nécessite pas la compilation d'un fichier C++.

BeamNG.drive utilise Lua pour compléter ses équations physiques.

Prosody : serveur XMPP léger écrit entièrement en lua.

L'environnement de bureau Awesome (linux) utilise aussi Lua dans ses fichiers de configuration depuis sa version 3.

FreeBSD intègre un interpréteur lua dans son chargeur depuis la version 11.3.

La solution qui associe le montage, l’étalonnage, les effets visuels, les animations graphiques et la post-production audio Davinci Resolve utilise Lua, Py2 et Py3.

Le logiciel de notation musicale professionnel Finale propose un plugin Lua.

Annexes

Bibliographie

• (en) « Lua 5.2 Reference Manual », sur lua.org, Lua.org et université pontificale catholique de Rio de Janeiro (consulté le 14 mai 2014)
• (en) Roberto Ierusalimschy, Programming in Lua, Rio de Janeiro, Lua.org et université pontificale catholique de Rio de Janeiro, janvier 2013, 3^e éd. (1^re éd. 2003), 347 p. (ISBN 978-85-903798-5-0 et 85-903798-5-X)
• (en) Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo, Lua Programming Gems, Rio de Janeiro, Brésil, Lua.org et université pontificale catholique de Rio de Janeiro, 2008, 346 p. (ISBN 978-85-903798-4-3)
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel d'apprentissage, Paris, D-BookeR édition, 2012, 188 p. (ISBN 978-2-8227-0005-4, lire en ligne)
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel de référence, Paris, D-BookeR édition, 2012, 336 p. (ISBN 978-2-8227-0015-3, lire en ligne)

Articles connexes

• Plua
• LuaTeX
• GLua

Liens externes

• (en + pt) Site officiel
• Notice dans un dictionnaire ou une encyclopédie généraliste :

  • Den Store Danske Encyklopædi
• Notices d'autorité :

  • BnF (données)
  • LCCN
  • GND
  • Israël
• (en) Lua Development Tools
• (en) Lua embarqué
• (fr) Introduction à la programmation avec Lua