Hubbry Logo
search
logo
List of applications using Lua avatar
List of applications using Lua
List of applications using Lua
current hub
L

List of applications using Lua

logo
Community Hub0 Subscribers
Read side by side
List of applications using Lua
View on Wikipedia
from Wikipedia

The Lua programming language is a lightweight multi-paradigm language designed primarily for embedded systems and clients.

This is a list of applications which use Lua for the purpose of extensibility.

Video games

[edit]
Main category: Lua (programming_language)-scripted video games

In video game development, Lua is widely used as a scripting language by game programmers, perhaps due to its perceived easiness to embed, fast execution, and short learning curve.[1]

In 2003, a poll conducted by GameDev.net showed Lua as the most popular scripting language for game programming.[2] On 12 January 2012, Lua was announced as a winner of the Front Line Award 2011 from the magazine Game Developer in the category Programming Tools.[3]

Other uses

[edit]

Other applications using Lua include:

  • 3DMLW plugin uses Lua scripting for animating 3D and handling different events.
  • Adobe Photoshop Lightroom uses Lua for its user interface.
  • Aerospike Database uses Lua as its internal scripting language for its 'UDF' (User Defined Function) capabilities, similar to procedures
  • Apache HTTP Server can use Lua anywhere in the request process (since version 2.3, via the core mod_lua module).
  • Ardour hard disk recorder and digital audio workstation application uses Lua for scripting including the ability to process audio and Midi.
  • ArduPilot an open source unmanned vehicle firmware that uses Lua for user scripts
  • Artweaver graphics editor uses Lua for scripting filters.
  • Autodesk Stingray, a game engine which uses Lua for developing video games.
  • Awesome, a window manager, is written partly in Lua, also using it as its configuration file format
  • Blackmagic Fusion can be extended and automated through a comprehensive Lua API, as a faster alternative to the Python API.
  • The Canon Hack Development Kit (CHDK), an open source firmware for Canon cameras, uses Lua as one of two scripting languages.
  • Celestia, the astronomy educational program, uses Lua as its scripting language.
  • Cheat Engine, a memory editor/debugger, enables Lua scripts to be embedded in its "cheat table" files, and even includes a GUI designer.
  • Cisco Systems uses Lua to implement Dynamic Access Policies within the Adaptive Security Appliance (ASA), and also SIP normalization in Cisco Unified Communications Manager (CUCM).
  • civetweb Easy to use, powerful, C (C/C++) embeddable web server with optional Lua support.[4]
  • Conky, the Linux system monitoring app, uses Lua for advanced graphics.
  • Cocos2d uses Lua to build games with their Cocos Code IDE.
  • Codea is a Lua editor native to the iOS operating-system.
  • Core uses Lua for user scripts.[5]
  • CRYENGINE uses Lua for user scripts.[6]
  • Custom applications for the Creative Technology Zen X-Fi2 portable media player can be created in Lua.
  • Damn Small Linux uses Lua to provide desktop-friendly interfaces for command-line utilities without sacrificing much disk space.
  • The darktable open-source photography workflow application is scriptable with Lua.[7]
  • Certain tasks in DaVinci Resolve can be automated by Lua scripts, in addition to the more advanced scripting functionality specific to the Fusion page integrated within DaVinci Resolve. Like in Fusion, a Python API can also be used.
  • The Daylon Leveller heightfield/terrain modeler uses embedded Lua to let plug-ins be more easily developed.
  • ESPlorer Multiplatform IDE & tools for any ESP8266 developer from luatool author’s, including a LUA for NodeMCU and MicroPython. All AT commands are supported.
  • Eyeon's Fusion compositor uses embedded Lua and LuaJIT for internal and external scripts and also plugin prototyping.
  • In the videogame Factorio, Lua is used for creating mods and scenarios (expanding the game with scripting)
  • Flame, a large and highly sophisticated piece of malware being used for cyber espionage.[8]
  • Friday Night Funkin': Psych Engine uses Lua for stage building, so-called "modcharts" and multi song functionality, such as editing HUD or adding more functions.[9]
  • Foldit, a science-oriented game in protein folding, uses Lua for user scripts. Some of those scripts have been the aim of an article in PNAS.[10]
  • FreeBSD's default bootloader is implemented in Lua as of version 13.0.[11]
  • FreePOPs, an extensible mail proxy, uses Lua to power its web front-end.
  • Freeswitch, an open-source telephony platform, can make use of Lua as a scripting language for call control and call flow among other things.
  • Garry's Mod, a sandbox video game, uses Lua for mods, called addons, published on the Steam Workshop.
  • Geany, a code editor, has a Lua plugin, GeanyLua.
  • Ginga, the middleware for Brazilian Digital Television System (SBTVD or ISDB-T), uses Lua as a script language to its declarative environment, Ginga-NCL. In Ginga-NCL, Lua is integrated as media objects (called NCLua) inside NCL (Nested Context Language) documents.
  • GrafX2, a pixel-art editor, can run Lua scripts for simple picture processing or generative illustration.
  • HAProxy, a reverse proxying software, may be extended with Lua starting from version 1.6.[12]
  • Hollywood, a cross-platform programming language using Lua.[13]
  • iClone, a 3D real-time animation studio to create animation movies uses Lua in the controls of its new physics simulation.
  • The drawing editor Ipe (mainly used for producing figures with LaTeX labeling) uses Lua for its functionality and script extensions.
  • Leadwerks Game Engine uses Lua for user scripts.[14]
  • Lego Mindstorms NXT and NXT 2.0 can be scripted with Lua using third-party software.[15]
  • lighttpd web server uses Lua for hook scripts as well as a modern replacement for the Cache Meta Language.
  • LÖVE, a 2D game framework for Lua (programming language).[16]
  • Luanti, a 3D games framework for Lua programming language.
  • LuaTeX, the designated successor of pdfTeX, allows extensions to be written in Lua.[17]
  • MediaWiki, which is used on Wikipedia and other wikis, uses Lua as a templating language provided by Scribunto extension.[18]
  • Minecraft modifications like ComputerCraft or OpenComputers allow players to execute Lua on in-game computers.
  • Minetest uses Lua for in-game programming of robots, microcontrollers and sorting tubes, using popular addons.
  • Moho, an animation software package distributed by Smith Micro Software, uses Lua as its scripting language, and all of its native tools are built as editable scripts.
  • mpv (crossplatform media player, an mplayer fork) uses Lua as a scripting language.
  • MySQL Workbench uses Lua for its extensions and add-ons.
  • Neovim text editor offers Lua functionality as a replacement for Vimscript as a scripting language, both for plugin development and for user configuration.[19]
  • NetBSD has a Lua driver that can create and control Lua states inside the kernel. This allows Lua to be used for packet filtering and creating device drivers.[20][21][22]
  • nmap network security scanner uses Lua as the basis for its scripting language, called nse.[23]
  • NodeMCU uses Lua in hardware. NodeMCU is an open source hardware platform, which can run Lua directly on the ESP8266 Wi-Fi SoC.[24]
  • NUT allows Applications written in Lua.
  • OpenMW, a free and open-source game engine recreation that reimplements the one powering Bethesda Softworks' 2002 open-world role-playing game The Elder Scrolls III: Morrowind.
  • OpenResty, a web platform based on nginx, supports Lua scripting in different execution phases.
  • Orbiter (simulator) Space Flight Simulator offers some Lua API allowing to customize simulation feedback, or to automatize simple maneuvers [25]
  • pandoc, a universal document converter, allows modifications of the internal document representation via Lua scripts.[26]
  • Sierra Wireless AirLink ALEOS GSM / CDMA / LTE gateways allow user applications to be written in Lua.
  • PewPew Live uses Lua scripting to define community levels.
  • PowerDNS offers extensive Lua scripting for serving and changing DNS answers, fixing up broken servers, and DoS protection.
  • Project Dogwaffle Professional offers Lua scripting to make filters through the DogLua filter. Lua filters can be shared between Project Dogwaffle, GIMP, Pixarra Twistedbrush and ArtWeaver.
  • Project Zomboid is a video game (similar to The Sims but in zombie theme) made in Java, that uses Lua for mods (expanding the game with scripting).
  • Prosody is a cross-platform Jabber/XMPP server written in Lua.
  • QSC Audio Products supports Lua scripting for control of external devices and other advanced functionality within Q-SYS Designer.
  • Quartz Composer, a visual programming tool by Apple, can be scripted in Lua via a free plugin produced by Boinx Software.
  • Ravenfield (video game) is a first person shooter sandbox game that uses a modified version of Lua.
  • REAPER digital audio workstation supports Lua scripting to extend functionality.
  • Reason digital audio workstation uses Lua to describe remote codecs.
  • Redis, an open source key-value database, uses Lua (starting with version 2.6) to write complex functions that run in the server itself, thus extending its functionality.[27]
  • Renoise audio tracker uses Lua scripting to extend functionality.
  • RetroShare encrypted filesharing, serverless email, instant messaging, online chat and BBS software, has a Lua plugin for automation and control.
  • Roblox is a game platform with its own game engine. It uses a modified version of Lua 5.1 called Luau.[28]
  • Rockbox, the open-source digital audio player firmware, supports plugins written in Lua.
  • RPM, software package management system primarily developed for Red Hat Linux, comes with an embedded Lua interpreter.[29]
  • SAS integrates Lua with PROC LUA as an alternative to its legacy macro language.[30]
  • Scrap Mechanic is a video game, that uses Lua in mods that can be downloaded from the Steam Workshop.
  • ScyllaDB uses Lua for user-defined functions, which let users deploy server-side scripts to perform data transforms such as aggregations, sums and averages.
  • New versions of SciTE editor can be extended using Lua.
  • Snort intrusion detection system includes a Lua interpreter since 3.0 beta release.[31]
  • The Squeezebox music players from Logitech support plugins written in Lua on recent models (Controller, Radio and Touch).
  • Stormworks: Build and Rescue use Lua for microcontrollers scripting / monitor scripting[32]
  • Tarantool uses Lua as the stored procedure language for its NoSQL database management system, and acts as a Lua application server.
  • TeamSpeak has a Lua scripting plugin for modifications.
  • TI-Nspire calculators contain applications written in Lua, since TI added Lua scripting support with a calculator-specific API in OS 3+.
  • Torch is an open source deep learning library for Lua.
  • Trailmakers is a sandbox- vehicle builder game. It uses MoonSharp to bind Lua into Unity which gives the ability the script gamemodes, custom maps and general gameplay functionality.
  • Varnish can execute Lua scripts in the request process by extending VCL through the Lua VMOD (Varnish module).[33]
  • Vim has Lua scripting support starting with version 7.3.[34]
  • VLC media player uses Lua to provide scripting support.
  • Warframe uses Lua for HUD purposes and several other UI operations
  • Waze uses Lua internally. waze-4-35-0-15.apk includes Lua 5.3.3.
  • WeeChat IRC client allows scripts to be written in Lua.
  • WinGate proxy server allows event processing and policy to execute Lua scripts with access to internal WinGate objects.
  • Wireshark network packet analyzer allows protocol dissectors, post-dissectors, and taps to be written in Lua.[35]
  • X-Plane uses lua for aircraft systems and plugins.
  • ZeroBrane Studio Lua IDE is written in Lua and uses Lua for its plugins.

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

