The Lua Workshop 2013 will be held
in Toulouse, France,
on November 23–24, 2013.
It will be part of
Le Capitole du Libre,
a larger FOSS event.
As in previous workshops
the main goal of the workshop is to allow the Lua
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.
There is no registration fee but participants are required to
because space is limited.
Please make your own
if you need help or have special requirements.
Registration is now closed.
list of participants.
If you have sent a registration,
but your name is not listed,
let us know.
We shall have
a plenary talk by
(Lua's chief architect)
and several contributed talks.
There will also be plenty of time for getting together and chatting about Lua.
All activities in the workshop will be conducted in English.
Other activities in Captiole du Libre are mainly in French.
This event will be composed of talks, all Saturday 23rd and Sunday 24th morning.
For the Sunday afternoon, it would be great to have more interactive workshops, since the Sunday is usually more of a general public event.
If you'd like to speak at the workshop,
please send a title and a short abstract to the
The final program is shown below but it is still subject to last-minute changes.
The workshop will be held at
2 Rue Charles Camichel
See the precise location in the
Toulouse train station is
You may want to buy tickets from
The train station is a 20-minute walk from ENSEEIHT.
You can also use the subway from the train station:
On line A, heading to Basso Combo, take line B at Jean Jaurès.
Leave at François Verdier.
Now you are 5 minutes away from ENSEEIHT.
Here is a
The nearest airport is
There are flights from Paris every 30 minutes and
direct flights from numerous cities.
To reach ENSEEIHT from the airport,
Tisséo's Airport shuttle,
leave at Jean Jaurès, then follow this
There are many hotels downtown,
prices starting at 50€.
Hostels with prices starting at 17€.
Within a 5-minute walk from ENSEEIHT,
Kyriad Toulouse Centre
is probably the most practical hotel.
You can also contact
to find whether a FOSS user could host you for the occasion.
The workshop is organized by
The organizers can be contacted at
- Jean-Philippe Humbert (Tebis)
- Rob Kendrick (Codethink Ltd.)
- Daniel Silverstone (Codethink Ltd.)
- Pierre Chapuis (Moodstocks)
- James Callahan (ChatID)
- Thomas Jericke (Indel AG)
- Raphael Zulliger (Indel AG)
- Dmitry Ledentsov (Tebis)
- Paul Cuthbertson (Gamesys)
- Thijs Schreijer
- Alexander Gladysh (LogicEditor)
- Romain Charbit (Diginext)
- Vitaliy Rybalka (software developer)
- Justin Cormack
- Kris François
- Lesley De Cruz
- Bernard Haible (ETAS)
- Joseph Manning (University College Cork)
- Julien Desgats
- Alessandro Delgado (Moviepilot)
- Robert Schlephorst (SE-Elektronic)
- Paul Gil (individual consultant)
- Bruno Amir (software developer)
- Jose Alvarez
- Pauline Colas (study manager)
- Jean-Luc Jumpertz (Celedev)
- Dominik Off (Festo AG & Co. KG)
- Bertrand Mansion (Mamasam)
- Cédric Deltheil (Moodstocks)
- Marc Balmer (micro systems)
- Hisham Muhammad (PUC-Rio)
- Peter Drahos (Slovak University of Technology)
- Vera Hardmeier (micro systems)
- Cuero Bugot (Sierra Wireless)
- Enrico Tassi (Debian & Inria)
- Ignacio Burgueño (inConcert)
- Laurent Barthelemy (Sierra Wireless)
- Fabien Fleutot (Sierra Wireless)
- George Stoianov
- Arnaud Degroote (LAAS-CNRS)
- Francisco Sant'Anna (PUC-Rio)
- Valerio Capoccia (3D Informatica)
- Roberto Tirabassi (3D Informatica)
- Ladislav Sopko (3D Informatica)
- Jerome Leclanche (LXDE)
- Christophe Berbizier (Peersuasive Technologies)
- Toni Reina (3scale)
- Raimon Grau (3scale)
- Théo Lumineau (Harmonie Consulting)
- Eric Koorn
- Belhorma Bendebiche (Spotify)
- Nicolas Barthe
Integrating Lua into the high-end automation framework McRobot
McRobot is a module and message based framework for automation. It is
used to control various types of machines, such as handling systems,
pick and place (SMT) and wire processing machines. This talk will show
several aspect of integrating Lua into an existing framework as its
primary scripting language. It focuses on the following topics:
- Binding Lua with a message based framework
- Writing a custom scheduler for Lua in C
- Adding debugging support with Eclipse as IDE
- Building a cross-compiler library for Lua source code to embedded
Gitano and its attendant technologies
I will cover the Gitano Git Service (written in Lua) and its
- Lace - Lua Access Control Engine
- Clod - Configuration Language Organised (by) Dots
- Supple - Sandbox (for) Untrusted Procedure Partitioning (in) Lua - Engine
- Gall - Git Abstraction layer (for) Lua
- Gitano - A Git Service written in Lua
I will cover the issues encountered and resolved while writing Gitano, some
of the current uses of Gitano, and some of the future plans for the technology.
A visual DSL toolkit in Lua: past, present and future
Lua, besides its other virtues, is quite easy to learn. Nevertheless, Lua is a programming language, and in order to learn it one must invest a considerable effort to learn to write programs.
It is often the case that, on one hand, there is a need to configure lots and lots of business logic intricate and ever-changing rules, but, on the other hand, the person who has the most expertise on the particular business logic area – domain expert – not have any clue on how to write code effectively (or even at all).
All kinds of clumsy UIs, spaghetti code, wasted dedicated scripter's hours and other unpleasantries stem from that problem. Our flagship product – Business logic editor toolkit – to alleviate that somewhat by providing a programmer with a set of tools to easily build a business-logic configuration UI, suitable for a non-programmer domain expert, and an easy, platform-agnostic way to seamlessly tie business-logic configuration from that UI to an existing (or newly written) codebase, effectively creating a visual domain-specific programming language.
And a promise: no marketing speak in the talk, and as much technical details as I'd dare (and time will permit)!
Using Lua to boost document handling and information retrieval in XML Native Database scenarios
Valerio Capoccia and Roberto Tirabassi
(3D Informatica Srl)
Our primary target was integrate a scripting language to delegate specific operation on data to something else than the engine. The specific target, required very intimate integration with a multitude of features Document/Object Oriented belonging to the engine and at the same time a great simplicity and flexibility of development.
By placing the look at the panorama of scripting languages that could lend themselves for this purpose, whereas the integration would take place with modules fully implemented in C/C++, Lua language has soon proved our right choice. It is widespread and is used in many different areas. It has a wide extensibility as well a wide range of functionality and libraries already available, and is designed to suit a multitude of our needs. In its declination LuaJIT, also offers a level of performance further advanced.
Our implementation of Lua in eXtraWay provides an executor of scripts, organized into packages in java style, which can be invoked explicitly (Stored Procedures) or run automatically inside the engine(Triggers) and who are able to take advantage each other through a simple inclusion system.
We have developed specific packages for individual databases eXtraWay in which it was necessary to carry out specific and tricky operations on documents and indices. Were also developed generic library to perform common operations on documents through Lua, reusable in multiple scenarios.
Each package refers to a dynamic library specifically designed allowing you to use the functionality of the server invocandole directly from Lua scripts built.
so you can create records, save them, search them, operate on lists of records and their abstract, load the XML content and perform multiple operations on the same structure including managing digital content associated with them. You can also perform batch external and different solutions have been implemented for the management of large amounts of data in memory and on file.
LuaRocks - past, present and future
This is a talk on LuaRocks, the package manager for Lua modules.
was first released in 2007 and currently features over
300 projects in its repository. The focus of the talk will be on the
history of LuaRocks so far, its current status and latest
developments, including possibilities for changes, especially
revisions in the rockspec format. The idea is to hopefully open a
discussion with the community with regard to future directions.
(An accompanying article on the history of LuaRocks is
State of the Lua ecosystem
We will have a look the Lua ecosystem, comparing it to that of other dynamic programming languages. We will try to understand what makes its specificity and what we, members of the community, can do if we want to increase the popularity of the language. We will particularly focus on Open Source libraries.
Using Lua for BACnet OEM solutions in building automation
In order to create highly customizable BACnet OEM solutions we integrated a Lua runtime into our building controllers. From within this runtime you have access to our BACnet stack (ASHRAE/ANSI 135-2010; ISO 16484-5) and can interact with internal and external BACnet objects and devices. Each Lua instance is part of the BACnet stack itself and can be controlled with the BACnet protocol. Furthermore, it is possible to use Lua for diagnostics, tests and one-time tasks since each instance is equipped with shell access via telnet.
CFM: A Console File Manager for POSIX
(University College Cork)
CFM is a text-based file manager for POSIX-compatible systems, written in
just 750 lines of Lua, using the 'posix' and 'curses' libraries.
CFM emphasises a clean uncluttered display and simple ergonomic interaction,
while providing a good range of useful facilities.
This talk firstly demonstrates the features of CFM and then presents several
observations on the use and advantages of Lua in developing this software.
Using Lua for Responsive Programming of iOS apps
Celedev has developed a live-coding-oriented development environment for iOS apps. This talk will be focused on the role of Lua as a key component of this system. It will present the reasons behind the choice of Lua and will discuss several technical aspects of the integration of Lua in a complex host operating system like iOS, including:
- Multi-threading aspects: We will see why multi-threaded Lua is a mandatory feature in our system and we will show how to use the lua_newthread() function to run code from multiple threads within a standard Lua VM. We'll also provide a few implementation tips & tricks to avoid common traps in Lua multi-threaded implementation.
- Object-Oriented framework: The need for integration of Lua code with the iOS Objective C runtime has led us to design an extensive Lua Objects Framework, fully compatible with the Objective C model, but with a very Lua-ish spirit; we will give a brief overview of this framework.
- Dynamic code update: we will discuss Celedev dynamic code update feature from the Lua implementation perspective and show how it is integrated with the Lua require() function.
- Lua Debugger: And, as a good debugger is key for serious software development, we will put the highlight on some original features of the Celedev debugger and show the debugger integration with other features of the system discussed previously.
This talk will be illustrated by short coding & debugging demos of the Celedev Responsive Programming system on iOS devices.
Towards a Lua scripted operating system
Recently I have been working on a project (called "ljsyscall") to
experiment with scripting operating systems in Lua. In this talk I
will look at progress so far, what I have learned, and look at a
roadmap towards an operating system that is scriptable entirely in
Initially ljsyscall was an experiment to see what a scripting
interface for Linux would look like in Lua. I started with system
calls, and progress was slow, as there are lots of them and you cannot
do very much with just a few. But I carried on, and then started
adding facilities built on the raw system calls, such as configuration
of network interfaces, security systems etc. The aim was to get to the
point where an application could easily configure its whole runtime
environment without needing a large infrastructure of shell scripts
etc. It was partly driven by the way that the way systems boot was
being made less transparent by code such as systemd which moves code
into C not shell, making it harder to understand how an operating
system works, while one that works in Lua should be easier to
The second phase, in 2013, involved more experiments, this time with
NetBSD, and the NetBSD rump kernel, which allows parts of NetBSD, such
as file systems and the network stack, to run in userspace, even in
other operating systems, or in systems with no operating system at all
such as embedded systems. Lua scripting was extended to be able to
script these, with the same interface as on the operating system
itself. This allowed things like booting Lua natively as a guest under
Xen, without an operating system at all but with a full network stack
and file system, in a couple of megabytes.
Future work includes further work with NetBSD, as Lua is now a
component in the core set of packages in the operating system,
although it is not yet used there. NetBSD is a good complement to Lua,
as it is small, portable and powerful. I intend to work towards
producing a scripting interface for all the core functionality, in
what will be a fruitful partnership. Other work in progress is the
port of ljsyscall from LuaJIT that it originally targetted to PUC Lua,
and further extensions for Linux.
LuaDist: providing the batteries
(Slovak University of Technology, Faculty of Informatics and Information Technologies)
One of the primary issues with Lua in the wild is the lack of
standardized batteries included distribution. Creating and maintaining a
distribution that is as portable and flexible as Lua is challenging,
especially for modules that depend on external libraries. Solutions to
this problem are partially available in form of the LuaRocks and LuaDist
projects, however there are still some standing issues that have to be
addressed. This talk will summarize the challenges of building
multi-platform Lua distributions and provide some insight into the
planned unification between the two most prominent package management
systems in the Lua ecosystem.
Integrating Lua in a commercial product - Experiences made and decisions taken
arcapos is a commercial point of sale solution for retail and ticketing
with a focus on ease of use, speed, and stability. The frontend can be
extended using the Lua language, the backoffice parts are written to 90%
With integrating Lua we had two things in mind: Allow us to quickly
react to customer requests, and, allow experienced users and resellers
to change the system.
This is a (technical) talk about how we integrated Lua into the arcapos
point of sale solution. This is not a marketing talk, of course, but
rather technical issues we faced, how we solved them, code examples
(both C and Lua) etc.
Lua and the Web
The Web is the biggest platform in the world and it can now be scripted in
too, with the help of a lightweight virtual machine called Moonshine.
In this talk I'll introduce Moonshine and walk you through how to get
started with Lua in the browser. We'll write some code, create some APIs,
explore the debugger and discover a few things that are now possible with
Lua and the Web.
Lua: 20 years
LuaNode: Asynchronous I/O for Lua
LuaNode allows to write performant net servers or clients, using an
asynchronous model of computing (the Reactor pattern). You might have seen
this model implemented in event processing frameworks like Node.js,
EventMachine or Twisted. In fact, LuaNode is heavily based on Node.js.
Towards practical type-checking for Lua
This talk will describe ongoing investigations to perform optional,
partial, compile-time type-checking on Lua programs. It describes the
main challenges and compromizes necessary to go from a theoretically
sound type system to a pragmatic solution, finding actual bugs in
actual programs without requiring excessive amounts of bookkeeping
Lua and Debian
(Debian & Inria)
Debian is a free OS distribution on which more than 120 derivatives
are based. It distributes around 20K different softwares, precompiled
and packaged for an average of 10 architectures. Lua is part of it,
and the 5.1 runtime counts more than 100K installations (in Debian,
10 times more in Ubuntu, ...).
In this talk I describe how Lua fits in this picture, and how the
peculiarities of Lua make it easy or hard to package it and its
libraries for a mainstream software distribution like Debian.
Lua integration in NetBSD
Lua is part of the NetBSD operating system
It is not only used to script programs in userspace, but also to run Lua
code in kernel space. What sounds bold at first sight allows for
interesting experiments, e.g. rapid system code development, ideal for
prototypes, proof of concepts and such.
In this talk, I'll give an overview of the current state of Lua
in NetBSD, the components and NetBSD specific bindings, and what
generally can be done using the NetBSD and Lua combination.