List of projects
Tecgraf is the result of a partnership between
PUC-Rio, the Pontifical Catholic University of Rio de Janeiro,
PETROBRAS, the Brazilian Oil Company.
Tecgraf is Lua's birthplace, and the language has been used there since 1993.
Currently, more than thirty programmers in Tecgraf use Lua regularly,
who have written more than two hundred thousand lines of code,
distributed among dozens of final products.
Computer Graphics Technology Group, PUC-Rio
Contact: Waldemar Celes
The Advanced X-ray Astrophysics Facility (AXAF), due to be launched in 1998, is
the third of NASA's four Great Space Observatories. AXAF will provide
unprecedented capabilities of high resolution imaging and spectroscopy over the
X-ray range of 0.1-10keV.
As part of our efforts to support the AXAF program, the SAO AXAF Mission
Support Team has developed a software suite to simulate AXAF images generated
by the flight mirror assembly. One of the tasks of this system is to simulate
the physical obstructions in front of and behind the AXAF mirrors.
The generalized aperture program is designed to simulate the
effects on the incident photon stream of physical obstructions, such as thermal
baffles and pre- and post-collimators. It can handle a wide variety of aperture
shapes, and has provisions to allow alterations of the photons by the
apertures. The philosophy behind the aperture program is that a geometrically
complicated aperture may be modeled by a combination of geometrically simpler
apertures. This is done by incorporating a language, Lua, to lay out the
apertures. User provided call-back functions enable the modeling of the
interactions of the incident photon with the apertures.
This approach allows for maximum flexibility, since the geometry and
interactions of obstructions can be specified by the user at run time.
Contact: Diab Jerius
RPA is an intranet system developed by PUC-Rio
to record the academic production of its faculty.
The project started in August, 1994 in the Department of Computer Science;
in 1996 it was extended to other departments.
Currently, the system is being used by hundreds of faculty and staff members
from all departments of the University.
This project was the birthplace of the
CGILua library and
its team contributes in the development of HTMLToolKit (which is
distributed with CGILua).
Pontifical Catholic University of Rio de Janeiro
Contact: Tomas Gorham
We did this application for
They are specialized in creating recreational and commercial vehicles.
We had to create a bench test for snowmobiles, which are assembled in
Valcourt, Québec, Canada. The application had to be fully customizable,
because as new technologies are added to the vehicles, more tests have to
be done, and existing ones change.
All the tests are done in Lua. The host application, which is programmed
in Delphi, serves only to expose a toolkit to the Lua environment, and to
load the correct Lua script depending on the vehicle being tested. The
toolkit is composed of many functions that access different hardware
components, like data acquisition cards and sound cards. Other functions
are used to talk with a component inside the snowmobile, called a MEM. This
is the heart of the snowmobile; it regulates motor speed and also serves as
an anti-theft system. Some functions are used to interact with the operator
performing the tests. All the test results are stored in an SQL server.
The host application is written in Delphi 2.0. We interact
with Lua via a DLL written in C, using Visual C++ 4.2. I have merely
exposed key Lua functions in the DLL, and call them from the host
application. The DLL spawns a DOS console, then redirects stdin, stdout and
stderr so we can see errors messages created by the Lua engine. There are
currently 66 functions in the toolkit, and we are adding 16 more for future
use. The part of the host application that treats Lua requests is in a
separate thread, so we don't stop the main thread while executing Lua code.
To execute the Lua code, I simply save the Lua script in a local file, then
call the function lua_dofile. All Lua code comes from the SQL server.
The application is now in operation and works fine. We are currently
working to adapt the host application to be used on another type of
vehicle, the VTT, which will be produced by Bombardier this summer.
Contact: Robert Lamoureux
I'm using Lua to sequence high-level commands to robots, connected to the
host either via a serial line or transputer link; perhaps in future via USB
or FireWire. Lua is particularly valuable here because the debugger hooks
give me a means to make external asynchronous events (eg: touch-sensors) look
like atomic actions as far as the Lua program is concerned, and allow users to
assign call-back functions to them. Essentially the robot is a ``manipulation
server'' and the Lua program its client. The second major advantage is the
portability; I can easily compile a stripped-down Lua client for an embedded
processor on the robot's motherboard. The user can then download their final
debugged application into non-volatile memory, disconnect the host and
leave the robot to get on with the job.
Contact: Mark Ian Barlow
GT Software, Inc. has developed an IBM CICS Based HTTP/FTP Server that includes
a 3270 Web Browser. The Product "Novation" (TM) includes Lua as a HTTP server
GT Software, Inc.
Contact: Steve Able
PIROL (Project Integrating Reference Object Library)
is targeted at full coverage of all aspects of real software
development projects. It was first designed with a strict focus on object
oriented development, but for the use within the ongoing project
ESPRESS it has also been extended towards formal techniques such as Z.
The redesign resulted in LuaP, an adaptation of Lua for PIROL, which is
now used to define PIROL's meta model.
Contact: Stephan Herrmann
The HZ Engine is a 2d real-time action strategy engine.
It was originally written for Win32/DirectDraw, but it
has now been ported to Linux/X11. Lua is used for game logic and
sprite definition. All sprite properties, including animation
sequencing, physics, and object properties are coded in Lua.
Contact: David Jeske
Automatic Web site maintenance
Several pages in this site are generated automatically from
databases in Lua.
Graduate Program in Systems Engineering and Computer Science, Federal University of Rio de Janeiro
Contact: webmast AT cos.ufrj.br
This project uses Lua as the basis of a platform for the
construction of extensible management applications.
Lua is used on a standalone basis and
not really as an extension language.
The LuaMan library was developed to provide access to services which are
specifically relevant to tcp/ip network management: SNMP, ICMP and DNS.
We are currently working on the development of an OO interface
for these services. LuaMan runs on Linux, Solaris, SunOS, IRIX and
AIX. Work is also under way for porting LuaMan to Windows NT.
Using LuaMan and other available libraries, such as CGILua and LuaOrb,
several small management applications have been built.
Contact: Noemi Rodriguez
AulaNet is a software environment based on the Web developed at the Software
Engineering Laboratory (LES) of the Department of Computer Science at PUC-Rio,
for creating and assisting distance courses.
AulaNet was conceived from the experience gained in three courses
during the second semester of 1997,
and is based on the following basic premises:
Software Engineering Lab, PUC-Rio
- The courses created must posses great capacity of interactiveness, in
order to encourage intense participation by the student in the learning
- The author of the course does not need to be a specialist on the Internet.
- The resources offered by the creation of the courses must correspond to
those available in a conventional classroom, plus others normally available
in a Web environment.
- It must be possible to re-use the contents already existing in digital
media, through importing files, for example.
Contact: AulaNet Team
The resource manager (RES) is a C-library for use with the Scitech
MGL and uses the language Lua as a configuration language.
The RES deals with resource allocation (i.e loading of files, use of
certain datatypes) and abstracts the use of resources through a
This means that you never have to allocate a bitmap again, you just
ask the repository for an image with a certain name.
It also helps in grouping information so that multi-lingual versions
of software are easier to develop and maintain.
The project is under continuous development.... 8-)
Contact: Freek Brysse
noweb is designed to meet the needs of literate programmers while
remaining as simple as possible.
Its primary advantages are simplicity, extensibility,
noweb uses 5 control sequences to WEB's 27.
The noweb manual is only 3 pages;
an additional page explains how to customize its LaTeX output.
noweb works ``out of the box'' with any programming language,
and supports TeX, latex, and HTML back ends.
A back end to support full hypertext or indexing takes about 250 lines;
a simpler one can be written in 40 lines of awk.
The primary sacrifice relative to WEB is that code is seldom prettyprinted.
Electrical Engineering and Computer Science, Harvard University
noweb has been used for eight years at many universities and
It has been used for tens of thousands of lines of code in such
languages as awk, C, C++, Icon, Modula-3, PAL, perl, Promela,
Turing, and Standard ML.
The supposed advantages of Noweb 3 over Noweb 2 are:
- to be more portable and easier to install (perhaps in one binary);
- to be faster;
- to retain all the extensibility features;
- to document some of those third-party extensions.
The means to all these good ends is to replace the shell scripts and
the Icon code with the embedded language Lua-2.5+nw.
(This is Lua version 2.5 extended with 2 kinds of case statement.)
Contact: Norman Ramsey
Maths Problem Solving is a Windows based multimedia application
aimed at developing mathematical problem solving techniques in
14-16 year olds.
The application mainly consists of an MFC operating shell,
with plug in COM-based tools that the users interact with
to solve problems. We use Lua 3.0 to script the way the problems
are handled, and to control the interactive characters that
guide sers through the problem.
Using Lua in this way allows to develop the core
interactivity of the application very quickly.
Contact: Paul Dixon
Deli is a Lua extension to support Actors, a model for concurrent
computation in distributed systems. Deli extends Lua with functions like
to deal with actor creation and interaction in a distributed
Contact: Carlos Duarte
uCore is a integrated development enviroment for distributed business applications. It is primary developed for WIN32 but with several Unix platforms in target for server part.
The uCore Development Team
It consists of a core with the following modules:
A series of modules are written with uCore itself:
- Runtime environment (Compiler + Interpreter)
- Database Manager
- Network Manager (Including RPC)
- Windows Manager (Win32 Wrapper Library)
- DLL Manager (Plug-ins for interpreter)
- Database Designer (Tables + Relations + Triggers etc.)
- Network Server
- Applet Designer (Forms)
- Report Designer
- User Control
uCore will be used to create a series of distributed applications for the financial sector.
Lua 3.2 has been used as the basis for the compiler/interpreter.
All development are done by a team in Denmark.
Contact: Erik Hougaard
ImageKitchen: Solutions for Laboratory Visualization
ImageKitchen is a software package developed for Windows 95, 98, and NT
that automates the acquisition, processing, and presentation of image
information. Its modular design allows hardware to be interfaced easily,
and controlled via a built-in scripting language (Lua). Built in image
processing primitives of the scripting language allow powerful manipulation
of images. One, two, and three-dimensional display capability allows
immediate visualization and interaction with the processed image
information. The ImageKitchen environment and scripts interact to provide
rapid prototyping of experiments and presentation environments.
Photonic Systems Group, Beckman Institute of Advanced Technology
University of Illinois at Urbana-Champaign
Contact: Daniel Marks
Criterion Studios, headquartered in Guildford, England, is
a developer of 3D games.
We are using Lua as an embedded scripting language in an upcoming
action-strategy game. A number of Lua scripts control the high level
flow of the game. Using Lua allows us to easily save and restore the
game state, as well as significantly reducing the complexity of writing
the game logic. This makes the game more crash proof, and opens up the
writing of scripts to game designers and other non-programmers.
The game will be published on PC as well as next-generation console
Contact: Luc Van den Borre
WPartner is a development tool for CGI scripting.
WPartner utilizes Lua as one of its guest languages.
PERL and REXX are also supported, but Lua is the preferred language.
WPartner provides Lua with capability to build HTML output based on
templates. It means that your program code is not polluted with
"print" commands to generate HTML output and is much more readable than
usual CGI script. You do not need to change your program to modify
HTML output it produces. All you need is to modify HTML templates
containing program data placeholder. Templates are actually HTML files
that can be created and modified by any HTML editor.
WPartner provides Lua with SQL databases connectivity (both ODBC and
native). You can use embedded SQL straight in your Lua script and
even operate with LOB objects such as images.
WPartner's input parser dynamically creates program variables in the
user's script that correspond to the input parameters (form data or URL
data name-value pairs). Created variables are populated with the
appropriate values. You can use and reference input parameters by their
names assigned to them in the input form or URL. The input parser
handles "application/x-www-form-urlencoded" and "multipart/form-data"
WPartner provides file upload and download, mail (SMTP, Exchange...),
execution control, and many more capabilities
All active pages and sample programs on our site are enabled with Lua.
Contact: Vlad Serpik
Grim Fandango is a graphic adventure game that
uses a modified version of Lua 3.1 as its scripting language.
Grim Fandango was lauded by critics and adventure game fans as
one of the best games in its genre.
"A tremendous amount of the game was written in Lua",
according to Bret.
Contact: Bret Mogilefsky
Our work on an integrated software environment is motivated
by the observation that this is such a golden age for electronic imaging
system development that the capability to quickly and robustly develop and
test new imaging system concepts is more important than any single system
concept. With this in mind, we have developed an integrated Windows
software environment, named 3DImager. 3DImager encompasses image capture,
hardware control, and data processing. It is the intent of this software to
provide the user with the necessary tools for 3D data acquisition with real
time feedback to speed up the development process. This software can
control several pieces of hardware including a scientific grade CCD arrays,
digital I/O, piezo accuators, and translation stages. The user has the
option of controlling this hardware directly, which is useful during
alignment procedures, or one can place it under script control. The
scripting language is based on the Lua script engine.
The Lua language itself has been extended to
include control of all the hardware with the addition of image processing
routines and display functions. The scripting language is complimented by
macro support allowing the user to implement new features to the software
that were not thought of at design time.
The Computational Imaging Initiative, Beckman Institute of Advanced Technology
University of Illinois at Urbana-Champaign
Contact: David J. Brady
The Zeus for Windows programmers text editor has been specifically designed
for software developers working in the Windows 3.x, Windows 95 and Windows
NT environments. The Zeus text editor offers all the features of an IDE
(Integrated Development Environment) with the added benefit of providing an
powerful text editor that supports the Brief, Epsilon, WordStar and Emacs
new plugable scripting modules that allows you to write Zeus macro scripts
using the Python, Lua or Small C macro languages.
Contact: Jussi Jumppanen
a collection of software components which are
useful to create simulators based on partial differential equations.
The main idea of the package is modularity,
based on a pattern-oriented, bottom-up design.
As the development of graphical user
interfaces is a cumbersome task which takes a lot of time, we decided
to enable users to communicate with our codes based on an interpreted
scripting language. On demand, we plan to implement a GUI on top of
Lua. Among the large number of languages of this type, only Lua proved
to be simple, portable and powerful enough to meet our requirements.
Weierstrass Institute for Applied Analysis and Stochastics, Berlin
For a list of applications developed within this framework,
Contact: Jürgen Fuhrmann
Baldur's Gate is role-playing game (RPG) that
is scripted internally using Lua.
All debugging commands were
exposed to Lua and a Lua prompt exposed to the game.
This allowed complex debugging without spending much development time
making debugging tools.
Contact: Cameron Tofer
MDK2 is the sequel to the PC game
MDK2 runs on both the SEGA Dreamcast and the PC.
In MDK2, Lua is critical for game functions.
Lua's main purpose is its parsing ability.
Many file formats were scraped because
code/data could be parsed by Lua and read from the host.
The real-time debugging features were taken to another step with MDK2,
allowing for much more complicated tests. Even as far as prototyping.
The other main use of Lua in MDK2 is that most of the movie scripts,
AI scripts and time events are all done with Lua code.
Contact: Cameron Tofer
E-MAIL filtering, forwarding, etc. for large (250+ users)
alphanumeric paging commercial application.
Currently Lua substituted AWK scripts, and shell scripts.
Next phase is conversion of C programs to Lua,
interfacing to PostgreSQL,
followed by a full (Yes, Lua is fast enough!)
conversion of all our C programs to Lua.
Operating systems used are FreeBSD 3.2 STABLE and OpenBSD 2.5 CURRENT.
Lua's speed and footprint are awesome. :)
Contact: Karl Wagner
ClanLib is a cross-platform Game SDK written in C++.
ClanLib is under heavy development, but it has some stable versions.
It currently works on Linux, Win32 and BeOS.
ClanLib has support for Lua
and that makes it faster to develop games.
We chose Lua as scripting language to ClanLib because it is so fast.
Contact: Magnus Norddahl
This is educational software that we put together for
crack growth in dams.
We wanted to allow people to do a crack growth simulation on line.
We took the (FORTRAN) core of FRANC2D,
threw away the GUI,
and replaced it with a scripted interface implemented in Lua.
What happens is that the browser sends a message which runs a
CGI script, which writes a Lua script, and runs FRANC2D on the web
server. The results are then sent back as gif images. Not a very
sophisticated use of Lua, but it works well in this application.
Contact: Wash Wawrzynek
GameParts is an object-oriented lightweight application framework for
creating 2D games (mainly needed for coin-op/casino-games).
Games are made up of C++ base objects and VCL-controls (Delphi C++ Builder).
Some of those components are based on CDX
(a popular DirectX-wrapper/sprite engine).
Everything is controlled by Lua scripts, so most games can be done by
visual editing of forms and define control flow/logic/animation with Lua scripts.
Thanks to Lua and tolua there isn't a paradigm break between C++ and
scripting and Lua adds a lot of flexibility/versatility to the OO power of
C++ (in contrast to solutions based on COM/OLE automation, where passing
objects between scripts and C++ code is severely limited and code gets
Loewen Entertainment GmbH
Contact: Klaus Zerbe
Station 5 is intended as a shareware Internet game with
a highly configurable 3D engine called ENG32, featuring
an SDK, a custom Level Editor, scripting capabilities (Lua),
3D Studio Max integration and state of the art 3D rendering.
It targets mainly 3D game developers, who seek an engine
upon which they can build - the Station 5 game provides a
capability demo and a decent shareware game as well.
The project is mid sized, featuring about 50.000 lines of
C/C++ code and was designed and programmed by Harald Nowak.
Since it is still under development there are no regular
Lua was chosen as scripting language because of its ease
of integration, source availability and easy extensibility.
It is used to embed custom scripts in the levels for opening
doors, playing sounds, switching on/off lights, changing
polygon textures and performing other game relevant actions
like sending / processing various messages between the
moveable game entities (enemies, rotors, switches...)
The scripts can be entered in the custom Leveleditor.
Contact: Harald Nowak
Crazy Ivan was the robot that won the RoboCup 2000 in Denmark. Crazy Ivan has a "brain" that uses Lua for scripting language. All AI and logic is done in Lua.
The brain is running on a Motorola Coldfire 5206e processor, and Lua is modified to use only int's as the Coldfire has no FPU.
Contact: Erik Hougaard
LuaSpace is an environment for configuring and
reconfiguring component-based applications. The environment is composed
of a set of tools that offer support for dynamic reconfiguration. One
of these tools is a binding between Lua and CORBA - LuaOrb. The other
tools are based on Lua. The generic connector is a mechanism that
dynamically selects components for executing services required by an
application. Exploring this approach, an application can be configured
using a set of services without being aware of the specific componentes
that offer these services. The components will be selected on-the-fly
by the generic connector.
Computer Science Department, PUC-Rio
Contact: Thais Batista
A web browser plug-in and player for Lua with support for OpenGL.
Comes with a base class implementing a NewtonScript-like object model
as well as Foundation and Windowing toolkits.
Contact: Steve Dekorte
The project goal was to design a flexible system for
automatic configuration of network devices through ISDN (X.75).
We added data transfer functions to Lua and use it to perform communications
Lua gives us flexibility to support various types of devices and
We have chosen Lua because it is small, has great extension capabilities,
nice syntax, and proved to be reliable.
The system works as multi-threaded Windows NT service.
Contact: Maciej Maczynski
A plasma etch simulation was developed using Lua to allow users to modify the etch recipe, the structure being etched, or parameters of the simulator.
Contact: Fred Bertsch
Escape From Monkey Island is the fourth game in the
Monkey Island series of adventure games.
Like Grim Fandango, it uses a modified version of Lua as the scripting
Contact: Richard Sun
The Strategy Game Project is an effort to create an Open Source
Engine for Real-time strategy games. This Engine can be employed to create
real-time strategy games with very distinct look 'n' feel. As a part of
this Project, an example game (including client software, graphics and
maps) will be provided.
Lua is an excellent tool to create flexible and
efficient config files, engine modules and controlling
scripts for our project. Good work, Lua developers :)
Contact: Davor Ocelic
has purchased a new line of Intensive Care Unit monitoring system.
These new monitors are able to use de HL7 networking protocol.
We built a system to make the data from monitoring available on line in the Web.
And the Lua language was very useful.
The parser of Lua language was useful to extract data from text written by
the doctors as well lab results and convert this text in XML format.
Also we used Lua (in the form of CGILua) as HTML script for our Monitoring
An example of use of Lua tecnology in handheld devices used for Intensive
Care monitoring is shown in
from a presentation of Steve Balmer
(Microsof's CEO) during a meeting in Brazil.
Contact: Pedro Paulo de M. Oliveira Junior
U61 is a block-based game which uses Lua as a
scripting language. U61's main goal is to provide a solid framework for
creating new block-based games (some well-known block-based games are
Tetris, Columns or Puyo-Puyo...), while staying extensible with the
help of Lua. As Lua is easy and quick to learn, any player who has some
very basic programming skills should be able to create his own set of
rules and share it with his friends. U61 is free software, distributed
under the GPL.
Contact: Christian Mauduit
The CPC4400 is a hot-swappable Ethernet switch in a
CompactPCI 6U form factor. Lua is used to implement the CPC4400's
command-line interface (CLI). Writing the CLI in Lua was far more pleasant
and productive than if we had coded it in C or C++. Lua is also exposed as
the scripting language of the CPC4400. The user is able to associate events
(such as link status change, detection of topology changes, RMON alarms,
etc.) with Lua scripts. This allows the user to customize the behavior of
the CPC4400 to an unprecedented degree, and allows the CPC4400 to take
intelligent action based on the user's requirements.
Lua was chosen over other languages because of its small memory footprint,
efficient execution, ease of integrating with C code, and extensible
semantics. We're already on the cutting edge by providing an Ethernet
switching platform that incorporates a scripting language. But with Lua,
we're really pushing the envelope by giving end users a powerful
Contact: Performance Technologies, Inc.
FullMoon is a plugin for a popular 3D modeller called Moray, extending it with new objects written in Lua.
Objects are easy to write. The plugin provides an interface to Moray's API
that makes it easy to write code to perform the various operations needed to
obtain a fully functional object.
Contact: Andre de Leiradella
Soul Ride is a PC snowboarding game featuring expansive real-world terrain and physics-based gameplay and character animation.
We used stock Lua 3.2.2 in the engine as a configuration facility and console interface, and for scripting some game events. We dropped Lua into the engine late in development, and it proved to be simple, functional and headache-free.
Slingshot Game Technology
Contact: Thatcher Ulrich
Lune is a simple Multi User Dungeon (a text-based, multiplayer online role-playing game). I've been working on it since September 2000. It uses a modified Lua interpreter that provides a few functions for sockets, time, and directory listing. Other than that, the whole thing is written in Lua, including the data files. It currently runs on the Linux and Win32 platforms.
Contact: Jason Clow
FaME is a programmer's text file editor for Windows 9x and NT.
It is customizable and extendable by Lua scripts.
At the moment I have a German version available,
but I'm already working on an international version.
Contact: Florian Wolff
A shareware program for the RISC OS operating system that
allows you to graphically layout family trees. It uses Lua
as a scripting language to control the style in which people
and marriages are drawn.
Contact: Alex Waugh
The Extensible Web Portal project,
currently housed at http://lua.digital-scurf.org/,
is a project to eventually build
a good extensible ISAPI content generator based on Lua,
to allow people to write their web pages in Lua. (Much like
PHP does at the moment).
The main application for this, is Digital-Scurf's portal site,
which is constantly under development (although right now,
development is paused while we work on another important
project using Lua).
Contact: Daniel Silverstone and Robert Kendrick
A fantasy role playing game (Linux based), using Lua for two main purposes: character AI and world actions. Most of the actions that can affect the world can be scripted by overloading the hardcoded behavior with a Lua script.
The reasons for choosing Lua as a scripting language were mainly its speed and small memory footprint, secondary reasons being that it is a fully blown language with a neat syntax.
Contact: Vincent Penquerc'h
The Universal Game Haven (UGH) is a server and protocol
meant to facilitate network game play, particularly of the
bridge and chess variety. It is being built with the
following goals in mind:
- simple, textual protocol
- scalable to many rooms, many players per server
- can be distributed over multiple servers
- games written in Lua, to allow rapid development and
perhaps direct play of client-programmed games
Contact: Noam Zeilberger
Horus process incoming alarms from various sources: alarm transmitters, phone centers, GPS transmitters. It is mainly used for security centres in Europe (150+ sites).
We chose Lua because of it clear syntax, easy extension and reliability. We added a lot of NT core functions, a Dialogic board interface, SQLserver basic access, and redesigned the memory allocation subsystem.
The Lua interpreter is embedded in five modules of the Horus system: alarm supervisor, operator interface, remote command server, receiver and vocal server. Every module can be finely parametrized using Lua scripts, helping users sort false alarms.
Contact: Joel Jacob
DigiTest is a next-generation telephony network testing family of products.
Lua has been used extensively throughout for tasks such as user interfaces,
automated test scripts, and results analysis and was chosen for its speed,
small footprint and easy extensibility.
Lua has been linked with the Tollgrade Services Architecture (tm),
allowing scripts to be executed anywhere and at any time within a DigiTest network.
Contact: Todd Wade
SAGE is a computational system that executes the functions of
energy management in electrical power systems.
As SAGE fulfills a large number of functionalities, it is
by several programs. Some of these programs were implemented
the Lua language:
Conditional Register (RegCond) - Using Lua configurations files,
SAGE can be configured to log the values of some
SCADA variables, dumping them to ASCII files whenever
certain conditions are reached.
The configuration file is composed by a set object
descriptions (Lua table constructors)
which allows the configurator to deal with a
only-descritive syntax, legible to non-programmers.
SAGE Shell (SASh) - This is basically a Lua interpreter linked
with SAGE development libraries.
With this special interpreter, programers can easily write simple
scripts that access SAGE real-time database, command SCADA
and manage the system processes. The Lua/SAGE binding offers a
abstraction for the concepts involved in this kind of program.
As SASh is also linked with IUP/Lua, the scripts can
deal with graphical widgets (dialogs, buttons, menus, etc.).
Dynamic Calculator - Using the functionalities of the Lua parser
interpreter, SAGE offers a dynamic calculator where the
operator can easily set formulas that involve values and
at SCADA real-time database. These formulas are calculated
throughout the system execution and updated regulary,
thus offering the possibility to setup calculations that were
not previously expected to be needed; for example, in emergency
Contact: sage AT cepel.br
NebLUA is a Lua script server for the 3d engine The Nebula Device. It makes use of Lua 4.0 and TKLua to achieve a very full-featured scripting interface to The Nebula Device. It was developed for use in Logic Hole Software's independent game, Catalyst.
Logic Hole Software
The Nebula Device is a free full-featured 3d engine from Radon Labs, which they are using for their next commercial game, Nomads. It is cross platform between Linux, and Win9x and WinNT.
NebLUA is about 1500 lines of code, and took a single programmer about a
week to implement, knowing nothing about the Lua API or the Nebula API.
It makes use of most of Lua's API facilities, including tag methods,
garbage collection, and embedded c functions. Lua was chosen for this
project because of its speed, powerful language features, and ease of
embedding into the Nebula Device framework.
Contact: James Hearn
tomsrtbt is "The most Linux on one floppy disk" for:
rescue recovery panic & emergencies,
tools to keep in your shirt pockets,
whenever you can't use a hard drive.
Tomsrtbt includes a Lua interpreter with luasocket, md5, and regex libraries as well as vi and emacs editors, along with other tools. Utilities currently written in Lua include: wc unrpm-- undeb-- tee split login head grep dirname cut cmp basename dhcpcd--.
Contact: Tom Oehser
PlayCom is a complete game development system implemented in C++. It has full
support for 3D, physics, animation, music, audio fx and networking. All
aspects of the system are controllable from Lua. The system is used to
implement free (gratis) online multiplayer 3D games for Windows, Mac and
Contact: Lars Johan Rustemeier
GUPPY (Genetic Understanding Perspective Preview sYstem)
is a program for visualizing information
of sequence databases in molecular biology.
This program aims to accelerate computational tasks
for various studies in bioinformatics. Our current development involves
prototyping additional functions for some of active biological projects.
Lua language was embedded in this program in order to facilitate
data processing and scripting functions for layout of the
This program also features highly interactive operations for
smooth scrolling and zooming from the genomic landscape to discrete
nucleic acid sequences.
Contact: Yutaka Ueno
FEMM is a free magnetics finite element package for Windows.
It solves low frequency problems over 2D and axisymmetric
domains. The Lua scripting language integrated with FEMM,
allowing for batch runs, creation of animations, dynamic
simulations, and so on.
Contact: David Meeker
Doris is a script driven OpenGL viewer. Lua is bound to OpenGL, GLUT and GLUI so that graphical scripts can be written. The GLUI widget library provides a nice set of OpenGL implemented widgets for use from Lua. Designed to be portable and easy to use.
Contact: Nick Trout
allows you to control the Nikon Coolpix 990 digital camera.
It includes timelapse functions and download capabilities,
and includes scripting support with Lua:
you can write Lua programs to control the camera.
Contact: Charlie Wallace
Availix is a software suite used for managing and monitoring blade clusters
based on CompactPCI hardware.
The project size is about 85,000 lines of C code and 6,500 lines of Lua.
This a commercial project.
Lua is mainly used for extending our management and monitoring applications.
It is also used by the end user to change the default behavior of the system.
Lua is the only language light and simple which can be easily embedded into host
programs written in C. From our point of view it has no drawbacks.
Contact: Eric Mauger
Publique! is a web based content management system.
The information structure managed by Publique! can comprise
an entire HTML site or just part of it.
Publique! can also be used as an XML based web service or as an WML front end.
Publique! offers a workflow based on three user types or actors:
Authors, Editors and Readers.
There are currently more than 100 sites using Publique in Brazil,
Argentina, USA and Japan.
The current version (2.2) is available in Portuguese and English.
Japanese and Spanish versions are on the way.
Publique started in 1998
and has been developed by a team of 3 to 7 programmers during its lifetime.
The production team totals 30.
Publique uses a modified version of
as its current web engine and consists in almost 50K lines of Lua
and 5K line of C (not including CGILua itself).
Lua has been chosen for its ease of prototyping,
speed of execution and extensibility.
It is used for almost every feature in the system other than the OS Platform,
DBMS and Web Server abstraction layers.
Contact: André Carregal
In the UK the post office offers a discount for mailshots
over a certain size if they are sorted by delivery code -
not the same as postcode (zip code). Labelsort takes a file
of address labels, as would be sent to the printer, appends
the delivery code to each postcode, and sorts the file.
It works by having the post office data, listing for each
delivery code which postcodes it accepts, converted into
a Lua table. The table is indexed by initial letters of
postcodes and its values are tables, indexed by delivery
codes, of lists of patterns to match against postcodes.
Contact: Gavin Wraith
MCCI is a software IP development company, presently focused on USB. Our development tools are cross platform (both for compilation and for target system).
One of the big issues for a large commercial software project is cross-platform makes. We deliver software in source form and we need our customers to be able to build quickly. None of the previously available tools fit our needs; Lua was a key tool for solving this problem, and we now use it extensively internally and for customer deliveries.
We use Lua in the following ways:
- to write cross-platform portable scripts (so that we don't have to depend on 'sh' features that are not available on W32). In particular, this allows us to ship dependency checkers for third-party compilers without having to write C code, which is a great help.
- integrated into a slightly augmented version of NetBSD's make, upgraded to run directly on Win32 as well as on BSD and MacOS X (again, to provide a local compute engine that can be used by MAKE instead of having to call shell scripts and external tools)
- to write internal scripts
We started with 3.2; are in the process of upgrading to 4.0. A small amount of work was needed in 3.2 to make it easy to do items (1) and (3).
We also had to create an MCCI standard library for Lua (written in Lua), both to allow scripts to be cross platform (hiding the details of pathnames, env variables, etc.), and to enforce a certain level of consistency.
With our local changes and development, we spent about one labor month integrating Lua into our project.
We found the language admirably suited for this need,
and the interpreter shell (lua.c) and compiler shell (luac.c) were easy to modify to meet our local needs.
Contact: Terry Moore
Meldlua is a framework for scripting engines in Meldstar Studios' game projects. It is based on Lua 4.0 and uses a number of Meldstar only extensions. For our games, we build upon Meldlua to create the final scripting languages for each game. It is these final scripting languages that the level designers work with for extending their content.
We're also looking at using Lua for configuration files; however, that's a different story.
Contact: Christopher S. Charabaruk
Angband is a freeware computer dungeon exploration game based (loosely) on the books of J.R.R.Tolkien. You explore a very deep dungeon, kill monsters, try to equip yourself with the best weapons and armor you can find, and finally face Morgoth - "The Dark Enemy".
It is a highly portable game with versions available for Windows, MS-DOS, Linux, Amiga, RISC OS, Solaris, BSD, and many other systems. The source code for Angband (about 170,000 LOC) is freely available for non-commercial use.
Lua 4.0 is currently used in Angband to script the effects of magic spells and item use. The wrappers for the C functions and variables in the Angband game engine are created by tolua. Future Angband versions will extend the use of Lua to allow more customization of the gameplay.
Lua was chosen as the scripting language for Angband because of its small footprint, high portability, speed, and ease of use.
Contact: Robert Ruehlmann
Lixoo aims to be a fast, lightweight and extensible 2D
adventure game engine. Lixoo's core is composed by the scripting engine
provided by Lua, a plugin management system, and a minimal bunch of the
engine's generic routines. Almost everything is scriptable with Lua and
loadable as a plugin. This makes Lixoo extendable and a lot easier to port.
We use Lua because it compiles without changes in several platforms and
OSes, it's very fast and extremely small. Another interesting feature is
the ability to run precompiled chunks: this way game scripts can be
compiled to distribute final versions of the game.
Contact: Adrian Perez
ToME is a free roguelike game.
It is a very evolved and deep game that
started its life as a variant of Angband (of one of the variants
actually) and has now grown into a wildly new game.
ToME uses Lua to allow customization of the engine, new quests,
spells, powers, whatever.
A lot is customizable thanks to Lua,
and a lot more will be.
Lua was selected because of its portability,
smallness, clarity of syntax, tables and general neatness :)
Hands is a Brazilian software company that provides technology for
developing and deploying content, marketing and business applications to
mobile platforms like PDAs and Cell Phones.
Our PDA solution relies on a offline browser that uses Lua 4.0 as its
scripting language. Lua is also used to create dynamic pages based on a
internal relational database and some configuration scripts.
Other Hands Browser's nice features include:
- LuaSockets TCP/IP layer for HTTP, FTP and email support;
- MD5 encryption and decryption;
- XML/HTML content grabbing;
- XSLT formatting templates;
- Complete API for creating business and content PDA applications;
- Bitmap and animated GIF display;
- HTTP Sync capabilities;
- Available both for PalmOS and Windows/CE;
Lua was chosen because of its portability, speed, small footprint, and easy
of embedding into host programs written in C.
Contact: Renato Crivano
Psychonauts is an XBox Action/Adventure game from the mind of Tim Schafer.
All of Psychonauts Game logic is implemented via Lua. The Level
Designers use Maya to create the geometry for the levels, and then
place down markers for Lua controlled Script Entities. This includes
all non-player characters, platforms, puzzle pieces. Basically the game
engine boots up and places the main player into a static world. Lua
scripts then take over and control all interactive elements.
Lua is so light and fast! It is AWESOME!
Double Fine Productions
Contact: Dave Dixon
Emotion Engine is a 3d game engine based on plib for the 3d graphics, Lua for the scripting engine and xml for the world files. Originally the engines intent was to demo and create a tutorial on how to use plib for new game developers. This idea still stands but has now grown to a 3d Engine.
Currently the engine is very new and there are some design changes that have to be completed. This Engine is meant to help people get started and experiment. New developers are more than welcome, working together we can learn Engine
development. This is an engine ment for making mistakes, experimenting with ideas and most importantly learning and helping others.
Contact: Ben Woodhead
Digital Fusion is a fully integrated, non-linear
compositing and special effects post-production system for finishing,
design and effects creation, used extensively in many feature films,
HDTV productions, broadcast video, web-based/multimedia projects and
Lua forms the basis of 'DFScript', an integrated scripting language
added in Digital Fusion v4. This allows the automation of repetitive
tasks within the program, as well as facilitating integration into other
aspects of a post production facility, such as clip management, 3D
renderer integration, EDL/conform integration etc.
Contact: Peter Loveday
Lua was used as the language to handle all
interaction, cinematics and game logic for each level in the game.
Each game level had a Lua code file that contained all game logic,
dialogue, cinematic code, etc. for that particular level. The Lua
code files were pure Lua source and since Lua can compile at runtime,
we could edit our source and then tell the engine to reload the Lua
code file to test the changes without ever recompiling the game
HDB uses Lua for the PocketPC, PC and Linux versions. The Game Boy
Advance version's Lua code and interface was all converted to
straight C due to the extreme limitations of the GBA itself.
Contact: John Romero
ZIG is a C++ library for scripted, action-multiplayer game programming. It's intended to
be used directly for simple games, or as a starting point for the development of more sophisticated
Lua is the scripting language of ZIG. It was chosen because it's small, fast, and easy to use. Lua code
will be used in the client and in the server, for instance, to assemble and to parse the application-specific
part of network packets. This means that when you connect to a server with a newer version of the
software, and perhaps with a new protocol, you can just download the client Lua code and start talking
the new protocol, without having to update your game's native binaries. This empowers the game
developer to squeeze the last bit out of the game protocol and to make practical experiments with the
protocol, all without worrying about compatability with older versions
Contact: Fabio Reis Cecin
Monday is a collection of libraries and tools for the Dylan language. The Monday project uses Lua as the implementation and extension language for mmk, a specialized build tool for Monday's XML-based literate programs. (The mmk implementation also includes a Lua wrapper for libxml2.)
Contact: Peter S. Housel
ELinks is text-mode web browser which can have various hook
functions defined by the user in Lua. These hooks allow the user some degree
of customisation over the basic program. For example, a hook can be defined to
treat strings entered into a dialog box as terms to be searched for using a
search engine, rather than a URL.
Lua was chosen for its size, its string handling capabilities, and its relative
ease of learning for non-programmers.
Contact: Jonas Fonseca
Girder is a Windows automation tool. It can control most Window s applications. To trigger commands you can have many kinds of input devices, things like a simple keyboard, Infrared receiver, X-10, Internet you name it. Girder is extensivly used in the HTPC (Home Theatre PC) community.
Lua is the built-in scripting language in Girder that enables users to make complex commands. A plugin mechanism allows users to easily extend Lua, special commands give Lua the possibility to also trigger commands.
Contact: Ron Bessems
Inspired by Williams' Robotron and Smash T.V.,
MutantStorm is furious retro arcade gaming in a state of the art graphics environment
for gamers who want pure action...
Contact: Miles Visman
Impossible Creatures is a PC RTS (real time strategy)
game released on January 7th 2003.
The project has 100's of thousands of lines of code and was written
by ~8 programmers.
Lua contributed about 50,000 lines of that code.
Lua was used extensively in all aspects of the game.
It was used to configure almost every system and subsystem in the game.
It defined and controlled the UI, managed the AI,
and specified the look of the effects and other graphical entities.
It was used in tuning the game in realtime, for editing unit attributes,
processing the game rules, automation of tasks, and on and on.
Lua was chosen because of its speed,
its simple syntax and its ease to understand for both programmers and designers.
It was also easy to debug, modify and itegrate into our C++ game/ tools.
Contact: Shelby Hubick
The Brazilian Marines Warfare System (SJD - Sistema de Jogos Didáticos) is a
computer-assisted warfare gaming system designed to support the training of
Brazilian Marine officers.
The SJD provides a complex and fully integrated combat models required to
support Brazilian Marine exercises.
The major functional areas are ground combat, air operations, fire support,
ship-to-shore, logistics and engineering. The SJD uses digitized terrain
files for trafficability, cover, and elevation in the area of operations.
Either astronomical, weather and climate conditions can be described
with resultant effects on ground movement, air operations, and visibility.
Some modules of the game engine were wrote in Lua and
all user interfaces were developed in Lua with IUP/CD library.
Contact: Roberto de Beauclair Seixas
dZ80 is a freeware Z80/Z180/Z80GB disassembler for
binary files, such as arcade machine ROMs, Z80-based personal computer
snapshots. dZ80 now has scripting support. Writing a script for dZ80
allows you to override, or simply modify dZ80's existing handling of
opcodes. The scripting language used is Lua 4.0.
Contact: Mark Incley
Aranha is a powerful web-application-development platform. Lua was chosen to
drive it because Aranha needed a light-weight language which was easy for
non-programmers to use. We also like Lua because it is easy to extend and
offers many useful extensions.
The Lua community is a very effective way to get help and ideas on how to
improve on our project.
The Pepperfish Consortium
Contact: Daniel Silverstone
Spellscape is a 3d rpg/action computer game being developed by two computer science students in Warsaw, Poland. Almost all aspects of the game/scenario are controlled with Lua scripts - this includes game events, character AI, entity generation, visual fx, etc. Lua was chosen for its speed and easy integration with C/C++.
Codeminion Development Studios
Contact: Maciej Biedrzycki
The Plot Graphic Library (PGL) is a C++ charting library specifically designed for Visual C++ and MFC applications.
It is a complete solution for inserting 2D charting into your application.
Lua is built on top of a limited C API wrapper of the library.
Contact: Jonathan de Halleux
SilenceVST is a self-contained interactive language for programming music and
created by adding musical primitives written in
C++ to Lua. SilenceVST runs as a standalone GUI application, as a
standalone console application, and as a VST synthesizer or effect plugin.
Users can write new plugins for SilenceVST in any language with a C binding,
and such plugins automatically become part of the language.
SilenceVST contains a programmable score generator together with two
programmable software synthesizers. One, silence::Orchestra, is a new C++
synthesizer of my own design. The other is Csound version 4.23, embedded in
SilenceVST using the Csound API. SilenceVST comes with several plugin
opcodes, which also run in canonical Csound. These plugins include Jezar's
freeverb, Perry Cook's Synthesis Tool Kit (STK) physical modeling
instruments, and Peter Hanappe's iiwu SoundFont synthesizer.
Contact: Michael Gogins
Premake is a "build script generator".
Premake reads configuration files written in Lua and
can generate GNU makefiles,
MS Visual Studio 6 workspace and project files,
MS Visual Studio 7 solution and project files,
and more coming soon.
Contact: Jason Perkins
Lua and Perl6 Virtual Machine
A compiler that compiles Lua code to the new Virtual Machine for Perl6, which is currently being developed (current version is 0.0.9).
Bachelor's project for Computer Science at Hanzehogeschool Groningen, the Netherlands
Contact: Klaas-Jan Stol
We use Lua for several parts of the project. We first
chose it to be the language for mission scripting (triggers and other
stuff), but currently we use Lua for mission scripting, sound scripting,
data definition language, general preprocess tools and other uses.
Contact: Dirk Ringe
Harmony Assistant is powerful music notation and playing tool. It is now fully scripted by Lua 4.
Harmony includes a Lua text editor with syntax coloring, an Interface Composer to build interface objects with Lua methods, a Lua debugger with breakpoints, step, global and local variable windows.
Contact: Didier Guillion
Lua was used as the scripting language to drive the missions for this PlayStation 2 game title (also ported to XBox and GameCube). We used Lua to script all the mission specific game events and extended it heavily to call numerous C++ routines from the scripts.
Seven Studios, Los Angeles
Contact: John Keating
Monkey king II is the second game in the Monkey king
series of MMORPG games. We are using Lua 4.0 as the scripting interface for
the game UI and net protocol. It helps us to write flexible UI and can
extend the gameplay easily.
Contact: Cloud Wu
Lua has been used in APT-RPM to implement an extension system for the
APT-RPM libraries, allowing many interesting tasks that can't be easily
achieved using just the command line APT tools. With the scripting
capabilities provided by Lua and the Lua API offered by APT-RPM, more
advanced upgrading setups can easily be done, and it's possible to
customize operations to the user's taste.
A number of different languages were evaluated before Lua was
chosen as the scripting language for APT-RPM. Lua was chosen because
it's not a general purpose language. Lua is very small, fast, and
perfect for embedding. No other language compares to Lua in that
Contact: Gustavo Niemeyer
Blitzkrieg is a WWII real-time strategy game which implements Lua for scripting historical missions, as well as lets any player modify or create maps with a map editor using the Lua language.
Contact: Michael Allenson
KQ is a console-style RPG for the PC that runs on DOS,
Windows and Linux. Abandoned by its creator for personal reasons, the
project was rescued by the Allegro community, thanks to the wonders of
open-source software. In KQ, you control the destiny of any of eight
different characters on a search for a magical staff.
KQ has about 24000 lines of C source code and about 7000 lines of Lua
scripts, which are used to control map triggers and progress flags. There
are currently 10 KQ developers on sourceforge.net and thousands of users.
Contact: KQ Mailing List
APOCALYX is a simple open source 3D engine based on OpenGL and other free libraries. The engine includes simple features such as lens flares, sky boxes, flat and height field terrains, wavy surfaces, sprites, billboards, particles, 3D sound, compressed data management, MD3 models loader and animator, BSP levels loader, bumped materials, and Lua as a scripting language to describe and control the scenes without any recompilation. Features planned include the extension of the basic physics engine already available and more. The current implementation supports Win98 (or higher) with an accelerated graphic card installed and OpenGL drivers.
Contact: Leonardo Boselli
Arkhart is a Free (like in beer and speech, even the data, not just the code) (Multiplayer|Solo) RPG game in an original world called Arkhart.
It uses its own 3D engine, called Ark, and all the game will be written in Lua, since the engine takes care of everything else.
The engine itself is quite big (around ~50k lines of C++ code), and we are just starting to make the game... and we are always looking for talented people btw :)
Lua was chosen because it was small, easy to use and understand :)
DCPlaya is a multiformat music player for Dreamcast, very flexible and extendable, with strong visual aspects.
The whole GUI and many other aspects of DCPlaya were implemented in Lua, whereas all CPU usage critical tasks are implemented in C. Because Lua is used intensively on an embeded system with limited memory, we had to use a patched version of Lua 4.0 with incremental garbage collecting. (This is the version provided by Paul H. Liu.)
Contact: Vincent Penne
MusicMUD is a build-from-scratch mud codebase developed in the course of writing a mud (the Cryosphere). It uses Lua heavily, initially as a way to script events, but increasingly to implement commands and other more important parts. It's not just a toy mud, but a working one with over 40 missions and thousands of rooms.
Lua was chosen for the ease of integration, the nice clean syntax, and the fact it is sandboxable.
Used Lua on the server to script high-level behavior of entities and modules. Used Lua on the client for config stuff.
Contact: Curt Carpenter
We have selected Lua 5.0 as our scripting language for Lantern Games Chess.
All GUI elements are driven from Lua and the game's event handler
is a Lua function. We are very pleased with the way Lua has been working
for us, and we are continuing to find numerous ways to use Lua in our
Contact: Paul Schuytema
Project193 aims to create a robust, easy to use, general
purpose microcontroller with specific considerations given to educational
and robotics applications. Project 193 uses a Lua interpreter process
running in the microcontroller firmware, and Lua as the target programming
language for our language grammar translators.
Contact: Jeff McCune
Lua 5.0 is being incorporated into Meta-S, a parser generator, in order to allow reduction event code to be interpreted, rather than statically compiled. Since Meta-S grammars are already dynamic, the incorporation of Lua into Meta-S will finally allow parsers to be entirely defined fully at run-time.
Contact: Quinn Tyler Jackson
aXes comprises a web server, a terminal server, and a set of tools that
allow corporations to distribute existing AS/400 and iSeries
applications via a TCP/IP network using a web browser. The web server
component is called aXesW3 and the terminal server component is
called aXesTS. Multiple instances of each server can be active at the
same time. Commands are provided to start, stop and manage these
Tools are provided that allow developers to compress and decompress
stream files, and to create and run script files written in the Lua
language. These script files can be used to extend or customize the
operation of the aXesW3 server, and can be used to write new web-based
applications. The aXes implementation of Lua provides support for data
queues and SQL access to AS/400 and iSeries databases.
Contact: Bob Moore
PtokaX DC Hub is server application for Direct Connect P2P community. I've decided add scripting abilities on the end of 2002. Lua was exactly what I've been looking for. That time Direct Donnect was "powered" by Visual Basic server with VBScripting. These days more than 1400 servers out of 2200 use PtokaX and the Lua scripting popularity grows every day (check the
Contact: Zdenek Stangl
Lua 4.0 was integrated into the system that is used to monitor gas concentration levels during Space Shuttle launch operations. Launch personnel use Lua to perform some of the more tedious tasks such as long duration leak testing and statistical data collection. Lua was integrated into the Windows application that provides remote control of leak detection equipment installed at the launch pad. The remote control application provides hooks into Lua that allow a Lua script to gain access to the data collected and to issue commands to the leak detection equipment.
Lua was chosen mainly because it is an easy language to understand (a benefit for the launch personnel) and it is very easy to integrate into a project.
Contact: Charles Curley
FarCry uses Lua extensively for scripting all game events and AI/game logic,
both for single and multiplayer game,
and for realtime game editing.
Contact: Marco Corbetta
Verbi is a wxLua small application that gives all the conjugations for
Contact: Tiago Tresoldi
Lua-driven, image-searching kaleidoscope simulator.
Contact: Jim Bumgardner
Vendetta is an internet multiplayer videogame.
The client runs on Mac OS X, Linux, and Windows, and the server is FreeBSD.
We currently use Lua in each of the server-side sector processes -- Lua
controls every aspect of the "game" separately from the "engine" which just
handles physics and keeping things in sync across the network.
Lua has been a joy to work with for the most part. Initially debugging was
very difficult to get used to, as many typos of table members weren't
caught, but we got used to it and now have a better sense of debugging in
Lua. The best part is that our developer accounts can run Lua code in-game
and have the output returned to us as chat messages. Thus we can change
the AI behavior, create space stations and wormholes, and pretty much
modify any aspect of the universe while people are still playing.
We started with Lua 4, doing nothing but controlling behavior of the
non-player ships. Lua 5 came out shortly afterwards, and features like
coroutines were enough of a draw for us to scrap our entire server-side
code base and start over with almost everything written in Lua.
We plan to use Lua in even more aspects of the server, such as handling
logins and all database queries, and also on the clients for the user
interface and inventory code.
Contact: Andy Sloane
Gorky Zero is using Lua 4 for scripting AI, game logic and user interface. It was also used for realtime game debugging and tweaking.
Contact: Jacek Brzezinski
Homeworld2 is a space PC RTS game that uses Lua4 extensively in almost every aspect of the game, including the UI, AI, game rules, game flow, stats, game attributes, game tuning and automation.
Relic Entertainment Inc
Contact: Shelby Hubick
"Battle Mages" is a high-scale modern game that combines tactical strategy, quality role-playing system and original adventure elements. All game triggers, cinematic sequences and high-level magic effects are written using Lua 4. Lua is also heavily used for debugging purposes; in-game console fully incorporates Lua as its primary controlling language.
Contact: Alexey Scryabin
eGames Chess is a 3D chess. The Lua GUI handling from eGames Chess was expanded and more Lua interaction was introduced into our core system. Lua is very quickly becoming central to all of our projects.
Contact: Mark Manyen
Mikatron is a PC game currently under development that is inspired by the old Robotron arcade game. Mikatron uses Lua for enemy robot AI and general game configuration.
Contact: Mike DuVall
"Little Robots, Making Friends" is a party game
consisting of 12 mini-games and a main game area.
The game is being published by BBC Multimedia.
The project consists of a C++ base with Lua running all the game code;
we also used Lua for data description.
We chose Lua because it is small and fast; we wanted a minimal script
language without large CPU and memory overheads.
Using Lua allowed us to develop the game very rapidly and to prototype
new ideas quickly and safely. The project contains over 6000 lines of
Contact: Robert Anderberg
Lua 4 was used extensively and successfully in the
creation of the game at several levels. It was used to a significant
degree in GUI creation, event handling, load/save functionality,
parameter setup, scripting of maps and scenarios, object instantiation
and so forth. The versatility and flexibility of Lua allowed us to move
quickly when time was tight. It allowed us to tackle several fronts
with minimal resources and allowed the designers the ability to tweak
the game and change features on their own without much help. Due to
the success of Lua 4 on this project and other prototypes, we have
decided to fully commit ourselves to using Lua 5 and beyond for all our
Contact: Simon Roper
Enigma is a puzzle game, reminiscent of Oxyd and Rock'n'Roll.
We are making extensive use of Lua 4 and tolua: for configuration
files, for describing the graphical models and, most importantly,
for describing the levels.
Contact: Daniel Heck
Railway Mogul is a realtime 3D strategy game in which the player is challenged to build a successful profitable railroad empire.
All data, including the 2D Interface is fed to the game via Lua.
Contact: Aryan Mukherjee
(Aftermath Lua Plugin Engine)
is a tool for allowing plugin style mods for ALTAR Interactive's game
plugins in Lua using functions provided by ALPine which allow for
manipulation of the game data. ALPine can then apply a group of plugins
to the game data, allowing multiple plugins to be active at once.
Contact: Andrew Campbell
AutoPlay Media Studio 5.0 is a unique software tool which allows you to quickly create your own custom Windows software, autoplay/autorun CD/DVD ROMs, and interactive multimedia presentations. Simply drag and drop rich media content such as photos, video, audio, Macromedia Flash content, text, HTML, and more directly into your project.
You can tie it all together with a powerful freeform scripting engine based on the popular Lua language. This easy-to-understand scripting language features everything from "for, repeat and while" loops, to "if/else" conditions, functions, variables and tables (associative arrays). We've included a library of 350+ powerful actions (high level functions) along with built-in mathematical and Boolean evaluation. The point-and-click "Action Wizard" and "Code Wizard" make is easy enough that even complete novices can add powerful interactivity to their projects. Advanced developers will appreciate the color syntax highlighting, code completion, function highlighting, as-you-type action prototypes and Ctrl+Space function listings.
Contact: Brett Kapilik
The LuaVIEW toolkit embeds the Lua scripting language into the LabVIEW graphical data-flow language. It allows Lua scripts to be run inside the LabVIEW runtime. The Lua language can be enhanced with custom LabVIEW-implemented functions so that LabVIEW can be called and scripted. LuaVIEW also provides tools for architecting modular LabVIEW applications with improved error handling.
Contact: Albert-Jan Brouwer
CARA is a novel application for the interactive analysis and assignment of NMR spectra developed by the group of Prof. Dr. Kurt Wüthrich, winner of the Nobel price for chemistry 2002.
The software is written in C++, featuring an NMR object model accessible to Lua (which is statically linked).
Contact: Rochus Keller
Entropy is a space-trading game using a massively multiplayer server based economy and communication mode to let players interact and enjoy it's universe together, while enjoying the hassle free enviroment an offline game provides.
Lua is used mainly on the backend, at the server, to provide script for AI,
economy models, and describing equipment. All of those things need to be
simply changed by people that don't necessarilly understand programming due
to the expanding nature of the game. Lua functions bound with a healthy dose
of C functions results in fairly intuitive scripts. In addition, scripts are
sent to clients with patch server behaviour instructions (like updating the
client, changing the protocol, etc.).
Bearing in mind also that most of Entropy's content is procedurally
generated, scripting is a logical way to define elements that rely on
predictable yet unknown data, such as missions.
Added to that is the mud-like use of Lua to define server side how the game
reacts to player commands, such as say, /emote etc.
This also allows developers particularly powerful debugging commands.
Originally I was writing my own scripting system but why re-invent the
wheel? Lua is more feature packed and versatile than anything I could've
done in the time available to a game development cycle.
A novel embedded controller for CAMAC crates (racks of equipment conforming to IEEE-583 standard, widely used in nuclear physics applications) has been designed; a local Lua engine (based on version 4.0) allows stand-alone execution of scripts at startup or under user control. Support for sockets (from Luasocket), extensions for binary operators and more than 60 custom commands specific to the underlying hardware have been added.
We appreciated good performance and easy integration of the scripting engine.
Contact: Umberto Zanghieri
SIGONYTH DESERT ETERNITY is a planet of eternal desert. Most of this planet is covered with sand. It's occupied by human race called Welimars. In Welimars language Sigonyth means ETERNAL DESERT. Atmosphere on the planet is very hot what makes impossible to walk on desert without proper suits. Going to the desert without good clothes is dangerous for two reasons. High temperature makes human body to dehydrate fast what leads to death. Second danger are desert maggots hiding in the sand and mutated griffons flying in the air.
We are creating our original engine which is specially made for this game
(C++ and SDL).
We use Lua to make scripts that can be used to execute actions on every
part of game. For example:
Contact: Dawid Makowski
(Ar)gon (G)eneric (O)nline (N)etwork server - Mostly designed to be used to create MUDs, currently text-only, in the future it may include graphical MMORPGs. Has been in development for 2 years now, with only one programmer and no other staff. Lua is being used to allow "builders" to create "worlds" from within the server without having to write a single line of C.
Originally I had written my own script language for use with the server, but had a change of heart and swapped over to Lua for the following reasons: a) Developing and expanding my script language would have been another full-time project when ArGON takes up enough of my time already, b) Lua is widely used and therefore learning Lua is much more useful than learning yet another proprietary script language, c) Lua has more functionality than I could be bothered adding to mine, d) Lua is written in ANSI C, e) Is flexible and easily expanded, f) Out of all the other scripting languages I have looked at, it is by far the easiest to embed into software and use.
Contact: Jarratt Davis
Jukebox Virtual was the first commercial jukebox based on MP3 digital technology, fully developed in Brazil.
Lua contributed by being an easy and reliable way to develop dynamic menus to the complex setting system of the machine. Before the implementation of Lua in the Jukebox Virtual, the settings system of the machine took months to be developed. After Lua, we've rewritten the entire system in just a few days. Lua eliminated the compilation problem, since we didn't need to close and recompile the entire program after each modification.
Lua is also a very efficent tool to develop the advertisement system, which allow the user to program ad-banners, creating animations and simple visual effects in a simple way, using the VGM micro-engine that also implements the Lua technology and is designed to the game development market.
Thanks to Lua, the owner of a JBV can customize some properties of the program.
Vortex Entertainment / Eletrônica Vector - São Paulo - Brazil
Contact: Alexandre Ribeiro de Sá
Giggle is a renderman procedural DSO developed for the production of visual effects created for the film 'Troy'. This project required the rendering of scenes comprising tens of thousands of battling soldiers,in addition to complex city layouts and particle effects for flames, smoke and dust. The generation of all this geometry was handled almost exclusively at rendertime by Giggle.
The Moving Picture Company
Giggle's core functionality comprises approximately 40,000 lines of C++, written by 2 MPC programmers over the course of 9 months. This provides many capabilities including :
- loading of geometry, shaders, particle caches and a proprietary cache format for agent simulations.
- skinning and other geometry modifiers
- procedural geometry generation
- kd tree classes for
- geometry evaluators to perform ray intersections and closest point queries
The functionality is bound into Lua, providing a flexible scripting interface which allows it to be easily adapted to specific tasks. MPC initially chose Lua for its reputation for speed and efficiency as well as for the great simplicity of its API. It has subsequently proved itself through heavy use by a team of 16 or so CG artists and across a renderfarm of over 500 machines.
Since adoption, Giggle's use has been extended to other MPC feature pipelines, and coupled with an interactive interpreter and OpenGL preview renderer to provide interactive script development and debugging.
Contact: John Haddon
Painkiller is a first-person horror shooter, designed to satisfy a gamer's hunger for intense, fast-paced action.
Lua is used for game logic, AI, GUI and as a RPC in multiplayer.
Contact: Bartek Sokolowski
DCSH is a server (or hub) allowing communication between direct connect clients. It's very flexible and can be scripted with Lua.
MPT Discovery is a new generation of software used on CableTest's MPT Series Wiring Analyzers.
MPT Series Wiring Analyzers use computer controlled, state-of-the-art switching architecture to evaluate the functionality of complex electrical wiring systems.
The project was developed in Delphi and is using Lua 5.0 both to allow the user to perform complex scripting and, internally, for handling the product under test's configuration.
Contact: Marius Gheorghe
zeGraph is an object rendering system designed for scientific data visualization and yet can be used to create 3D arts in a broad scope. It is small, fast, and easy to use. Here is a summary of zeGraph features:
Light weighted and high performance;
Rendering 2D and 3D objects using Lua script;
Easy to construct scene and produce complex 3D image.
Utilities to create 3D shapes;
Offscreen image can be saved as JPEG, PNG, TIFF, and BMP;
Offscreen image can be used directly as texture;
Output to window for real time display or animation;
Creation of simple graphic user interface;
Array data manipulation;
Binary input and output of netCDF and HDF formats, GSHHS coastline, and any other formats;
XML parsing using Expat.
A very bizarre action game developed by the Argentine game development company Moraldo Games, in C++ and Lua. A web page about it is also available on http://games.moraldo.com.ar/randomedia.htm (only in spanish though). Lua was used for storing the animation information, program data, and also for managing the entire GUI.
Contact: H. Hernan Moraldo
Eressea is a play-by-email strategy game. While the bulk of the game is written in C, we use Lua to extend the gamecode and create different rule-sets for different worlds. We used luabind for making the bindings, which was straightforward and easy, even though our code was C, not C++.
The game uses a proprietary data format that is hard to edit, and by adding a Lua console to it, we've now got a great way to change data and make small corrections programmatically without having to rebuild the server code.
Contact: Enno Rehling
Frontrunner is a simulation of the Presidential election.
Frontrunner lets you jump into politics like you're out there kissing babies and shaking hands.
Lua is the main development language for the product. It controls the game flow, GUI interaction, AI and nearly every other aspect of the game.
This is our 3rd release using Lua.
Contact: Mark Manyen
StyleADVISOR is an institutional investment analysis
platform used in analyzing investment managers, funds, markets and
portfolios. Over 500 firms, including many of the worlds leading
financial institutions, use StyleADVISOR as part of their investment
Lua 5.0 was integrated into StyleADVISOR's 500,000+ lines of C++ to
provide end-user flexibility in generating reports. Lua allows the user
to script the generation of dynamic text within reports that comply with
various regulatory agency requirements. Lua was chosen for its ease of
embedding, powerful yet simple grammar, and speed.
Contact: Aaron Moore
A smooth scrolling 2D tile engine in Lua using OpenGL and ZEngine bindings. Originally the engine was all in C++, but after toying with Lua bindings for awhile I decided to go ahead and just try a full rewrite in Lua--it paid off. There's no noticable performance hit, the engine is more extensible, and new changes and additions are quick and painless. Eventually an actual game will be built on top of this technology--keep watching.
Contact: Kevin Watters
The Ribosome Builder Project
aims to simulate the dynamic behavior of the ribosomal translational
machinery. A secondary goal is the establishment of an open source project
for developing modular, reusable, portable and documented software components
and frameworks for structural and dynamical molecular modeling.
The core application is written in C++. For rapid prototyping and tool
development, the program provides a scripting interface implemented in Lua.
The Rbq-Lua API is a comprehensive and documented set of functions, organized
in different categories.
Contact: William Knight
Minions of Mirth is a Massivle Single Player RPG in development at Prairie Games. We chose Lua for our database configuration language because of its simplicity to embed. Thanks to all the Lua developers and supporters!!!!
Contact: Josh Ritter
Lua is used to provide a simple program for computing inequality coefficients (e.g. for wealth distribution and income distribution). Besides the usual coefficients (Gini, Atkinson, Hoover etc.) also an inequality coefficient based on the Kullback-Liebler-Redundancy (Actual redundancy is maximum entropy minus actual entropy) is computed as an average of two two Theil-Redundancies.
Contact: Goetz Kluge
Centaur Force is a tactical First Person/Third Person shooter set in 2005. The game will feature gameplay mixing Counter Strike, America's Army, and Rainbow Six.
Lua is used for scripting events, triggers, etc. Basically everything that
you would see in the game will be scripted via Lua + luabind.
FusionX Game Development Studio
Contact: Stephen Eckenrode
BCDC++ is a popular clone/mod of the most
popular Direct Connect peer-to-peer client, DC++. Due to the
huge amount of small feature requests, the main author -
BlackClaw - decided to add Lua support so non-C++-programmers
could implement those features themselves. Lua scripting is
now in use for colorization of chat lines (highlighting),
automated responses and even bots for DC-hubs (servers) that
lack scripting support.
Direct Connect P2P Community
Contact: Walter Doekes
The OpenSource Metaverse Project
aims to provide a virtual online environment, a
metaverse, where users can create what they choose on
the fly and add scripts dynamically into the world.
Lua was chosen for the role of secure scripting engine
because it is very easy to attach to C, provides a
tight control over what can and cant be executed, and
the Lua language itself is powerful and easy to use.
Lua is fast becoming a standard for in-game scripting
Contact: Hugh Perkins
TeleTrader Professional is a complete information and
analysis platform with quote data, news, charts and extensive
possibilities of technical analysis. Lua is currently used for simple
configuration tasks and transformations of some data sets. It is planned
to further enlarge its use within the project for various calculations
and probably in some form of macro language for Professional.
Contact: Bosko Ivanisevic
Yzis is a vi compatible editor, which provides a reusable vi-engine, a ncurses based vi, a KDE based vi and a vi component for the KDE project.
We use Lua as the scripting language.
Contact: Philippe Fremy
Quest3D has an extra building block so that Lua scripts can be used to program logic in the Quest3D software. Quest3D can be used to create virtual reality productions using real-time 3D techniques.
Contact: Edward Niewold
SciTE is a SCIntilla based Text Editor.
Originally built to demonstrate Scintilla,
it has grown to be a generally useful editor with facilities
for building and running programs.
It is best used for jobs with simple configurations.
SciTE features a lot of modern editor features
(most provided by Scintilla)
like syntax highlighting of code,
call tips, autocompletion of code, folding, etc.
Since version 1.60,
Lua can be used to perform operations on the current buffer,
using the full API of the Scintilla component.
Contact: Neil Hodgson
Lumo is a 3D middleware for use in complex virtual environments. It is used for medical, training & simulation and entertainment. Lua is used as a programmable shader pipeline for the global illumination simulator next to HLSL of DirectX and GLSL of OpenGL.
Keep IT Simple Software
Contact: info AT keepitsimple.nl
We used Lua 5.0 with our own C++ wrapper to drive the games logic. We
chose Lua because of its easy integration and robustness. We have never
experienced any performance issues and could have build the scene graph
entirely by script what was abandoned due to schedule issues.
bhv Software GmbH & Co. KG, Germany
Contact: Phil K
Mini Golf construction. Uses Lua 5.0 for many things including AI control, GUI and setup and game event handling.
This is our 4th shipped product using Lua.
Contact: Mark Manyen
Arcade style childrens game. We use Lua 5.0 in our
engine's console window for debugging, and also for light scripting of
game events. Other games from us,
Care Bears Lets Have a Ball
The Incredibles: When Danger Calls,
use Lua in the same fashion.
Contact: Brian Weed
Moho is a 2D vector-based cartoon animation application for use by hobbyist animators as well as professional studios.
Moho uses Lua 5.0.2 to implement all of its drawing and animation tools. Lua is also used to create "plug-in" menu commands, allowing users to extend Moho with special drawing and animation effects. Lua extensions to Moho have the ability to repsond to mouse, keyboard, and pressure-sensitive tablet events, as well as create and manage GUI elements in the program.
Lua was a great choice for this project because of its speed and the ease with which it can be integrated with C++ code.
Contact: Mike Clifton
Setup Factory 7.0 is a Windows software development
tool for creating compact software installers for deployment via web,
email, LAN, CD, DVD and floppy disk. Its compact single-file setup
creates little runtime overhead (~450KB including uninstall) making it
fast and easy to initialize and install. It uses Lua 5.0 as a scripting
language to control and customize the installation process.
Contact: Brett Kapilik
An gimp 2.x plug-in for prototyping image processing algorithms in Lua. Available as source and precompiled for win32.
Gjøvik University College
Contact: Øyvind Kolås
Nut/OS Configurator is a GUI application for
configuring an RTOS and TCP/IP stack for tiny embedded systems.
It's based on the eCos Configuration Tool, but uses Lua as its
embedded scripting language.
Contact: Harald Kipp
Lua is being used as the "Triggers" language of the Game Map Editor,
similar to "Never Winter Nights". The Map Editor will be the heart of Legend Alive and will be released to players, in a more practical version, different from the Developer version that we are currently using.
Contact: Marcelo M. Prado
Lock On: Flaming Cliffs is a modern air combat simulator. Currently it uses Lua for configuration files parsing and for dynamic data export/import. Our advanced users make scripted LuaSocket network connections between Lock On and their custom cockpit instruments software. We also intend to use Lua in our future projects for UI implementation, for AI scripting, for data base processing, etc.
Contact: Valery Blazhnov
XVP is a 3D Visualization Toolkit for games and other applications requiring graphics, sound, input and network support. Lua fits into the package by offering a console at runtime that can be used to dynamically affect the engine by modifying settings, displaying debug information, etc.
Lua was chosen because of its speed, ease of use and proven abilities in the game industry.
Contact: Lynn Duke
FlatOut uses slightly modified Lua 5.0 for
configuration data and GUI. Total Lua code is around 50000 lines
(including config files).
FlatOut was developed for PC, Xbox and PS2.
Bugbear Entertainment Ltd.
Contact: Mikko Sivulainen
Simulators use Lua for configuration files and other scripting needs. The training simulators
have their operator/instructor view almost completely
implemented using Lua combined with wxWidgets GUI library
glued together with wxLua. The exercise control in
training simulators is also Lua based.
Team Simrac Finland Oy / Eepsoft Oy
Contact: Eero Pajarre
GoElemental! is an interactive open-air project in the city of Bath, UK
based around the periodic table of elements. Users use cellphones to text in
the name of an element and an informative movie about the element plays
projected onto a wall above.
As well as being used for the base logic of the project Lua was used to
handle interactions with a cellphone, sending and receiving SMS'es using AT
commands over a serial connection. Lua's flexibility allowed quick
prototyping and testing, and allowed an easy transition to more structured
The code was developed in San Francisco, CA, and the test system in the UK
didn't have a full C++ dev environment so embedding Lua allowed a great deal
of flexibility, most development moving out of C++ into Lua fairly quickly.
Using Lua 5.0.2 as it was current when the project was started. One coder, a
month or so of time, and it's probably much smaller than many of the other
projects on the uses page.
Contact: Peter Bradshaw
Ughly is a remake of old DOS game called "UGH!".
Ughly was designed to have two features: flexibility and backward compatibility.
Flexibility was provided by the Lua script language. All significant variables like gravity factor or taxi draught are defined in a Lua configuration file. Maps are described with meta-language, designed to be easily comprehended by non-programmers. Also particle effects are defined in external *.pef files, utilizing Lua.
Contact: Konstanty Kalicki
An implementation of the Lua programming language
(version 4), with a GUI, editor and support for dbf files. This
distribution also includes a character mode version of the interpreter
with support for the dbf and date functions. Open plugin architecture
allows for extension of the functionality provided.
Contact: Kenneth Camargo
A modular and extendable SIP proxy (RFC 3261) that has script support through Lua. Lua is mainly supposed to add more dynamic routing capabilities (also on a per user base) but can be used in any prepared component. The Lua virtual machine is also seen as a base on which other languages may be build. An useful example for this would be CPL (Call Processing Language).
Lua has been choosen because of its easy interface for extensions, customization and integration into the application, its platform independence, its small size and because it is a technically mature, used software.
Contact: Heiko Bennewitz
LuaMat is dedicated to Image Processing. It includes image io, visualization, matrix linear algebra, morphology, edges detection and segmentation functions. It works with images in bytes or in floating points, 1, 2 (complex images) or 3 channels. First developed for rapid prototyping of Photoshop and DirectX filters, the design is now oriented to a general purpose image processing language. LuaMat uses Lua 5.1 and the OpenCV library. It runs as a stand-alone interpreter under Windows.
Lua was chosen for its speed and for its powerful simplicity. LuaMat is still under development (integration of others algorithms).
Hunter Dan's Bowfishing Survival Gauntlet is a
first-person bowfishing game where the player can explore and fish in three detailed environments inluding an exotic tropical island, and an overgown stretch of the Amazon. Hunter Dan's Bowfishing Survival
Gauntlet uses Lua to provide access to much of the engine's functionality.
Scripted sequences, end-of-game conditions and the menu interface are all
specified in Lua. Lua was chosen for its lightweight nature, ease of
use, and overall
Contact: Matthew Harmon
Fish Fillets NG is a Linux port of wonderful puzzle game.
Lua is mainly used to drive animation in 70 game levels.
There are 70,000 lines of Lua code (including level description and dialogs).
Contact: Ivo Danihelka
Daimonin is a free Massively Multiplayer Online Roleplaying Game (MMORPG). The development team is currently about 10 people, including developers, artists and others. We have a several thousands registered players and about 100 on-line players at peak times.
We aim to be a fun and free alternative to commercial MMORPGs.
The server is about 125.000 lines of C code, and 3.000 lines of Lua code (expected to increase as we extend the game world).
Lua 5.0 has recently replaced Python as the scripting language for NPCs, quests and interactive maps. We chose Lua because of it is lightweight, simple and higly customisable.
Contact: Michael Toennis
FreePOPs is an easily extensible program, which allows
access to the most varied resources through the POP3
protocol. Mainly, it can be used to download mail from the most famous
webmails, but it could also be used as an aggregator for RSS feeds
and much more. This way it is possible to get all your messages in your
favourite email client. While the mechanisms
are implemented in C the policies are coded in Lua.
Contact: Enrico Tassi
Love Invaders is a free game which we at Steambird hope you will enjoy! Re-enact the famous "battle of '78" in space with your alien friends. Simple to play, in classic style. How high a score can you reach?
Love Invaders uses Lua 5 for 100% of the game-specific code (plus localization data and a thick utility layer) implemented over a generic C engine.
Contact: Adam D. Moss
Sprite Studio 32 is a new, paradigm-shifting
Multimedia Authoring Environment that empowers you to create image-rich
content for the Desktop, World Wide Web and QuickTime.
Simply drag-n-drop Image, Animation, Sound, Font and Movie assets, plus
Built-In and QuickTime Effects and even "Pre-Fab" Items such as
buttons, check boxes, menus and more to quickly create Sprites,
Entities and even complete Scenes which you can then arrange and
configure to design and layout multimedia experiences from quite simple
to very sophisticated.
Orchestrate these elements, their behaviors and interactions (with each
other and users) with the power of Lua Scripting. Sprite Studio has
fully integrated Lua as its native scripting language of choice. And
with over 550+ API calls you can make in your Lua Scripts to the
internal Sprite Engine, there is virtually no interactive Desktop
experience or Web or QuickTime animation that cannot be created with
Contact: Ando Sonenblick
libTAP is a simulation prototyping system for Virtual Reality and Augmented Reality applications. It is platform independent and completly scriptable with Lua. The goal is a highly flexible and easy deployable system with a small but distinctive feature set.
Contact: Hartmut Seichter
SafeKit is a software-only high availability solution with network load balancing, real time file replication and automatic failover. Our technology makes it possible to render any application available 24 hours per day. With no extra hardware: just use your existing servers and install this software-only solution available on Windows, Linux,
AIX and Solaris.
Interfaced with an xml library, Lua is used as a generic preprocessor language (rewritting HTML user configuration to xml SafeKit configuration, dynamic and hotplugable cgi,...). Lua 5.0 was chosen because of its expressiveness, portability, and easy of embedding into host programs written in C.
Contact: Philippe Boinot
TrueUpdate 2.0 is a software tool by Indigo Rose Software. It is designed to facilitate the process of creating and managing patch delivery and dynamic update systems. A few typical applications of TrueUpdate include developers adding "update from web" capability to their applications, network administrators automating patching processes, software manufacturers embedding update functionality into software, and many more. TrueUpdate uses Lua 5.0 as a scripting language to control and customize the update process.
Contact: Brett Kapilik
Gaia brings the functionality of an operating system to physical spaces. Common operating system functions are supported, such as events, signals, file system, security, processes, process groups, etc. Gaia extends typical operating system concepts to include context, location awareness, mobile computing devices and actuators like door locks and light switches. We are investigating how to build applications in a generic way that make no assumptions about the current hardware setup of a space - applications can be built and then deployed in spaces with different configurations, using the available resources.
Lua is used to start various services of Gaia and applications.
Contact: Chetan Shiva Shankar
Free 3D game development engine and SDK that uses Lua for scripting.
Contact: Martin Schlingmann
After fiddling and futzing with a few little gaming
projects for a little while, I decided it was time to streamline the
process. It shouldn't take years to develop a small to medium sized
game. So, combining the Allegro game programming library with Lua seemed
like a natural marriage. Many game engines (Allegro and SDL, to name a
couple) have already been integrated with various other scripting
languages. Unfortunately, it's usually a call-for-call conversion,
offering little more benefit than programming without compiling, not to
mention that the scripts are rarely, if ever, integrated into an
executable, thus requiring distrobution of the scripting language along
with the program. Because of the call-for-call nature, the scripted
programs were significantly slower than their compiled counterparts.
This seemed very archaic. So I combined script loading from the
executable, hardcoded functions for common gaming activities (sprite
loading, manipulation, physics, etc.), proprietary compresed images with
full alpha transparency (which can be displayed in fully blended 32-bit
color, or crosshatched bitmap conversions for speed improvement on
slower machines, and both in a variety of blending modes, such as
additive, subtractive, alpha, etc.), and other features that traditional
2D consoles and arcade machines applied in the past. Instead of offering
the programmer complete control of the input/logic/render/output flow, I
opted instead to create specific functions for handling the intricate
details that are most commonly used in 2D games, so the programmer's
effort is minimal at best. Of course, the engine can be extended with
C/C++ for additional functionality, but the overall design was to limit
the programmer to using the included functions and abilities, albeit not
at all limiting. So far, Lua's been a DREAM to work with, as it's so
easy to integrate. And the fact that it's so compact is a blessing in
and of itself! So thank you SO much for Lua, it's the perfect
embedding/extending an application.
Contact: Daniel Kinney
LuaBREW is the Lua Virtual Machine ported to Qualcomm`s BREW platform.
It is currently being used by the "VIVO em Ação 2 - Quebra Senhas" game, available on more than 15 commercial devices.
Contact: Reinaldo Mello
Lantern Games Checkers Ultimate is an action-packed 3D checkers game
that features Lua as its scripting base. Lua controlled the AI,
interface, and even the positioning of the 3D models. Scripting in Lua
provided the perfect tool for this undertaking.
Contact: Paul Schuytema
Lantern Games Air Hockey Adrenaline employs Lua in order to provide a 3D
environment that simulates tabletop air hockey. Nearly everything (other
than the physics and the online technical elements) is driven by Lua
scripts. Lua is truly a crucial piece of this game.
Contact: Paul Schuytema
Lantern Games Foosball follows the line of our other tabletop game
projects. With the GUI elements, models, and opponent logic managed by
the Lua scripting language, we have come to recognize Lua's massive
capability as a development tool.
Contact: Paul Schuytema
Lantern Games Shuffleboard Showdown simulates the exciting realm
of tabletop shuffleboard. Once again, Lua handled the game events,
interface menus, and the artificial intelligence. Lua is the primary
development language for this project, and it has become the main
scripting language of our development team.
Contact: Paul Schuytema
eGames Mahjongg Master 6 uses Lua in a variety of ways. Lua-driven
programming manipulates the game menus and allows for the selection of
various tile sets and backgrounds. Lua also proves to be an excellent
tool for attending to game events. With the completion of this project,
our company has developed over 15 games with Lua as a crucial element.
Contact: Paul Schuytema
Lantern Games Video Poker relies almost exclusively on Lua scripting.
Its GUI management, game flow, and game event factors are fully
controlled by Lua. This project truly represents the many talents that
Lua exhibits. The complete version of this game is available for free
download at our website.
Contact: Paul Schuytema
Lua, once again, is the primary scripting language selected for our
latest game project - eGames Riverboat Slots. Lua scripts handle the
content behind C++ triggered events and assist in the placement of 3D
models. Lua also helps to logically organize GUI interfaces and saved
Contact: Paul Schuytema
eGames Health & Fitness Club Tycoon is a comprehensive look at building,
creating, and managing your very own health club. Lua was selected for
this project because it easily allowed for the handling of game events,
GUI interfacing, and saved game data. Lua's flexibility and power made
it the perfect candidate for this project.
Contact: Paul Schuytema
Magic Lantern Video Game Tycoon is a tycoon-based simulation that
follows the daily routine of a video game development company. From
start to finish, every aspect of game developing is included. Lua
functions to handle the game events, manage the interactive GUIs, and
logically organize the game data. We have completed over ten projects
using Lua as the scripting base.
Contact: Paul Schuytema
In eGames Vegas Casino Challenge, Lua is the exclusive language used
for the scripting development. The game includes 7 different poker
games, 60 3D slot machines, Video Poker, and Blackjack. Each portion of
this project employed Lua to a large extent, and the finished product
is a demonstration of Lua's strength. We have utilized Lua in over 15
Contact: Paul Schuytema
Lua was selected for eGames Video Blackjack for its management of GUI
interfaces, events, and nearly every other aspect of its operation.
Through cooperation with a C++ base, the Lua scripting in eGames Video
Blackjack provides a truly entertaining experience.
Contact: Paul Schuytema
Our research group has developed an integrated, user-friendly, open-source software program (called iDMC), for the analysis of dynamical models. It allows the user to easily perform the routines on models included in the program or any model formulated by the user and easily encoded, without recompiling. The latter feature is due to the use of the Lua language for reading the models and please accept our sincerest gratitude for having developed such a wonderful tool for research.
Contact: M. Lines
Meetro is a dyanmic social network based on your physical location. Within the Meetro client there are various plugins for other popular instant messengers such as AIM & ICQ. These are all done using Lua. There are other internal tools using Lua as well.
Contact: Paul Bragiel
This 3rd person action adventure for Playstation 2, developed for the
past four years by VIS entertainment, takes the player through a
magical fantasy world rich in life and character. From the start the
design centered around a large world, with no loading screens or other
obvious transitions. Lua 4 (and then later 5) was used to script the
mammoth task of loading and unloading assets as the player moved
around the game world. After integration, it became apparent just how
flexible and useful Lua was, and it was used to provide the high level
glue for all of the content in the game. New characters, environment
aspects and gameplay elements were all integrated using Lua. The game
finally shipped with a work in progress version of Lua 5.1, which
despite not being an official release, was more than stable enough
over time and provided much needed incremental garbage collection.
Contact: Chris Chapman
Aleph One is an open-source descendant of Bungie's "Marathon 2" first-person 3D shooting game. Lua scripting was added to allow 3rd party scenario designers greater control over gameplay, allowing them to extend
the engine without the need to make their own custom builds.
Contact: Aleph One Dev List
Underworld Adventures is a project to recreate
Ultima Underworld 1 on modern operating systems, using the original game files.
It uses OpenGL for 3D graphics, the SDL library for platform specific tasks, and Lua for scripting.
Contact: Michael Fink
Intellipool Network Monitor is a commercial Network Monitoring platform that uses Lua to enable customers to extend Intellipool Network Monitor with custom made agents, actions and events. The Lua IDE developed by Intellipool AB can be downloaded free of charge from our site.
Contact: Robert Aronsson
The Optimized Sparse Kernel Interface (OSKI) Library is a collection of low-level C primitives that provide automatically tuned computational kernels on sparse matrices, for use by the developers of solver libraries and scientific computing applications. The kernels include sparse matrix-vector multiply (SpMV) and sparse triangular solve (among others), and are tuned for a particular input matrix and machine. Although conventional implementations of kernels like SpMV have historically run at 10% or less of machine peak on cache-based superscalar machines, OSKI's implementations can achieve as much as 31% of peak speed, and can be as much as 4x faster. We are using Lua as a way to express the tuning transformations between the library and the user.
Contact: Rich Vuduc
MySQL Migration Toolkit is an extensible toolkit for migrating databases
to MySQL. It can migrate from Oracle, MS Access and MS SQL, but support
for new systems can be added through plugins written in a variety of
languages, including Java, PHP, Lua and C. Lua is used to script the
runtime system, managing plugins and coordinating the migration process.
The runtime system is designed to be generic and will be used in many
other MySQL tools.
Contact: Alfredo Kojima
The Mira Pro Script Module adds a scripted quantitative image processing facility to the Mira software platform used in science & enineering applications. Pro Script accesses Mira's extensive internal libraries to allow the user to create procedures, ranging from simple to complex, for processing, measuring, and analyzing quantitative image data. Within the Mira environment, Pro Script employs Lua as a powerful, yet easy to learn and use scripting language that leverages an object oriented library containing dozens of classes and more than 600 methods.
Contact: Michael Newberry
Our TileEngine is an isometric tile based game engine
written in C++. The Lua scripting functionality allows us to remove the
gameplay from the engine and allow the (non programmer) level editors
create the game story and flow.
Contact: Beric Holt
Lua Player helps programmer newbies to write their own games in Lua. It provides some game related functions, like image loading and blitting and is available for Sony's Playstation Portable and perhaps later for other platforms.
Contact: Frank Buss
Blue Frog is the key element in Blue Security's Active Deterrence Technology. Additional information can be found at http://www.bluesecurity.com .
HTTP scripting is at the heart of the Blue Frog client. The architecture consists on a CURL based HTTP client engine (with Zlib and OpenSSL), that is scriptable through Lua scripts using an internally developed glue library. The operation mode is asynchronous with callbacks into Lua code from native code. Effort has been put into implementing a sandbox Lua environment that is isolated from any local IO related operations on the running machine.
Contact: Shmulik Regev
Kepler is both a project and a Lua Web development platform. The Kepler Project is building a set of Lua 5.0 components that together make the Kepler Platform.
Kepler offers the same advantages of Lua:
it is is Simple, Portable, Light and Extensible (SIMPLE) .
The Kepler Platform consists of the Windows, Linux and OSX distribution of the components that allow the creation of Web Applications and the use of SQL, LDAP, XML, SOAP etc.
Contact: André Carregal
DogLua is a scriptable filter for Project Dogwaffle, a painting and animation tool by Dan Ritchie. It provides an environment for experimenting with image processing algorithms, using Lua as the scripting language. DogLua is largely inspired by gluas, by Oyvind Kolas, and tries to be as compatible as possible with it, providing a similar syntax.
Contact: Marco Pontello
Afrika is an operational level wargame that covers the war in the Western Desert from 1940 until 1942. Afrika has an extensible AI system that uses scripts written in the Lua programming language.
Lua was chosen over rival scripting languages because of the small size of, and the ease of embedding its interpreter; the non-viral nature of its free licence; and the straightforwardness of the language itself.
Mike Kreuzer Games
Contact: Mike Kreuzer
Zlash is an ActionScript decompiler/compiler for .swf Flash files.
It is mainly programmed in Lua and has several thousands of lines of code written in this language.
It makes use of the C++ Fox toolkit for GUI, and uses a custom binding to Lua for it.
Zlash is closed source, but the Fox binding is part of the srtti project (on luaforge) and open source.
Contact: Vincent Penne
"There" is an online getaway where you can hang out with your friends
and meet new ones --
all in a lush 3D environment that's yours to explore and help build.
The game is written mostly in C++,
served mostly from a scalable Linux cluster,
with additional customization using ThereScript,
which is Lua plus added functions.
Rita is a MacOS X drawing program that uses an
infinite canvas. You can zoom and pan without ever reaching an edge or
encountering big blocky pixels.
Rita uses Lua for its pen definition files. New pen types (such as an
arrow or table drawer) can be added to Rita with Lua scripts.
Contact: Niklas Frykholm
This Plug-In is for the painting program Artweaver. It provides an environment for experimenting with image processing algorithms, using Lua as the scripting language. The Plug-In is inspired by DogLua (by Marco Pontello) and gluas (by Oyvind Kolas) and it is compatible with their syntax.
Contact: Boris Eyrich
Dednat4 is a TeX preprocessor to typeset deduction trees and 2D
diagrams. It reads a .tex file, interprets some lines starting with
"%" (which TeX treats as comments) in special ways, as 2D
representations of deduction trees and diagrams, and generates TeX
code to typeset these trees and diagrams.
The "little language" that dednat4 uses for specifying 2D diagrams is
a stack-based language inspired by Forth. Arrows between nodes are
drawn using a Forth-like syntax, but the creation and
positioning of nodes are usually done using Forth-ish words that mean
"treat the rest of the line as part of a 2D grid, and treat each word
in the grid that is over a cell having both horizontal and vertical
coordinates as a declaration of node".
Words in the Forth-ish language are defined in Lua, and lines starting
with "%L" in the TeX file are treated as Lua code and executed; this
makes the system very simple and easy to extend.
Contact: Eduardo Ochs
BlogMe is an extensible language for generating HTML that has a very
simple syntax: only square brackets and whitespace are considered
special characters. Its "evaluator" consists of about 100 lines of Lua
code, and its design was inspired by Tcl, Forth, and Lisp.
Contact: Eduardo Ochs
TEKlib is a library and operating system effort.
It runs hosted on platforms such as Unix and Windows,
it can serve as a freestanding operating system on architectures
such as the Playstation 2, and it is a middleware providing a
constistent interface across all hosting environments. Its
freestanding nature, small footprint and absence of global data
recommend it as a layer for portability and code reuse in
heterogeneous environments; TEKlib's role is that of a local or
logical operating system, allowing for deployment inside applications
likewise as on top of hardware.
Lua is provided in the form of a native TEKlib module, which allows for easy embedding of scripting hosts into any kind of TEKlib application; its scope has been extended with a 'tek' library, which operates in TEKlib's own filesystem and offers improved filesystem semantics and utilties for argument parsing.
TEKlib's website is served by a TEKlib application running a Lua script.
Contact: Timm S. Mueller
InkSpector is a Sinclair ZX Spectrum emulator screensaver
for Windows, where each Spectrum appears as a 3D television model with its
display appearing on the TV's screen. These models are manipulated by Lua 5
scripts that run the show. Using the supplied documentation, new scripts can
be written and added to the ones supplied with InkSpector.
Contact: Mark Incley
RM-X supports a plugin interface which can dynamically
add and remove C functions at run time to its Lua implementation.
Scripts can then be called either from user interaction, called from
various plugins, or even by other application on the same system (using
an IPC connection) or remotely (using a TCP connection).
Contact: Darkain Dragoon
monotone is a free distributed version control system. It
provides a simple, single-file transactional version store, with fully
disconnected operation and an efficient peer-to-peer synchronization
protocol. It understands history-sensitive merging, lightweight
branches, integrated code review and 3rd party testing.
monotone uses Lua to provide users with extension hooks used to
customise and automate many aspects of monotone's behaviour and
Contact: Development Mailing List
Disney's Preschool Time Online is an "Edutainment" product
for children ages 3 to 5.
It features weekly content updates,
and help teaches basic math, spelling, vocabulary,
shape/color/animal recognition, etc...
Lua 5.0 was used extensively for the creation of the episodic min-games.
We chose Lua because it is small, portable, and very easy to use.
(Also, it was already integrated with our game engine).
Lua allows us to add new mini-games to the product without
touching the executable.
This was important to Disney;
they wanted to eliminate/minimize the ammount of regression testing
when adding new content.
The first year worth of content currently has 275809 lines of Lua code,
and approximately 70000 lines of C++ code (not including the game engine).
Current number of programmers is 6, while the Max was around 11 programmers.
Overall, we are extremely happy with how well Lua has performed
for us in this project.
Contact: Brian Weed
IrrLua is a Lua language binding for the Irrlicht game engine. The Irrlicht game engine has six namespaces and over 130 classes, most of which are already imported into IrrLua. IrrLua is based on tolua++. IrrLua is tested to work on Linux and Windows.
Contact: Josh Turpen
Designed to reduce cost of ownership and mitigate impact of disparate systems, expressor software provides the building blocks for data processing applications so that clients with little technical background can develop applications. Almost any data type on any platform can be cataloged and used to develop data processing applications.
The expressor products are used for multi-platform, parallel
data processing. Lua is the used as the data transformation
language, and for configuration and monitoring for our products.
expressor software llc
Contact: John D Russell
FMH Make is a build tool similar to the classic make. It uses an embedded version of Lua for added functionality.
Contact: Martin Hoffesommer
Klango is an environment for developing and running
of audio games and applications, a software dedicated to blind and visually impaired people. Lua 5.0.2 is used by programmers (users of Klango) for developing entire klango-apps.
Contact: Sebastian Smyczynski
Adobe Lightroom is "the complete, elegant environment for
the art and craft of digital photography from raw capture to creative
Over 40% of Adobe Lightroom is written in Lua.
Contact: Mark Hamburg
World of Warcraft is a massively multiplayer role-playing game (MMORPG)
which uses Lua as an embedded scripting language for the UI subsystem.
This allows rapid prototyping of new features during development,
and has the benefit that customers are able to customize and improve
their own interface,
through mods and addons.
WoW is the world's most popular subscription-based MMORPG,
with more than 8 million subscribers.
Contact: WoW UI Forum
Hollywood is a Multimedia Application Layer for AmigaOS
and compatible platforms (WarpOS, MorphOS, AROS i386). Hollywood offers
over 350 functions to create full-featured Multimedia applications ranging from
simple slideshows to complex games. Starting with version 2.0, the script language
used to program Hollywood is Lua 5.0.2 but with a significantly modified syntax
and more control statements like Switch-Case, Goto, Gosub, Dim etc. Lua was
chosen because it is fast, portable, written in plain C, and very programmer-friendly.
Contact: Andreas Falkenhahn
Hyperion is a free tool designed to help developers and artists quickly create and prototype realtime 3D solutions: demos, benchmarks, little applications or games. Hyperion uses a mixture of XML, Lua scripting and GLSL (OpenGL Shading Language) in order to describe static and
dynamic parts of the 3D scene. Lua is one of the most important feature of Hyperion. With more than one hundred functions in the Hyperion/Lua host api, Lua allows the user to act on scene 3D objets. Lua is a great language: you can integrate it very easily in your C/C++ project (Hyperion is a C++ project), it is fast, easy to learn and powerful (Lua tables). Thanx to the Lua Team for this great tool!
Contact: Jerome Guinot
DCWatch is a Direct Connect robot program.
The full core scriptable in Lua
(with LuaJava) as the BCDC client.
The DCWatch's scripts is compatible with the BCDC's scripts, and the
DCWatch able to running the "startup.lua".
Contact: Balázs Viktor
The Symmetry Tax Engine is an enterprise level payroll
tax calculation engine for U.S and Canadian companies.
Lua was originally chosen as the scripting language allowing
customization of payroll calculations. However, it became quickly
apparent that most of the project could be written in Lua.
Approximately 85% of the project is written in Lua. Tax calculations
are stored in SQLite using LuaSQL from the Kepler Project.
We are shipping with Lua 5.1 RC2. Lua is true to its roots - simple,
small, portable, fast, and easily embedded into applications. We ship
Windows, Linux, Solaris, and AIX versions due to the incredible cross
platform capabilities of Lua.
Contact: Tom Reahard
Match-IT is a comprehensive production control system aimed at small manufacturers. It makes extensive use of Lua to allow users to customise the system. Customisation includes automating complex tasks, encapsulating product configuration knowledge and modifying scheduling behaviour.
Contact: Dave Nichols
We are currently using Lua 5.0.2 for various training simulations here at ECS, including Civil Support Team Training, Capitol Hill Police Training, Tactical Combat Casualty Care (Combat Medic Training ), etc. Lua is being used for configuration scripts and most of our behavior/animation state machines. It was chosen for its simplicity and our favorite data structure - the table! Lua was easy to integrate and its environment swapping support provided us with a safe, elegant solution for managing multiple layers of state machines and numerous scripts.
Kudos to Roberto & Tecgraf.
Contact: Matt O'Connor
Hercule is the firmware development platform for Olivetti printers, used in ANY_WAY and MY_WAY series. Lua is used as a configuration script to take the decisions about print modalities, provided desired qualities. This allows the printer driver to behave identically at run time. Additionally, Lua scripts can be executed directly from memory cards, without any host computer, simplifying test and production tasks.
Contact: Patrick Rapin
xNormal v3.0 is a .NET v2.0 application to generate normal/ambien occlusion maps from a very high polygon model and to fit it into a low polygon one to simulate zillions of polygons. It comes with an OpenGL previewer with customizable menus written in Lua.
Contact: Santiago Orgaz
FreedomBox System Access provides access to Windows
for blind people, with emphasis on ease of use and mobility. Ease of
use is achieved through automatic presentation of most information the
user will need. Mobility is achieved through the ability to run from
removable media such as a USB flash drive, thus allowing a blind person
to access nearly any Windows-based computer they encounter without
installing the software first. FBSA uses Lua internally; the bulk of
the code is written in Lua. Lua is currently not exposed to users as a
Contact: Matt Campbell
Garry's Mod is a Half-Life 2 Modification.
It won "Mod of the Year" (2005) from ModDB,
"PC Mod of the Year" (2005) from GameSpy,
and "Best Mod 2005" from PCGamer US.
Lua opened a lot of doors to Gmod players,
allowing them to script new weapons, gamemodes, and other features.
There may never be any addition that was quite as great as Lua.
Contact: Garry Newman
The LoriotPro software extended edition is an extensible solution for administrators and managers that are involved in network monitoring and system management tasks linked to the exploitation of networks, systems or smart infrastructures. The open Lua script language embedded in LoriotPro and the powerful concept of Active View provide unequal adaptation of LoriotPro to your requirements and environment. Additional Lua libraries provide snmp script functions, Active View manipulation script functions, directory script functions allowing you to create your own snmp management applications.
The scripting programs are ideal for making network inventory and create comprehensive and detailed reporting about all of the hardware and software on all of the network devices and computers on your network.
Contact: Florent Brisson
The project is a GUI which aims to replace the command line XMLTV scripts. The program now has around 1,500 users and is the preferred method for downloading XMLTV listings in the UK.
Lua version 5.0 is used in the project. Lua allows the user to create scripts to either download new listings from any source or to process existing listings. Lua was chosen mainly for the ease of integrating it with the rest of the program which is written in Borland Delphi.
Contact: Alan Birtles
The StoneTrip Development Kit is a 3D multimedia applications creation software, specially designed for games. Every application created with the STDK can run on many platforms, including PCs, Macs, Mobile Phones and PDAs, inside or outside a Web Browser.
In the STDK, every object in a 3D scene can have one or more AIModels, which are sort of "behaviour classes", containing Lua scripts.
Lua was chosen because of its small memory footprint, its portability and its speed, even on small devices. And best of all, it has a really "sexy" syntax.
Contact: Nicolas Peri
Impact IV is a telephony platform based on Linux around some Aculab Prosody cards. The cards do the telephony signalling and all the network protocol. To control the call flow we used Lua which was extended by our own telephony specific library containing calls like "getdtmf(how_many, timeout)", "playwav(filename)" , etc.
Lua was chosen because it makes it very easy to extend the basic language with what you need and it is small and lightweight. We run up to 480 lines in parallel (meaning up to 480 Lua interpreters are active at one time) and our system (pretty much bulk standard PC with 2GB of RAM) has no problem coping with that.
Furthermore Lua enables us to make DB connections from within a voice script (get or write for example subscriber information...), use SOAP requests from within a voice script and quite a bit more.
Very useful language!!!
Contact: Bernd Kronmueller
Chipmunk AV Controller is a Windows.NET application capable of controlling Home Cinemas and advanced audio visual equipment via plugins such as RS232 serial control, USBUIRT infrared and wireless remote control. Incorporating a Lua scripting engine enables users to interact with Chipmunk and its plugins programatically. Chipmunk uses Lua.NET to integrate Lua with the Microsoft .NET Common Language Infrastructure.
Contact: Dr Shaun Brown
Luxinia is a scriptable 3d game engine. The entire gamecode is done with Lua. The engine comes with a powerful material, shader and particle script as well. Rendering is done with OpenGL, audio with OpenAL, and physics with ODE. The engine does not require newest hardware but runs fine from geforce 2 generation cards on. The Luxinia API provides many classes and functions to Lua, so that many different games could be done with it. It is ideally for beginners and smaller games, or rapid prototyping. Lua's simplicity and power is a key to the engine.
Contact: Christoph Kubisch
Hearts for GNOME is an implementation of the classic
card game for the GNOME desktop. All the computer
opponents have been implemented in Lua, allowing for easy adding and
editing of opponents by developers as well as users who wish to tinker
with the game.
Contact: Sander Marechal
Wireshark is the world's foremost network protocol analyzer,
and is the standard in many industries.
Wireshark is used by network professionals around the world for
troubleshooting, analysis, software and protocol development, and
education. It has all of the standard features you would expect in a
protocol analyzer, and several features not seen in any other product.
Lua been added to Wireshark as a language for prototyping and scripting.
Lua can be used to write dissectors, post-dissectors and taps
(a mechanism to fetch data from every frame).
Contact: Ethereal Developers
ELF is an integrated scripting environment based on Lua from which you can control some dynamic loadable modules, written in C++, that allow you to control many other state-of-the-art and opensource technologies. These modules offer to the coder many functions designed to control all their functionalities in a simple but effective manner. For instance, loading the 3D graphics module, you can use all the functions designed to control the 3D view... loading the positional audio module you can load (and play, of course!) sound files, and so on! ;)
Contact: Alessandro Rasulo
The Avalon Management Suite is a complete business
management solution. We use the Lua language behind-the-scenes for
maintenance and reporting tasks. We also provide a front-end API for
users to write their own reports and jobs using Lua.
Contact: Bert Johnson
Malathedra is graphic adventure game similar to such
LucasArts(TM) classics as the Monkey Island(TM) series, The Fate of
Atlantis(TM) and The Dig(TM).
Malathedra utilizes Lua as a scripting language, which controls all
aspects of game logic.
Contact: Raymond Jacobs
David Douillet Judo is a judo game running on Ps2, Pc, Gc and Xbox. We currently use lua for judoka AI. Each decision the AI takes goes through lua, allowing to speed up the development and tuning of it using instant reloading. Lua is also used for some dynamic HUD (Head-Up display) element in the training mode.
Contact: Julien Hamaide
We added Lua scripting to our MUD game client in November 2004. We
have been very pleased with the ease with which it can be integrated
with the existing C/C++ code, and its speed and general flexibility.
In particular, the coroutine implementation has made it possible to
build "pauses" into MUD game scripts, in ways which were tedious or
impossible in other standard scripting languages.
Contact: Nick Gammon
CityBinder is a program designed to generate "bindfiles" for the MMO's City of Heroes and City of Villains.
CityBinder is written almost entirely in Lua, and uses IUP for its user
interface. What little isn't Lua is the interpreter code and a few
library functions supplied to facilitate the Lua code.
In the future, CityBinder will probably provide a method to run Lua code
entered by the user.
Contact: Jeff Sheets
VoodooPad is a personal "desktop wiki" for MacOS
X. Lua is used for creating custom plugins and executing code based
on events ('triggers'). Lua was chosen over other scripting
languages because of how easy it was to integrate and write scripts
for. The LuaObjCBridge is also used to talk between VoodooPad and Lua.
Contact: Gus Mueller
Illarion is a free graphical multi player online role
playing game which, unlike most other similar projects, focuses on role
playing (rather than levels, skills and so on, often referred to as
"hack and slash"). We have a running server since
1999, now hosted at the Technical University of Vienna (Austria) and a
client that was developed in Java (which, therefore, should run on most
The game is playable (and hopefully enjoyable) but remains under
constant development, meaning that we're always adding details or fine
tune certain things, and this is where Lua came in. In 2004 we were
looking for a scripting language that is small, runs fast (pre-compiled)
and is easy to learn and handle and which is easily embeddable in
our existing server source (C++). Lua obviously fulfilled all our
requirements, so we chose it.
At first, most things were handled by the server directly and only a few
things were handled by Lua (like non playing characters (NPCs) reacting
on spoken sentences and items being "used" (like to eat an apple or to
craft a weapon). When we realized the potential of Lua, we thought about
what else we could use it for, and by now, a lot of things are handled
First of, the whole combat system (everything that has to do with
fighting) is done by Lua, simply because you can easily tweak and
balance things more easily (just exchange the script, reload, done,
without restarting the server or having players log out for some
minutes). Magic is also handled by Lua, and so is everything that plays
a role for economy related things (like crafting items, buying/selling
them, finding loot, ...). Also, we started implementing automatic quests
which are practically realized in Lua entirely, so is a key-lock-system
and so on.
In total, we use more than 400 different Lua scripts, covering nearly
every aspect of the game. The Lua source codes in Illarion need about
2,5 MB of space, whereas the server source code "only" has 1,4 MB. This
is just to illustrate how important Lua became for Illarion.
Contact: Jan Falke
Alt-IDE is an open source Lua scriptable IDE. Since it uses Lua for project management it is possible to add support for any compiler and beyond. The project's aim is to be small, fast and most of all easy to use!
Contact: Teemu Hietamies
AAASeed is a 3D real time interactive software
raised incrementaly for 1O years now.
It's a kind of virtual lego based on the dataflow
metaphor (ConMan, MAX/MSP, pure Data, vvvv...),
but with no graphic representation for the
moment. You can also described AAASeed as an image instrument.
It is used for the moment by a very small group
of people around the Author Mâa.
AAASeed is a VJ tool, is used on events (Theater,
festival, dance, corporate conference...), is the
engine behind temporary and permanent art
installation, museum pieces (Nibelungen Museum,
Universal Exhibition Aichi 2005, Nuit Blanche PAris 2005...)....
AAASeed is develop these days toward massive
public collective interactive installations.
Lua is the first language integrated (August
2006), it was a great pleasure to do it, and even
challenge the AAASeed architecture.
I want to thank warmly the Lua team for their brilliant creation.
Contact: Emmanuel Mâa BERRIET
Barracuda provides Lua Server Pages (LSP) for web page authoring.
The Barracuda platform is an advanced Embedded Web Server designed
for controlling and monitoring embedded industrial applications in
real time. The Barracuda Web server has a very small footprint and
runs on almost any platform.
LSP provides support for most of the Barracuda APIs (cookies, sessions,
RPC, etc.) and has built-in Lua-SQL support. Barracuda LSP can be extended
with existing Lua libraries. LSP applications can be packaged as ZIP
files and/or embedded in the Barracuda web server executable.
Contact: David Burgess
Prime Mover is a command line build tool, similar to make,
designed for compiling multipart applications. It is written entirely in Lua
but uses a cunning mechanism to avoid having to have a Lua interpreter
installed when using it. Prime Mover is considerably more flexible and
extensible than make, and scales very well to large projects. It is freely
available under the MIT public license.
Contact: David Given
A multiplayer networked realtime programming game
featuring little creatures fighting for food. You upload your Creature
Code (written in Lua) to a game server using a telnet-like Interface.
The gameserver then runs your code. The graphical client can be used
to watch running games or replay recorded games.
Contact: Florian Wesch
Robots is an AI programming game, this means the
players write an AI in Lua and pit them against each other to find out
which on is the best.
The goal of Robots is to program your robots to be superior combatants. You
can have your robots battle the robots of other people or you could just
have some fun making your robots do what you want.
Contact: Brend Wanders and Pieter de Goeje
Catz 2006 and Dogz 2006
Published by Ubisoft, Catz 2006 and Dogz 2006 are Pet simulators, like Nintendogs, for the PC, targeted towards kids aged 6 and up.
We used Lua 5.1.1 for the UI screen layouts, 3D Object definitions, Save/Restore, and all Pet behavior (AI, animation control, pathfinding, etc...)
There were 3 programmers, 58960 lines of Lua code, 27730 lines of C++ code
(not including the Game Engine).
ImaginEngine Corp. A Division of Foundation 9 Entertainment
Contact: Brian Weed
We use Lua extensively for internal scripting/lab support on a gene sequencing device. We've also contributed a fair number of extensions to LuaInterface.
Contact: Kevin Hester
Lua 5.1 is used as the basis for the recent macro-instructions plugin written for K-MeleonCCF (the experimental development version of the K-Meleon web browser).
A smaller, lighter, version of the same browser, called K-MeleonCCF-ME (minimum edition) is even more heavily dependent on lua macros.
Contact: Hao Jiang
ROBLOX is a multiplayer game where you build worlds out of toy bricks. Every object in the world is subject to the laws of physics. The entire data model is accessible with Lua. You can use Lua to build such things as tools, weapons, jet-packs, elevators, etc.
Contact: Erik Cassel
MAXi is a simple and fast text editor. By creating plugins with Lua you can customize it on your own to add new features. For exsample it is possible to build a complete IDE for different programming languages like C/C++, PHP, Pascal or Basic.
Sven "Ratchet" Langenkamp
Contact: Sven Langenkamp
LLRnet is a distributed computing project. It is based on LLR, a program that can prove very efficiently whether a number of the form k.2^n-1 is prime. Lua was used in this project to program the logic of the server and the client, as well as to implement a simple GUI.
Lua was chosen so that different prime search projects could tune the behaviour of LLRnet to their specific needs without recompiling any code (LLRnet is used in several projects: Rieselsieve was the original one (a project to prove a certain conjecture), but also Sierpinski and other projects).
Contact: Vincent Penne
HDngn is a OpenGL API-based Video Player/Engine. It can use OpenGL and DirectShow to view the video as a texture and is able to interpolate new frames in real-time. This smoothes video playback and reduces block artifacts. HDngn can have different skins through Lua scripting.
Contact: Moritz Strickhausen
FLEXON is a round-based 3D board-game, which was developed as a Bachelor Thesis by two students at the University of Applied Sciences of Trier, Germany.
Inspired by the game 'Abalone' we created the rules of FLEXON based on a hexagonal playarea. To display the 3D graphics we used the jMonkeyEngine. In an early stage of development we got the idea of creating variable game content and variable rules. To put this conception into practice we used the scripting language Lua to separate the static program code from the rule-specific part.
University of Applied Sciences of Trier, Germany
Contact: Michael Müller
Multi Theft Auto (MTA) is a multi-player modification for Rockstar North's Grand Theft Auto game series. It is the world's first modification to incorporate multi-player into a single-player PC game.
Originally founded back in early 2003 as an experimental piece of software, Multi Theft Auto has since grown into an advanced multiplayer platform for gamers and third-party developers.
Starting with MTA for Grand Theft Auto: San Andreas, you can play Grand Theft Auto on-line with your friends, in your own custom created maps and gamemodes, powered by the Lua scripting language and currently (as of end 2006) 373 game specific Lua functions!
The use of Lua allows you to create virtually any gamemode or feature you like in the game. Examples and other cool Lua stuff can be found at our homepage.
Contact: Cecill Etheredge
Wireshark is used by network professionals around the world for troubleshooting, analysis, software and protocol development, and education. It has all of the standard features you would expect in a protocol analyzer, and several features not seen in any other product. Lua can be used to write protocol dissectors, and analysis modules. In the future we plan to make it the configuration engine as well.
Contact: Wireshark Developers
The T2 System Development Environment is a open source, GPL, system to automatically configure and build complete systems from scratch.
Among others it includes support to setup the cross compiler and compile the selected packages into a fresh sandbox environment.
Aside shipping Lua and many add-ons as package, Lua is also used in Versions after T2 6.0 as integrated script language in order to speed up non-trivial code-pathes that became too slow in the classic Unix Shell/Awk implementation.
Contact: René Rebe
Turtle uses Lua 5 for custom shaders to give users the option to create procedural texures, custom materials etc.
Contact: David Larsson
pbLua is an implementation of Lua 5.1 for the LEGO Mindstorms NXT. It is based on the open-source code for the NXT brick provided by LEGO. The low level drivers were modified slightly and then integrated with the Lua sources.
pbLua is an alternative text-based programming environment for the NXT that supports coroutines, strings, tables, and limited floating point operations.
The NXT is based on the ARM7 micro with 256K of FLASH and 64K of RAM. pbLua looks like a serial port to a PC and connects via USB. It is completely self contained as it runs the parser right on the brick.
Eventually, we'll support the Mac and Linux platforms when we figure out how USB gets enumerated on those platforms.
Contact: Ralph Hempel
Have you ever wished that there was a 3D
application that was as easy to use as Photoshop and had the
precision of Illustrator? Strata 3D CX is the answer to your design
needs with the ability to link to Photoshop files, import Illustrator
art, and create photo-real images and animations. Add a new dimension
to your work for illustration, design, web-ready graphics, animation
and more. Don't make the mistake of buying a 3D tool that makes you
change your design process - Strata 3D CX works like you do.
Lua 5.0.2 was added to Strata 3D CX for its 5.0 release in order to
support third party extensibility at many levels, from camera lenses
to shaders to the GUI. The next release will be upgraded to Lua 5.1
to take advantage of the many enhancements offered in that version.
We have been extremely happy with the performance, reliability and
sheer fun of working with Lua.
Contact: Gary Bringhurst
Omnitronix is the leading provider of remote site monitoring solutions that simplify and enhance the operation of distributed remote equipment sites that are vital to voice and data networks.
Lua provides a powerful yet easy to use Scripting language for our embedded systems. This allows users to write their own additions to our units.
Contact: Jesse Dennerlein
S.T.A.L.K.E.R.: Shadow of Chernobyl is a game of the genre FPS -
"first person shooter".
It has sold over 1 million copies for PC worldwide.
The project has been developed for 6 years,
and included 20 programmers (7 script writers).
It uses Lua 5.0.2 with LuaJIT (thanks to Mike Pall).
Lua was chosen because of its simplicity, speed,
and the availability of an open-source binding library (luabind).
Lua is an open-source project with 10 years of history,
with a large community,
with few bugs, and that has been used in many other FPS games.
Contact: Dmitriy Iassenev
TerraME is a development environment for spatial dynamical modelling that uses a spatial database for data storage and retrieval. The TerraME modelling language is a Lua language extension.
INPE (National Institute for Space Research, Brazil) and UFOP (Universidade Federal de Ouro Preto, Brazil)
Contact: Tiago Carneiro
A simple make replacement, uses Lua as the language for the builder scripts. It is written in C++ and depends on boost.
Contact: Uwe Sander
"Those Funny Funguloids!" is a nice little open source game about collecting mushrooms. In outer space. It has pleasant and smooth 3d graphics with atmospheric sounds.
We're using Lua 5 for the level scripting in the game. Lua made things simpler and enabled us to tweak the levels without touching the source code all the time. It's also used for loading the user music playlist to be played during the game. Lua rocks! :)
Contact: Mika Halttunen
LOona is halfway between a WIKI and a Content
Management System (CMS) for managing website content. Its main purpose
is to allow your boss to play with his/her website without being able
to break things, while for you server maintenance and the addition of
new features remain easy. LOona is extremely light-weight and requires
no system-wide installation or database, as webpages are generated from
plain text files in LOona's own WIKI-like notation.
Lua 5.1 complements LOona's minimalistic approach with its small and
fast interpreter and ease of learning for writers of extensions; LOona
is implemented in roughly 2000 lines of Lua and C code as a set of
modules in an object-oriented fashion.
Contact: Timm S. Mueller
VPOP3 is a powerful, but easy to use POP3/SMTP email server for Windows. It uses Lua for some extensibility features, such as being able to process incoming or outgoing messages, or generate message signatures etc, where the user needs behaviour above and beyond what can easily be achieved using a 'checkbox user interface'
Contact: Paul Smith
MotionNode is an affordable 3-DOF inertial
measurement unit for use in motion sensing applications.
The MotionNode system extends the Lua language with C++ classes. All
user interaction with the MotionNode system is implemented through a Lua
module. This includes device configuration, recording data, and
exporting animation to standard file formats.
The Lua scripting interface opens up our system to the user.
Contact: Luke Tokheim
Regnum Online is a fantasy online role playing game where thousands of
people can meet and interact with a vast and ever evolving world.
The game emphasizes social aspects and a strong sense of loyalty by
choosing one of the three main Realms at the beginning of your quest.
These three factions are constantly in war and you have to fight
alongside your friends in order to ensure victory over your adversaries.
Lua has been used extensively throughout Regnum Online. Lua comprises
more than 60.000 lines of code, which provide the building blocks for
the gameplay aspects of the game.
Using a combination of a low level API in C++, bindings and Lua we have
been able to create an engine that's easy to use, easy to understand and
easy to extend into whatever we want.
We started using Lua 4, and after a few changes, we were able to move to
the newer 5.1 version
Contact: Nicolas Lamanna
Avantage is a .NET based extensible BPMN (Business Process Modeling Notation see http://bpmn.org/ ) compliant process modeling application.
Avantage uses LuaInterface to provide a scripting interface to the BPMN object model and the UI libraries of the process modeler.
Lua was chosen because of its elegant simplicity, ease of implementation and the excellent access to the .NET CLR provided by LuaInterface.
Contact: Sam Caninski
Xeepe project offers SIP/ISDN based phone solution for SOHO & SMB customers. All configuration and behavior of Xeepe PBX is implemented in Lua.
Contact: Alexander Altshuler
Jive is a software platform designed to power the
development of remote control applications for
Squeezebox and Transporter.
The key highlights of the Jive platform are the Jive Browser,
a resolution and color-depth independent renderer
that allows us to power a wide range of display types, from
monochrome VFDs to full color LCD screens;
and the Jive UI, a new, Lua-based,
scalable user interface that can be completely customized
by anyone familiar with Lua,
a powerful, open-source scripting language.
Contact: Logitech's Streaming Media Systems group
Nmap ("Network Mapper") is a free open source utility for network
exploration or security auditing.
Nmap uses raw IP packets in novel ways
to determine what hosts are available on the network,
what services (application name and version) those hosts are offering,
what operating systems (and OS versions) they are running,
what type of packet filters/firewalls are in use,
and dozens of other characteristics.
It won Linux Journal's Editor's Choice Award for Best Security Tool,
LinuxQuestions.Org Security App of the Year award,
and Info World's Best Information Security Product award.
The Nmap scripting language is an embedded Lua interpreter
which was extended with libraries for interfacing with Nmap.
Lua was chosen because it exceeded in all criteria for Nmap:
it is small, distributed under the MIT license,
has coroutines which provide a sane method for parallel script execution,
was designed with embeddability in mind,
has excellent documentation,
and has a large and committed community.
Supreme Commander (SupCom) is a real-time strategy computer game
designed and developed by Gas Powered Games.
The game is considered to be the successor to Total Annihilation,
which was ranked by GameSpy as
the number one real-time strategy game of all time.
Lua is the language used by Supreme Commander
for most of the high-level game code.
Lua is also the language used to write SupCom mods.
Heroes of Might and Magic V (HoMM5) is the fifth installment of the
Heroes of Might and Magic computer game series.
Lua is used for custom logics programming.
The regular game process is programmed in C++,
but all the high level functions
(as hero movement, spell casting,
changing resources or creatures quantity, placing map objects,
creating text boxes, etc.)
are also accessible from Lua script.
Nival Interactive map and game designers use Lua for their
needs because the language is simple to study and easy to use by
And the programmers like Lua,
because it can be easily bound to the existing C++ code
and it's powerfull enough for a wide variety of
MySQL Proxy is a lightweight binary application standing between one or
more MySQL clients and a server.
The clients connect to the Proxy with the usual credentials,
instead of connecting to the server.
The Proxy acts as man-in-the-middle between client and server.
The Proxy ships with an embedded Lua interpreter.
you can define what to do with a query or a result set
before the Proxy passes them along.
The power of the Proxy is all in its flexibility,
as allowed by the Lua engine.
You can intercept the query before it goes to the server,
and do everything conceivable with it,
like pass it along unchanged,
fix spelling mistakes, rewrite the query, etc.
TshwaneLex is a professional commercial software application suite
for the compilation of dictionaries or terminology databases.
TshwaneLex (for lexicography) and TshwaneTerm (for terminology)
are fully Unicode-based,
and feature immediate entry preview, integrated corpus,
full customisability, styles,
automatic cross-reference tracking, automated lemma reversal,
online and electronic dictionary modules,
export to word processor or typesetting software,
integrated Lua-based scripting, and multi-user/network support.
A free "reader" application is also available.
Contact: David Joffe
LuaTeX is an extended version of pdfTeX
using Lua as an embedded scripting language.
The LuaTeX projects main objective is to provide
an open and configurable variant of TeX
while at the same time offering downward compatibility.
The criteria to for choosing Lua was that it was
easy to extend with pdfTeX-specific functionality,
and also fun to work with.
Contact: Hans Hagen
Warhammer Online is a new MMORP game from EA Mythic
(the creators of Dark Age of Camelot).
Mythic has been a prolific creator of multiplayer online games
since its formation in the mid 1990s.
In 2006 the company was bought by Eletronic Arts.
According to Lance Robertson, the Producer of Warhammer Online,
"we are aiming for the game interface to be very modifiable;
the actual method we have chosen for WAR is to have LUA addons."
These Lua mods follow the same popular fashion of World of Warcraft mods,
where authors can customize the default Warhammer Online interface
all the way to create full new interfaces and functionality.
Metaplace is a next-generation virtual-worlds platform designed to
work the way the Web does.
Instead of giant custom clients and huge downloads,
Metaplace lets you play the same game on any platform that
reads its open client standard.
It supplies a suite of tools so you can make worlds,
and it hosts servers for you so that anyone can connect and play.
And the client could be anywhere on the Web.
Metaplace committed to an open markup standard for its network protocol
- anyone can write a client for any platform they want.
It uses Web standards for everything it could,
which is why you can have a game world that is also a website,
or use Web data to populate your world.
The game logic is written in Lua,
so it is easy to make whatever kind of game or world you want.
SimCity 4 continues a long tradition of high-quality
city simulation games by Maxis.
The game uses Lua for configuring game constants and to
control various of its elements
including the user interface,
tutorials, advisors, and automata.
Third-party plugins for SimCity can access these features to define
the behavior of custom content.
The Allbase Suite is a web-based business management suite.
It incorporates accounting, CRM, inventory, scheduling,
and ticketing into one no-hassle web service.
The entire system is built on top of
an extended version of Lua that is used for report generation,
scheduled scripts, and skinning.
This Lua API allows users of the Allbase Suite
to quickly and easily customize the entire system.
Wed Nov 21 22:41:10 BRST 2007