List of applications using Lua

View on Grokipedia
from Grokipedia
Lua is a lightweight, high-level, multi-paradigm programming language designed primarily for embedded use in applications, emphasizing simplicity, efficiency, and ease of integration with other languages like C.[1] Developed in 1993 at PUC-Rio in Brazil, Lua excels as a scripting language for extending and customizing software, allowing developers to add dynamic features without recompiling the core application.[1] Its small footprint and fast execution make it ideal for resource-constrained environments, from games to industrial tools.[1] The list of applications using Lua encompasses a diverse range of software across industries, highlighting its versatility and widespread adoption since the early 2000s.[2] In gaming, Lua powers scripting in major titles and engines, such as World of Warcraft for user interface and addon development, Angry Birds for game logic, and the Defold engine for 2D games, developed by King; platforms like Roblox also rely on Lua for user-created content.[1][3] Multimedia and creative software frequently embed Lua for automation and extensibility, exemplified by Adobe Photoshop Lightroom, where it handles plugin scripting, and Blackmagic Fusion, a post-production compositing tool prominent in the film industry.[1][3] Networking and security tools leverage Lua's speed for real-time tasks, including Wireshark for protocol analysis scripting, VLC media player for module extensions, and Snort for intrusion detection rules.[3] Additionally, Lua appears in embedded systems like Brazil's Ginga digital TV middleware and scientific visualization software like Celestia for 3D space simulations.[1][3] This compilation underscores Lua's role in enabling rapid prototyping and customization, with its usage continuing to grow in both commercial and open-source projects worldwide.[2]

