Lua Workshop 2011

registration · program · venue · travel · accommodation · organization · participants · abstracts · photos

The workshop is over. See some photos taken by Erik Hougaard and read a report by Tony Finch.

The Lua Workshop 2011 will be held in Frick, Switzerland on September 8–9, 2011.

As in previous workshops (2005, 2006, 2008, 2009), the main goal of the workshop is to allow the Lua community to get together and meet in person and talk about the Lua language, its uses, and its implementation.

The workshop is open to everyone interested in Lua.

Please make your own travel and accommodation arrangements. Contact us if you need help or have special requirements.


Registration is now closed. See the list of participants.


We shall have a plenary talk by Roberto Ierusalimschy (Lua's chief architect) and several contributed talks. There will also be plenty of time for getting together and chatting about Lua, including a social event with wine tasting of FiBL's organically grown wines.

See the final program and the abstracts.


The workshop will be held at FiBL, the Research Institute of Organic Farming, which is located near Frick in Switzerland, on a nice hillside between Basel and Zurich.

See Frick at Google Maps and learn how to get there.


Frick is well connected by train to Basel and Zurich. For information see the Swiss railway company.

There are two airports Basel and Zurich, which are both about one hour from Frick by public transportation.

EuroAirport, airport code BSL, Basel. This is the airport of Basel (CH), Mulhouse (F), and Freiburg (D). If you are arriving from France or Germany, then check if you can book a cheaper domestic flight. Easyjet has a base at the EuroAirport. They fly from many European destinations to Basel. There is a bus Line 50 that gets you every 15 minutes to the main railwaystation of Basel. There are several connections per hour to Frick, normally at xx:13, xx:20, xx:40.

Zurich Airport airport code ZRH, Zurich. This is a big international airport. Every hour from 06:04 to 21:04 there is a direct train from the airport to Frick.


We have reserved rooms in the Hotel Platanenhof, which is directly situated by the train station. The cost per night is CHF 140 (single) and CHF 200 (double), breakfast included. These are special conditions. The rooms are reserved until August 9th. You still need to make an individual reservation for your room.

To book a room send email to the hotel. Make sure to tell them that you are attending the Lua Workshop at FiBL. If you need an invoice, include your address.

We will have a shuttle from the Hotel Platanenhof to the workshop location.

There are three other hotels in Frick. A cheaper one is Hotel Rebstock. The rooms costs from CHF 68 to 98. Swiss prices already include tax.


The workshop is organized by Marc Balmer with Vera Hardmeier and the Lua team.

For further information, please contact the organizers:

email: vera at, marc at · voice: +41 61 383 05 10 · fax: +41 61 383 05 12



Some thorny points in the design of Lua: a personal perspective slides
Roberto Ierusalimschy (, PUC-Rio)

The novelties of Lua 5.2 slides
Roberto Ierusalimschy (, PUC-Rio)

Reflexis Flow slides
Ashwin Hirschi (Reflexis)
In this presentation we will discuss how Lua has helped the team at Reflexis develop and evolve Reflexis Flow, a model-driven platform for web application development. Since making software usually requires writing (and wrangling) lots of code, this talk will start by explaining how model-driven development tackles things differently. And as there are paradigms aplenty, it will present our particular take on it and why we feel Reflexis Flow provides people with an environment that makes it easy to create solutions for the web that are both flexible and secure. Next we'll show how Lua has enabled the team at Reflexis to take somewhat of a middle ground between a procedural, component-based world view and a more high-level, model-driven mindset, resulting in a web application platform that's straight-forward to use but also easy to extend. While Flow developers don't need to be familiar with scripting, it is fair to say that knowing Lua greatly enhances what they can get out of our platform. Last but not least, this talk will highlight several cases where Lua has really helped our team come up with practical solutions to specific problems. Time permitting we'll also demo some of our tools or a few of the projects completed using Reflexis Flow.

SPLAY slides
Valerio Schiavoni (Université de Neuchâtel)
SPLAY simplifies the prototyping and development of large-scale distributed applications and overlay networks. SPLAY covers the complete chain of distributed system design, development and testing: from coding and local runs to controlled deployment, experiment control and monitoring. Developers specify their applications using Lua, which is executed in a sandboxed environment. The talk will include a short live demo of a simple distributed protocol in Lua deployed on the PlanetLab. SPLAY is the outcome of research and development activities at the Computer Science Department of the University of Neuchatel, Switzerland.

Henning Diedrich (Eonblast)
d'Arc offers an alternate and faster way to write C against both Lua and LuaJIT. It is faster, can be easier to write and uses less memory in many cases, than the the official API. d'Arc can be used to make libraries for both Lua and LuaJIT faster, and can make it less of a hassle to write patches that target both Lua and LuaJIT. d'Arc allows you to use direct (cost-less) C pointers to variable contents -- inside the universal Lua variable value holder C structure -- in a clear and unified way. After a brief historical intro, the talk will *primarily* take a closer look at the Lua and LuaJIT VMs. I will inspect how iteration works with the official Lua API and what happens 'under the hood', in both Lua and LuaJIT. I will look at the similarities and the differences in the implementation of the essential variable holder, TValue, in Lua and LuaJIT. Continue with a look at where LuaJIT tweaks things right there and how d'Arc allows you to write single source patches despite the differences. Finally, an easy example will be ported, from using the official API, to using d'Arc. We'll compare how it simplifies the source, and make live benchmarks to measure the difference, and look at pitfalls.

Lubyk: a Lua based ecosystem for live performances and distributed multimedia applications slides
Gaspard Bucher (
The talk will highlight some unique aspects of Lubyk: plug & play distributed computing and live coding by automagically connecting Lua processes with ZeroMQ and ZeroConf. A short demo will use the system to control the speaker's voice through simple body gestures (using a wiimote probably) by sending OSC messages to Kyma. The second part will be more Lua centric and highlight how lua scripts are connected together and how their runtime environments are encapsulated to ease code reuse and avoid side effects. This will also be the occasion to release the first public beta for Lubyk.

Mitigating the danger of malicious bytecode slides
Peter Cawley (University of Oxford)
In Lua 5.1 and 5.2, the family of load functions permit the loading of precompiled bytecode in addition to plain source code. We shall look at some relevant details of the bytecode, and see how these details can be maliciously abused to escape from a Lua sandbox (in both 5.1 and 5.2). With the dangers presented, we shall then move to look at two ways of mitigating them. Firstly, one can wrap the load functions as to reject bytecode before it is loaded. Secondly, and more interestingly, one can attempt to algorithmically decide whether a given piece of bytecode is malicious or not. We shall look at two such algorithms for validating bytecode: LBCV, which tries to reject as little as possible, and my current experimental verifier, which tries to accept as little as possible.

LuaDura for Olivetti
Patrick Rapin (Olivetti Engineering SA)
Olivetti is active in the ink-jet printing industry. Our current prototyping and testing platform is called LuaDura, based on Lua. The talk will first expose its origins (including its strange name), and the underlying concepts. For better comprehension, a rapid look into the foundations of Olivetti printers firmware will be necessary. Then we will see some implementation decisions, and some special features like the "threads" built upon coroutines and native threads together. The last part of the talk will be about how the application is used at Olivetti by lots of various people. But also what are the mostly experimented problems. If there is time, the presentation will finish with a small demo of "midi.lua".

IceLuva: a Lua-based framework for Magnetic Resonance Image reconstruction
Francesco Santini (University of Basel Hospital - Radiological Physics)
The reconstruction of images acquired with Magnetic Resonance involves many different manipulation steps, dealing with real and complex data. In this work, a brief overview of how a clinical MR scanner deals with data acquisition and image reconstruction will be given, introducing the tools that are generally available to the researcher for the customization of this process. Subsequently, the IceLuva framework is introduced. This framework is designed for postprocessing of the (complex) images, a step that is usually performed on a separate computer with tools like matlab. IceLuva is implemented as a functor in the reconstruction pipeline of the scanner, including a Lua virtual machine and the appropriate bindings for retrieval and storage of images. Details of the integration will be given in the talk. Finally, some custom extensions to the original Lua language, for basic image and complex data manipulation, are implemented in order to simplify common operations. In the end, real-life examples of usage will be given and a performance comparison between Lua interpreter, LuaJIT and offline Matlab processing will be presented.

Lua/APR: An extended standard library for Lua slides
Peter Odding (Netherlands)
Lua is a very elegant programming language, both because of its conceptual simplicity and the small size of its implementation, but this small size comes with a price: Lua's operating system interfaces are quite minimal and (in a sense) this makes Lua a second-class citizen on popular platforms like Windows and UNIX systems. In this presentation the author will talk about Lua/APR, a binding of the Apache Portable Runtime (APR) for Lua. The talk will start with the author's motivation for creating the binding, followed by a short introduction to APR and its origins. Next a short summary of the available operating system interfaces will be given. After this the technical challenges in creating the binding will be discussed. Finally the author will share his master plan in creating Lua/APR :-)

Lua tooling for M2M & embedded development / Koneki Project
Fabien Fleutot (Sierra Wireless)
Lua's flexibility makes it very versatile, but also makes it harder to provide good IDE support for it. Koneki is an Eclipse technology project aiming at proposing advanced tooling to help M2M (machine-to-machine) developers to create their solution. The proposed talk aims at highlighting the noteworthy features of Lua tooling in Koneki, in particular the support for LuaRocks and LuaDoc ; as well as giving the attendees an overview of a couple of design decisions which are allowing us to propose extensible tooling, in particular because most of the actual parsing code is written in (Meta)Lua.

Lua for M2M (machine-to-machine) communications slides
Fabien Fleutot (Sierra Wireless)
We develop a software agent, running on various embedded devices, which allows to monitor and control them through the net. A large part of the embedded code is written in Lua, which offers interesting solutions to many of our problems. Among noteworthy technologies we consider presenting, we have: coroutine-based scheduling, which allows most of our code to run unmodified on Linux-based systems as well as OS-less, callback driven architectures; a widespread use of ltn12 to handle data streams (IPC as well as client/server communications, mostly based on Hessian); some modifications in the Lua bytecode format which allows to keep large parts of Lua code in flash, thus saving significant amounts of RAM; an application-generation wizard, which offers flexibility for unforeseen needs (by allowing to add arbitrary Lua code), and allows to provision generated applications on architectures which would normally only accept a single monolithic executable.

Declarative Internal DSLs in Lua: a game-changing experience slides
Alexander Gladysh (
This talk will cover an approach to implementation of internal declarative DSLs in Lua, developed by the author along with the team. The approach employs a format-agnostic loader for a declarative DSLs and several DSL data-handling idioms, all described in the talk. Described approach is used widely in author's and team's work, and proven to be game-changing to our Lua application development process. It significantly eased and streamlined our work with DSLs, leading to the boom of effective DSL-driven solutions (also briefly showcased in the talk).

The Quest API for Gbanga
Robin Di Capua (Millform AG)
I'll talk about how we implemented our Quest API in Lua to create fast and easy to extend scripts for our location based platform Gbanga. I'll show some examples of Lua scripts and how we used them to dynamically populate our virtual world in our game Gbanga: Famiglia.

Crazy Ivan, a Lua driven robot
Erik Hougaard (E Foqus Danmark A/S)
For the last 11 years, a competitor in the Danish robotic race "DTU RoboCup" has been a Lua driven robot called 'Crazy Ivan'. Crazy Ivan is one of the most successful robots in the competition. The Crazy Ivan robot is designed to drive through a predefined race track and solve different tasks such as climbing stairs, passing a guillotine, playing golf and much more. Lua is used as the programming language for the robot's "brain" and all decisions are taken in Lua. This is the fourth incarnation of the robot, now vision based. During the presentation, Crazy Ivan will be running live on the floor while its "Master" will try to control the action. Anything can—and will—happen!

Interface specification and verification slides
Wim Couwenberg (Océ)
I will present an example of how Lua is used as a support tool in our build and automatic testing framework. Our software consists of many components that communicate via interfaces that are defined in a (proprietary) idl. Interface traces for each component are saved during each run of our software. These trace files are handled by Lua scripts to decode them into a readable format and to perform specialized post mortem analysis on them. Recently I added the possibilty to specify interface behaviour directly into the idl as small Lua snippets. This invites developers to properly document their interfaces and at the same time relieves them of the burden to write analysis scripts per component.

Lua in the NetBSD Kernel
Marc Balmer (micro systems)

Last update: Thu Nov 28 08:27:17 BRST 2013