Video games and game engines

Commercial video games

Lua has been widely adopted in commercial video games for its lightweight embeddability and ease of integration, allowing developers to handle scripting tasks such as UI customization, AI behaviors, and modding without recompiling core code.[1] In a 2003 poll by GameDev.net, Lua emerged as the most popular scripting language among game programmers, highlighting its early appeal for rapid prototyping and flexible gameplay modifications in AAA titles.[4] One prominent example is World of Warcraft, developed by Blizzard Entertainment, which has utilized Lua since its 2004 launch for player-created UI addons, macros, and interface extensions. This integration enables a highly customizable user experience, where addons can alter combat interfaces, quest trackers, and social features, fostering a vibrant modding community that enhances longevity and player engagement.[5] The Crysis series, powered by Crytek's CryENGINE, employs Lua for scripting entity behaviors, environmental interactions, and modding since the engine's debut in Far Cry (2004). For instance, in Crysis (2007) and its sequels, Lua scripts manage dynamic events like alien encounters and nanosuit abilities, supporting rapid iteration during development and extensive mod support post-release. Crytek's official Mod SDK, released in 2008, further emphasizes Lua's role in extending game logic.[6] Similarly, Sid Meier's Civilization V (2010) integrates Lua for modding systems, including custom events, diplomacy rules, and UI elements, allowing players and creators to overhaul gameplay mechanics like technology trees and victory conditions. This approach has made Lua a cornerstone for the series' modding ecosystem, contributing to its enduring popularity among strategy gamers.[7]

Game engines and platforms

Lua has been integral to numerous game engines and platforms, enabling developers to script game logic, handle user interactions, and facilitate cross-platform development due to its lightweight and embeddable nature. These engines leverage Lua's simplicity and performance for rapid prototyping and deployment across desktop, mobile, console, and web environments. Prominent examples include frameworks that power user-generated content and professional-grade titles, highlighting Lua's versatility in both hobbyist and commercial contexts. Roblox, a platform for creating and playing user-generated games, has utilized a scripting language based on Lua since approximately 2006; this language, now known as Luau, was open-sourced and officially named in 2021 while maintaining backwards compatibility with Lua 5.1 and adding optimizations like gradual typing and enhanced performance. Luau serves as the core scripting tool in Roblox Studio for building interactive experiences. This integration allows millions of creators to develop complex, multiplayer games, with Lua handling everything from physics simulations to UI elements.[8][9] Defold, a free and open-source 2D game engine developed by King (the studio behind Candy Crush Saga), relies on Lua for all game logic and scripting since its initial public release in 2016. Lua's role in Defold enables seamless cross-platform deployment to iOS, Android, Windows, macOS, Linux, HTML5, and consoles, making it ideal for mobile and web games. King continues to employ Defold for selected live operations titles, demonstrating Lua's efficiency in scaling high-traffic games with minimal overhead.[10][11] Solar2D, formerly known as Corona SDK, is a Lua-based engine focused on mobile app and game development since its commercial availability around 2011. It uses Lua as the primary scripting language layered atop C++ and OpenGL, allowing developers to create cross-platform 2D applications with native performance. Lua's lightweight design in Solar2D supports rapid iteration for features like physics, animations, and monetization, powering thousands of mobile titles on app stores.[12][13] LÖVE (often stylized as Love2D), an open-source framework for 2D game development, has incorporated Lua as its scripting language since its inception in 2008. Designed for simplicity, LÖVE provides bindings to libraries like SDL and Box2D, with Lua handling game loops, rendering, and input processing across Windows, macOS, Linux, Android, and iOS. This adoption has fostered a vibrant community for indie 2D games, emphasizing Lua's ease in creating portable, performant experiences without a full engine overhead.[14]

Indie and open-source games

Indie and open-source games frequently utilize Lua for scripting game mechanics, modding systems, and user-generated content, fostering vibrant communities where players extend gameplay through custom additions. This approach allows developers to create extensible titles without the overhead of complex engines, emphasizing accessibility and creativity in smaller-scale projects. Lua's lightweight nature makes it ideal for these environments, enabling rapid prototyping and iteration in resource-constrained development. Garry's Mod, an indie sandbox game released in 2006, relies heavily on Lua for its addon system, which powers user-created content such as weapons, vehicles, and gamemodes. The Steam Workshop hosts over 1.9 million addons, many implemented via Lua scripts, supporting a massive community that has produced diverse experiences like role-playing servers and custom maps.[15] Luanti (formerly Minetest), an open-source voxel-based game engine initiated in 2010 and renamed in October 2024, employs Lua for modding nodes, entities, and user interfaces, allowing creators to build entirely new worlds and mechanics.[16] Its official modding documentation highlights Lua's role in extending core functionality, contributing to a ecosystem of thousands of community mods that enhance gameplay variety.[17] Factorio, an indie automation game entering early access in 2016, integrates Lua scripting for mods that alter recipes, add machinery, and create scenarios, enabling players to customize industrial simulations.[18] The official mod portal features extensive Lua-based contributions, which have expanded the game's replayability through community-driven overhauls. Friday Night Funkin', a rhythm game released in 2020, incorporates Lua scripts via the Psych Engine mod, introduced in 2021, for custom events, character behaviors, and chart modifications in fan-made content.[19] This scripting support has empowered modders to produce intricate song packs and visual effects, amplifying the game's modding scene. Open-source projects like Mari0, a 2012 fan game blending Super Mario Bros. and Portal mechanics built on the Love2D framework, use Lua to define levels, physics interactions, and portal functionality. Such implementations demonstrate Lua's utility in crafting puzzle-platformers with procedural or editable elements, inspiring further indie experiments in the Love2D community.

Multimedia and creative software

Graphics and image editing

Lua scripting has been integrated into several prominent graphics and image editing applications, enabling users to customize user interfaces, automate workflows, and develop plugins for enhanced functionality in photo manipulation and processing tasks.[20][21][22] Adobe Photoshop Lightroom, released in 2007, incorporates Lua as a core scripting language for plugin development, allowing users to create custom tools for UI customization, automation, and integration with external services. Lua in Lightroom supports scripting for export presets, metadata handling, and batch processing operations, such as applying develop settings to selected photos or generating collections based on date ranges.[20][23] This integration has evolved with post-2020 updates, enhancing Lua's API for better compatibility with modern hardware and extending support for advanced automation without relying on third-party plugins.[24] The GNU Image Manipulation Program (GIMP) provides Lua bindings for plugin development, introduced in the development series leading to GIMP 3.0 in the early 2020s, released on March 16, 2025.[21][25] These bindings enable Lua scripts to interact with GIMP's image processing pipeline, supporting custom filters, UI extensions, and algorithmic testing environments like the gluas plugin for rapid prototyping of image effects.[26][27] Darktable, an open-source raw image editor, has utilized Lua for scripting since version 1.4 in 2013, focusing on image processing automation and workflow customization, as of version 5.2.1 (2025). Lua scripts in darktable allow users to define event-driven actions, such as exporting images with custom labels, manipulating modules via GUI actions, and extending the core functionality with contributed scripts for tasks like initial workflow configuration.[22][28] Recent updates have expanded the Lua API to version 9.5.0, improving stability and integration for advanced users.[29]

Audio and video processing

Lua scripting has been integrated into various audio and video processing tools to enable custom automation, plugin development, and extension capabilities, particularly for handling time-based media workflows. In digital audio workstations (DAWs), Lua provides a lightweight and embeddable language for scripting effects, MIDI processing, and session management, allowing users to extend functionality without recompiling the core application. Ardour, a professional open-source DAW, has supported Lua for audio and MIDI scripting since version 5.0 in 2016, enabling users to create custom plugins for tasks such as signal processing, automation curves, and real-time effects.[30] Lua scripts in Ardour run within the application's processor framework, interfacing directly with audio buffers and control parameters to facilitate non-destructive editing and modular plugin design. This integration has made Ardour a staple for audio engineers seeking flexible scripting, with Lua's simplicity allowing rapid prototyping of complex routing and synthesis behaviors. The VLC media player, developed by VideoLAN, incorporates Lua for extensions and scripting since version 0.8.6 in 2006, primarily for customizing playback, streaming, and interface behaviors in video and audio handling. Lua scripts in VLC allow developers to add features like dynamic playlist generation, subtitle synchronization, and network streaming protocols, with the language's core embedded via the LuaJIT interpreter for efficient execution during media decoding. Recent updates in VLC versions post-2023, such as 3.0.20, have enhanced Lua support for advanced streaming scripts, including integration with HTTP Live Streaming (HLS) and real-time transcoding controls.

Animation and compositing

Blackmagic Fusion, a professional node-based compositing and visual effects software, integrates Lua as a core scripting language to enable automation and customization in animation workflows.[3] Lua scripts in Fusion allow artists to manipulate composition nodes, generate procedural animations, and create reusable macros for complex scene assembly, streamlining tasks such as particle simulations and layer blending in 3D environments.[31] This scripting capability has been available since the software's early development in the 2000s, evolving from the original eyeon Fusion's Lua-based eyeonscript system to support modern film production pipelines.[32] In practical applications, Lua facilitates the automation of compositing nodes for film and television, where users can script dynamic keyframe animations, integrate external data for motion graphics, and optimize rendering processes across multiple shots.[33] For instance, artists employ Lua to build custom tools that adjust parameters in real-time, such as automating rotoscoping or merging 2D elements with 3D renders, reducing manual adjustments in high-volume VFX sequences.[31] These scripts run within Fusion's API, accessing tools for spline-based animation and vector graphics, which enhances efficiency in collaborative studio environments.[32] Fusion's Lua integration has significantly impacted the entertainment industry, powering visual effects in major Hollywood productions through its inclusion in DaVinci Resolve Studio.[34] Notably, the Disney+ series Ms. Marvel utilized Fusion for VFX compositing.[34] This adoption extends to broader Marvel Cinematic Universe projects and other blockbusters, demonstrating Lua's role in scalable, high-fidelity animation pipelines that handle intricate layering and motion control for cinematic outputs.[35]

Server and database systems

Web servers and frameworks

Lua, an embeddable scripting language, has been integrated into various web servers and frameworks to enable dynamic content generation, request routing, and middleware processing at the server level. Its lightweight nature and just-in-time (JIT) compilation capabilities, particularly through LuaJIT, make it suitable for high-performance web environments where low-latency scripting is essential. Since the early 2010s, Lua's adoption in this domain has grown due to its ability to extend traditional web servers without requiring full application rewrites, supporting use cases like API gateways and edge computing. One prominent example is OpenResty, a dynamic web platform built on Nginx since 2009, which embeds Lua for scripting HTTP requests and responses. OpenResty allows developers to write Lua modules for tasks such as load balancing, authentication, and caching, leveraging Nginx's event-driven architecture for scalability. Its integration with LuaJIT enables sub-millisecond response times in high-throughput scenarios, making it a choice for large-scale deployments. Cloudflare, a major content delivery network, has utilized OpenResty with Lua for custom edge logic in services such as its Web Application Firewall (WAF), handling billions of requests daily to implement features like rate limiting and content transformation.[36] As of September 2025, Cloudflare is transitioning from LuaJIT to Rust for enhanced performance.[37] Apache HTTP Server incorporated Lua support via the mod_lua module starting with version 2.3 in 2012, allowing Lua scripts to hook into all phases of the request lifecycle, from URI mapping to content generation. This module provides a flexible way to add dynamic behavior to static server configurations, though it is less performant than Nginx-based solutions due to Apache's process-based model. It has been used in enterprise environments for middleware tasks, such as integrating with external services during request processing. Lapis, a web framework for Lua released in 2012, builds on OpenResty to offer a higher-level abstraction for building web applications, including routing, database integration, and templating. It emphasizes simplicity and speed, with features like automatic reloading for development and support for PostgreSQL and Redis. Lapis has seen adoption in rapid prototyping for APIs, particularly in environments requiring Lua's embeddability. Post-2020, Lua's role in web frameworks has expanded with the rise of microservices architectures, where its efficiency supports containerized deployments. For instance, Indonesian e-commerce platform Tokopedia employs Lua in its backend to manage high-traffic APIs, contributing to handling millions of transactions daily. This trend reflects Lua's shift toward modern, distributed web systems, prioritizing performance over complex feature sets.

Databases and data processing

Lua scripting enhances databases and data processing systems by enabling embedded, high-performance server-side logic for tasks like stored procedures, custom queries, and data transformations, often executed atomically to ensure consistency and efficiency. This approach leverages Lua's lightweight nature and fast execution, allowing developers to extend core database functionality without external dependencies. Several prominent systems have adopted Lua for these purposes, providing scalable solutions for real-time data handling. Redis, an open-source in-memory key-value store used primarily for caching and messaging, introduced Lua scripting support in version 2.6, released in 2012.[38] The EVAL command permits the execution of Lua scripts directly on the Redis server using an embedded Lua 5.1 interpreter, ensuring atomicity such that no other commands or scripts can run concurrently during execution.[39] This capability is widely employed for complex atomic operations, such as distributed locks, rate limiting, or multi-key transactions in caching applications, reducing network round-trips and improving performance in high-throughput environments.[38] Aerospike, a distributed NoSQL database designed for high-scale applications, has supported User-Defined Functions (UDFs) in Lua since its early releases in the 2010s.[40] These UDFs, executed within the database engine, allow for custom record-level manipulations and stream processing, such as aggregation or filtering, directly on stored data to minimize latency.[41] In telecommunications, Aerospike's Lua UDFs enable real-time analytics on massive datasets, supporting use cases like fraud detection and network optimization by processing billions of events per day with sub-millisecond response times. Tarantool, an in-memory database and Lua application server, has been built around Lua since its inception in 2008 by VK (formerly Mail.Ru Group).[42] It embeds Lua as its primary language for defining data spaces (analogous to tables), implementing business logic, and executing stored procedures, allowing seamless integration of application code with the database engine.[43] This design facilitates efficient data processing for scenarios like real-time analytics and queuing, with Lua modules handling everything from schema definition to query optimization in a single runtime environment.[42]

Embedded systems and IoT

Microcontroller platforms

Microcontroller platforms leverage Lua's lightweight and embeddable nature to enable scripting on resource-constrained hardware, particularly in IoT and embedded applications where low memory and power consumption are critical. These platforms run Lua interpreters directly on bare-metal or minimal firmware, allowing developers to create responsive firmware without the overhead of traditional compiled languages.[44] NodeMCU, introduced in 2014, provides an open-source Lua-based firmware for Espressif's ESP8266 and later ESP32 WiFi system-on-chips (SoCs).[45] It integrates Lua scripting with the hardware's WiFi capabilities, enabling asynchronous, event-driven programming for tasks like HTTP servers and GPIO control.[46] This has made NodeMCU a staple in DIY IoT projects, where users script WiFi-enabled sensors and actuators directly on the device, facilitating rapid prototyping of connected home automation and environmental monitoring systems. eLua, a bare-metal implementation of Lua for microcontrollers, has been available since 2010 and supports a range of architectures including ARM and AVR variants.[47] By eliminating the need for an underlying operating system, eLua offers full platform control and portability across MCUs, allowing Lua programs to interface directly with peripherals like timers and ADCs.[44] Although the main eLua project has seen limited updates since 2015, it remains influential in embedded Lua implementations. Its compact footprint (requiring at least 256 KB of flash memory and 32 KB of RAM, depending on configuration) minimizes resource usage. It is particularly suited for custom embedded applications, such as real-time control in industrial sensors. OpenWrt, a Linux-based firmware for routers and embedded devices originating in the mid-2000s, incorporates Lua through its LuCI web configuration interface, introduced in 2008.[48] Lua scripts handle dynamic UI generation and device management tasks, such as network configuration, integrated via CGI with the uHTTPd server.[49] This embedding supports extensible router firmware for home and small office networks, where Lua's efficiency aids in processing configuration data on low-power MIPS or ARM-based hardware.[48] Post-2020 developments have highlighted Lua's role in energy-efficient designs for battery-powered IoT sensors, with platforms like NodeMCU enabling deep sleep modes and minimal scripting overhead to extend battery life in wireless monitoring devices.[50] For instance, Lua scripts on ESP8266-based sensors have been used in energy management systems, achieving low-duty-cycle operation that conserves power during intermittent data transmission.

Operating systems and bootloaders

Lua has been integrated into operating systems and bootloaders primarily for its lightweight nature, ease of embedding, and suitability for scripting low-level initialization tasks. In these environments, Lua serves as a flexible configuration and automation language, allowing developers to handle boot menus, kernel loading, and system probing without the overhead of more complex scripting systems. Its small footprint makes it ideal for resource-constrained boot environments, where it can replace older interpreters like Forth for enhanced maintainability and extensibility.[51] A prominent example is FreeBSD, where the boot loader's scripting language switched to Lua by default starting with version 12.0-RELEASE in 2018, and the legacy Forth-based loader was fully deprecated in version 13.0-RELEASE in 2021.[52][53] In FreeBSD's loader_lua(8), Lua automates the final stage of kernel bootstrapping by processing configuration files such as /boot/loader.conf and executing scripts like /boot/lua/loader.lua. This enables dynamic detection of installed kernels, module loading, and interactive boot menus, improving usability over static configurations.[54] For instance, during the boot process, the loader probes available consoles, sets environment variables like currdev for the boot device, and supports autoboot with configurable delays; if interrupted, users can interact via Lua-evaluated commands for troubleshooting or manual kernel selection.[54] Lua's role in the boot process extends to menu scripting and loader commands, where built-in functions handle tasks like variable manipulation and error recovery through Lua exceptions. In FreeBSD, this allows for features such as kernel autodetection (enabled by default via the kernels_autodetect option in loader.conf) and module blacklisting, streamlining the transition from firmware to kernel execution.[51] Derivatives like helloSystem, a graphical FreeBSD variant, further leverage these Lua scripts for customized boot behaviors, including enhanced console handling during initialization.[55] Regarding security, Lua's inherent sandboxing capabilities are crucial in OS environments, as the language can be configured with restricted globals and environments to limit access to sensitive operations like file I/O or process execution. In bootloaders, this prevents unintended modifications during scripting; for example, FreeBSD's loader_lua isolates script execution to mitigate risks from removable media or altered variables (e.g., init_path), recommending protections like password authentication or negative autoboot delays to block unauthorized access.[54][56] Such sandboxing ensures that Lua scripts in boot contexts remain secure against potential exploits, aligning with the need for trustworthy low-level system code.[57]

Development tools and editors

Text editors and IDEs

Lua has been adopted in various text editors and integrated development environments (IDEs) primarily for user configuration, macro scripting, and plugin extensibility, leveraging its embeddability and performance for customizing editing workflows. Neovim, a highly extensible fork of the Vim editor, integrated Lua as a first-class scripting language with the release of version 0.5 on July 2, 2021, enabling users to write configurations and plugins directly in Lua via an init.lua file and dedicated APIs.[58] This transition from Vimscript to Lua APIs facilitates faster plugin development and execution due to Lua's efficiency and reduced overhead in interop with Neovim's core, allowing complex extensions like language server integrations and syntax highlighting without the limitations of Vimscript's quirks.[59] By 2025, the Neovim ecosystem includes a thriving collection of Lua-based plugins, with community repositories such as neovimcraft.com cataloging over 1,000 extensions that enhance features from autocompletion to file management.[60] ZeroBrane Studio, a cross-platform Lua-focused IDE first released in 2010, is implemented largely in Lua itself, using the language for its core editing, debugging, and code analysis capabilities, including live coding and remote interpreter support.[61] SciTE, a lightweight text editor based on the Scintilla component library, has incorporated Lua for macros and scripting since the early 2000s, permitting users to automate tasks, customize menus, and interact with editor buffers through Lua functions accessible via the Tools menu.[62]

Build and automation tools

Lua has found significant application in build and automation tools, leveraging its embeddability, simplicity, and efficiency for scripting complex project configurations and dependency management. These tools benefit from Lua's lightweight runtime, which allows for rapid execution in resource-constrained environments while providing powerful metaprogramming features to abstract build logic. LuaRocks serves as the primary package manager for Lua modules, enabling the creation, installation, and distribution of self-contained packages called "rocks" that include versioned dependencies and build instructions. First released in version 0.1 in August 2007, LuaRocks standardizes module packaging across platforms and Lua versions, supporting automated building from source or precompiled binaries via a central repository.[63][64] It integrates seamlessly with build processes, allowing developers to declare dependencies in rockspecs—Lua-based specification files—and automate installations without manual intervention.[64] Premake is a versatile build configuration generator that employs Lua scripting to produce native project files for IDEs like Visual Studio, Xcode, and makefiles, facilitating cross-platform development workflows. Developed since 2009, it allows users to define projects declaratively in Lua scripts, handling tasks such as compiling C++ code, linking libraries, and generating platform-specific configurations with minimal boilerplate.[65] For example, Premake's Lua API supports conditional logic for multi-platform builds, enabling efficient automation of project generation for diverse targets like Windows, macOS, and Linux.[66] xmake represents a contemporary Lua-driven build system, emphasizing simplicity and speed for modern C/C++ projects with integrated package management. Launched in 2019, it uses concise Lua scripts (xmake.lua files) to describe builds, dependencies, and targets, supporting over 500 official packages and cross-compilation without external tools.[67] xmake's automation extends to rule definitions for custom tasks, such as integrating third-party libraries or generating artifacts, making it suitable for large-scale software engineering pipelines.[68] Beyond dedicated build systems, Lua enhances continuous integration and continuous deployment (CI/CD) pipelines by scripting automation tasks. In GitHub Actions, for instance, LuaRocks is commonly invoked via dedicated actions to install dependencies and run tests, streamlining workflows for Lua projects; the leafo/gh-actions-luarocks action automates Lua version setup and rock installations in YAML-defined pipelines.[69] Similarly, xmake provides an official GitHub Action (github-action-setup-xmake) for embedding builds directly into CI/CD processes, reducing setup overhead and enabling reproducible deployments.[67] This integration highlights Lua's role in efficient, scriptable automation for software delivery.

Emerging and specialized uses

Mobile app development

Lua has found significant application in mobile app development through frameworks that leverage its lightweight and embeddable nature to facilitate cross-platform creation of games and interactive applications. One prominent example is Solar2D, formerly known as Corona SDK, a Lua-based framework released in late 2009 that enables developers to build 2D mobile applications for platforms including iOS, Android, and Kindle Fire.[12] Solar2D allows a single Lua codebase to target multiple operating systems, streamlining development by abstracting platform-specific complexities while maintaining high performance for graphics and physics simulations. A key strength of Solar2D in mobile contexts is its ability to provide native UI components and access to device features directly from Lua scripts, bypassing the need for developers to write code in Java for Android or Swift for iOS. This integration is achieved through Lua bindings to native APIs, enabling rapid prototyping and deployment of apps with hardware acceleration for touch inputs, sensors, and multimedia. For instance, developers can implement gesture recognition or camera access using simple Lua calls, which compile to optimized native code, making it particularly suitable for resource-constrained mobile environments. Since its inception, Solar2D has been adopted for thousands of mobile games and utilities, contributing to Lua's role in efficient cross-platform development.[2] Another notable tool is Codea, an iPad-exclusive app released in late 2011 that uses Lua for on-device creative coding and prototyping of games, simulations, and interactive experiences. Codea provides an integrated editor with live previews, allowing users to write and test Lua code directly on the tablet, which supports exporting projects to full iOS apps via Xcode integration.[70] Its design emphasizes accessibility for beginners and professionals alike, with built-in libraries for graphics, physics, and audio that align with mobile hardware capabilities, fostering rapid iteration without traditional development setups.[2] Codea has enabled the creation of numerous iPad-native applications, highlighting Lua's utility in touch-centric mobile environments.[71]

AI and machine learning

Torch7 was a prominent machine learning library and scientific computing framework that embedded Lua as its primary scripting language, enabling efficient development of AI models from its inception around 2002 at the Idiap Research Institute.[72] Developed initially by Ronan Collobert, Clément Farabet, and Koray Kavukcuoglu, Torch7 leveraged LuaJIT—an optimized just-in-time compiler for Lua—to provide a flexible, Matlab-like environment for numerical computations and algorithm prototyping.[73] Its core strength lay in Lua-based tensor operations, which supported multi-dimensional arrays for data manipulation, alongside interfaces to C and CUDA for high-performance GPU acceleration, making it suitable for deep learning tasks such as neural network training and optimization.[74] In the realm of AI research, Torch7 was widely adopted for its modular design, allowing users to define complex model architectures through Lua scripts, including convolutional and recurrent neural networks via the nn library.[75] Facebook AI Research utilized Torch7 for projects like fairseq-lua, a sequence-to-sequence toolkit for neural machine translation, which implemented LSTM and convolutional models with multi-GPU support for training large-scale language models.[76] This integration demonstrated Lua's role in facilitating rapid experimentation in natural language processing and computer vision, where Torch7's energy-based models and optimization routines enabled breakthroughs in scalable AI systems. Development of Torch7 ceased around 2017 with the shift to its Python-based successor, PyTorch. Lua's lightweight footprint has also positioned it for specialized applications in edge computing on resource-constrained IoT devices, where scripting efficiency is critical for real-time tasks. As of 2024, Lua continues to be used in embedded platforms for tasks such as sensor data processing due to its minimal memory usage and fast execution compared to heavier languages.[77] For instance, ports of Torch7 to iOS and Android extended its Lua tensor capabilities to mobile environments, supporting on-device machine learning prototypes without relying on cloud resources, though these are now largely historical.[72] In more recent developments as of 2025, Lua is employed for dynamic AI scripting in games, such as implementing state machines for character behaviors.[78]

References

  1. about - Lua.org
  2. Lua: uses - Lua.org
  3. Lua: showcase
  4. Lua: news
  5. Lua: workshop 2009 - Lua.org
  6. Get The Crysis Mod SDK v1.2 Now! - Crytek
  7. Lua and UI Reference (Civ5) - Civilization Modding Wiki
  8. Luau - Luau
  9. Luau | Documentation - Roblox Creator Hub
  10. Defold - Official Homepage - Cross platform game engine
  11. Lua programming in Defold
  12. Solar2D Game Engine
  13. Introduction to Lua - Solar2D Documentation
  14. LÖVE - Free 2D Game Engine
  15. Garry's Mod
  16. Luanti (formerly Minetest) is an open source voxel game ... - GitHub
  17. Minetest Modding Book
  18. Factorio
  19. ShadowMario/FNF-PsychEngine: Engine originally used on ... - GitHub
  20. Unleash Lightroom Classic with Lua - Adobe Developer
  21. GIMP 3.0 Release Notes
  22. darktable 4.6 user manual - Scripting with Lua
  23. shuangye/lightroom-auto-develop: A Lua script that auto applies ...
  24. lua SDK for lightwoom classic - Adobe Product Community - 14170571
  25. Chapter 2. The gluas environment - GIMP
  26. Add Lua scipting capability (#140) · Issue - GIMP - GitLab
  27. darktable-org/lua-scripts - GitHub
  28. Lua API Version - darktable
  29. [PDF] SCRIPTING GUIDE AND REFERENCE MANUAL February 2016
  30. Fusion 20 | Blackmagic Design
  31. DaVinci Resolve – Fusion | Blackmagic Design
  32. Ms. Marvel Finished in DaVinci Resolve Studio - Blackmagic Design
  33. Marvel's rebirth and other major successes rely on Blackmagic
  34. Scripting with Lua | Docs - Redis
  35. EVAL | Docs - Redis
  36. Getting Started With Lua UDFs | Aerospike Documentation
  37. User-defined functions (UDFs) | Aerospike Documentation
  38. Tarantool Community Edition
  39. Defining and manipulating data - Tarantool.io
  40. Overview - eluaproject
  41. Lua based interactive firmware for ESP8266, ESP8285 and ESP32
  42. NodeMCU Documentation
  43. eLua Project on GitHub
  44. Technical Reference - [OpenWrt Wiki] LuCI
  45. [OpenWrt Wiki] LuCI essentials
  46. [PDF] Battery Monitoring System Using IOT - Impact Factor: 8.423
  47. FreeBSD 12.0-RELEASE Release Notes
  48. https://www.freebsd.org/cgi/man.cgi?loader(8
  49. How to know if the Forth bootloader or Lua bootloader being used?
  50. loader_lua - FreeBSD Manual Pages
  51. Boot process — helloSystem documentation
  52. lua-users wiki: Sand Boxes
  53. Scriptable operating systems with Lua - ACM Digital Library
  54. Neovim News #11 - The Christmas Issue
  55. Neovim 0.5: Lua, built in LSP, Treesitter and the best plugins for 2021
  56. neovimcraft
  57. pkulchenko/ZeroBraneStudio: Lightweight Lua-based IDE ... - GitHub
  58. Using Lua With Scite - lua-users.org
  59. [PDF] An informal history of LuaRocks - hisham.hm
  60. LuaRocks - The Lua package manager
  61. Premake
  62. Your First Script | Premake
  63. xmake-io/xmake: A cross-platform build utility based on Lua - GitHub
  64. Xmake
  65. Testing Lua projects with GitHub Actions - leafo.net
  66. Codea — Creative Coding on iPhone and iPad
  67. Codea - App Store - Apple
  68. Torch | Scientific computing for LuaJIT.
  69. [PDF] Torch7: A Matlab-like Environment for Machine Learning
  70. Getting started with Torch
  71. https://github.com/torch/torch7
  72. facebookresearch/fairseq-lua: Facebook AI Research Sequence-to ...
  73. https://arxiv.org/abs/1705.03122
  74. Harnessing Lua's Power for IoT and Embedded Systems
User Avatar
No comments yet.