Lua Workshop 2015

The Lua Workshop 2015 will be held in Stockholm, Sweden, on October 15–16, 2015, courtesy of King.

As in previous workshops (2005, 2006, 2008, 2009, 2011, 2012, 2013, 2014), 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. There is no registration fee but participants are required to register because space is limited. Please make your own travel and accommodation arrangements. Contact us if you need help or have special requirements. For further details, see the local page.


We shall have plenary talks by Roberto Ierusalimschy (Lua's chief architect) and by Thomas Hartwig (CTO, King), and several contributed talks. There will also be plenty of time for getting together and chatting about Lua.

If you'd like to speak at the workshop, please send a tentative title and a short abstract with your registration.

The local page contains a preliminary list of talks to be given at the workshop.

Thursday, Oct 15th

8:00 registration and badge pick-up
9:00 Welcome to the Lua Workshop
Thomas Hartwig
9:15 Lua in the Defold game engine
Ragnar Svensson
9:45 Creating a game using Defold and Lua
Johan Högfeldt
10:15 Lua in the Stingray 3D game engine
Niklas Frykholm
11:15 Testing Lua
Roberto Ierusalimschy
12:15 lunch, courtesy of King
13:15 Luerl - an implementation of Lua on the Erlang VM
Robert Virding
14:00 Shen: An API Gateway for mobile games using Lua + Erlang
Johan Lövdahl
14:45 Improvements of LuaJIT for MIPS32 and MIPS64 platforms
Stefan Pejic, Djordje Kovacevic
15:30 Clang plugin for generating declarations for the LuaJIT FFI library
Violeta Vukobrat
16:00 Ravi
Dibyendu Majumdar
16:45 Supporting Elephants with PostgreSQL and Lua
Marc Balmer
19:00 pizza, beer and Lua, courtesy of King

Friday, Oct 16th

9:00 Using Lua in a residential gateway
Dirk Feytons
10:00 Ad-hoc big data analysis with Lua and LuaJIT
Alexander Gladysh
10:30 Elasticsearch for Lua Developers
Pablo Musa
11:15 Tarantool - a Lua based database engine and in-memory data grid
Konstantin Osipov
12:15 High level application scripting with Enlightenment Foundation Libraries and LuaJIT
Daniel Kolesa
13:30 lunch, courtesy of King
14:30 Profiling Memory in Lua
Pablo Musa
15:30 At the end of the rainbow
Ignacio Burgueño
16:00 Always be testing
Ignacio Burgueño
16:30 Experience of game prototyping with MOAI: from low-level to framework
Dmitry Potapov
17:00 CodeFlow, an advanced IDE for Lua
Jean-Luc Jumpertz


The workshop is organized by Björn Ritzl and Martin Bunge-Meyer at King, and the Lua team.

The organizers can be contacted at

Sponsored by



Testing Lua slides video
Roberto Ierusalimschy (PUC-Rio)

Luerl - an implementation of Lua on the Erlang VM slides video
Robert Virding (Erlang Solutions AB)

Erlang is well-known for its ability to build scalable, massively concurrent and fault tolerant systems. While it is relatively easy to interface Erlang with Lua this will generally not give Lua access to all these features. Luerl is an implementation of Lua in Erlang which runs natively on the Erlang VM. Lua programs running in Luerl are part of the Erlang system and therefore have full access to all of the features of the Erlang system. This talk will give a brief description of the main properties of the Erlang VM and how Luerl implemented and how it can interact with the Erlang system. It will also show a simple example program demonstrating these features.

Shen: An API Gateway for mobile games using Lua + Erlang video
Johan Lövdahl (UXvibe)

Shen is an API gateway where new http endpoints can be added at run-time to handle requests. Request handlers are written in Lua and can be dynamically added/removed/updated. The framework is written in Erlang and the talk will focus on our experiences integrating Lua with Erlang; different approaches are evaluated and we present examples how this is used in our backend service for mobile games.

Improvements of LuaJIT for MIPS32 and MIPS64 platforms video
Stefan Pejic, Djordje Kovacevic (RT-RK)

This talk will give details of recent improvements for LuaJIT for MIPS32 and MIPS64. It will give insight to MIPS64 porting challenges, problems, as well as the excitement that were encountered in the process. Furthermore, it will give details on improvements done for MIPS32 port, namely MIPS32 soft-float support. In the end, it will present the validation process and final results.

Clang plugin for generating declarations for the LuaJIT FFI library video
Violeta Vukobrat (RT-RK)

LuaJIT compiler offers an efficient mechanism for calling external C functions and using C data structures inside Lua code, named LuaJIT FFI library. The FFI library requires C declarations of the functions and structures that will be used from Lua code. The talk will describe development of a tool that generates these declarations. It generates declarations for marked functions and structures in C code, using the functionalities offered by the Clang compiler.

Ravi slides video
Dibyendu Majumdar

Ravi is a modified version of Lua 5.3 that provides limited optional static typing and an LLVM based JIT compiler; these enhancements are done to improve the performance of Lua. I would like to talk about the implementation of Ravi. I hope to cover how the static typing is implemented, the JIT compilation approach, the challenges and compromises made to maintain compatibility with Lua, and finally the array extensions in Ravi, including example use cases and benefits of the approach.

Supporting Elephants with PostgreSQL and Lua video
Marc Balmer (micro systems)

The Basel Zoo is currently building a new structure to hold their african elephants: project tembea. Visitors to the zoo can support the project by becoming a mentor when they insert coins into a machine that has been custom built for this purpose: Two coin acceptors, one for children, one for adults (who pay double...) have been mounted on a steel frame together with a large LED display with 30cm high characters. The whole machinery has been installed in a large artificial rock which is, surrounced by elephant models painted in green and gold, a real eye-catcher and which already attracted more than 10'000 mentors. A large display shows the current number of mentors, this number is also visible on the webpage At the heart of this installation is a PostgreSQL database that holds the counter. The display, the coin acceptors, the webinterface and the SMS gateway are all separate programs written in the Lua programming lannguage. They are completely decoupled from each other by using PostgreSQLs asynchronous notification mechanism. And update of the counter value from whatever source, be it one of the coin acceptor processes, the sms gateway, or even a system administrator using psql, will cause a notification to be sent and the display and connected webbrowser to update the counter value (using websockets in the latter case). In this presentation, the "elephant mentoring machine" is briefly explained, as is the overall system architecture. Then the Lua PostgreSQL interface, written by the author and available under an open source license, is presented. It will be shown how Lua can be used to write complex and well-performing database applications with minimal code, but also how Lua and the PostgreSQL interface can be used to quickly prototype an application which will later be implemented in a different programming language. Lua is best known as a very efficient scripting language, it is, however, little known that it had been designed as a data-handling language. In conjunction with PostgreSQL and the feature-complete Lua-PostgreSQL-interface it is a ideal tool for data-centric application development.

Using Lua in a residential gateway video
Dirk Feytons (Technicolor)

In embedded (networking) devices C is no longer the default choice of implementation language. Lua has helped us do more in less time. This talk aims to give you an insight in what areas Lua outshines C and how we got there.

Ad-hoc big data analysis with Lua and LuaJIT slides video
Alexander Gladysh (LogicEditor)

Industrial big-data analysis tools like Hadoop are often unwieldy, cumbersome to use and expensive to maintain, especially if you're new to the field. It is well and good if you have a cluster set up and a handy team of engineers to maintain it. But what if you're a researcher, alone with a big dataset, a Linux machine (or, better, several) and no clue how to do Java? In this talk I will share a few handy tricks on how to quickly process and run preliminary analysis on large datasets with nothing more than LuaJIT and some shell magic.

Elasticsearch for Lua Developers slides video
Pablo Musa (Elastic)

Elasticsearch is a distributed and scalable data platform written in Java that, besides the transport protocol (Java to Java), offers a very complete REST API accessed through JSON. This talk will cover the details of the Elasticsearch client we built for Lua as a part of the GSoC program in the LabLua organization. By using the elasticsearch-lua client a programmer can access most Elasticsearch functionalities and benefit from: proper load balancing across all nodes with pluggable and multiple selection strategies; a connection pool; and the reindex feature (not available in Elasticsearch). We will also show two PoC. One PoC will show how this client could be used to implement a search feature in a website that is based on a SQL database, and the other PoC will show how a lot of data could be collected and indexed into Elasticsearch so easy and fast analytics can be performed.

Profiling Memory in Lua slides video
Pablo Musa (Elastic)

Memory bloat is a software problem that happens when the memory consumption of a program exceeds the programmer's expectations. In many cases, memory bloat hurts performance or even crashes applications. In this talk we present two tools created to help Lua programmers identify memory consumption problems. The first memory profiler we present is luamemprofiler, which was developed to explore three techniques: real-time visualization, type/class data categorization, and ongoing interaction. The second memory profiler we present is lmprof, which was created to explore gprof's largely used model which summarizes, after the main program execution, events based on function calls.

Tarantool - a Lua based database engine and in-memory data grid video
Konstantin Osipov (Tarantool)

I will focus on a practical use case: task queue application, using Tarantool as an application server and a database. The idea of the task queue is that producers put tasks (objects) into a queue, and consumers take tasks, perform them, mark as completed. The queue must guarantee certain properties: if a consumer failed, a task should return to the queue automatically, a task can't be taken by more than one consumer, priorities on tasks should be satisfied. With Tarantool, a task queue is a distributed networked application: there are multiple consumer/producer endpoints (hosts) through which a user can interact with the queue. The queue itself is a fault-tolerant distributed database: every task is stored in Tarantool database and replicated in multiple copies. If a machine goes down, the state of a task is tracked on a replica, and the user can continue working with the queue through a replica. Total power failure is also not an issue, since tasks are stored persistently on disk with transactional semantics. Performance of such an application is in hundreds of thousands of transactions per second. At the same time, the queue is highly customizable, since it's written entirely in Lua, is a Lua rock, but the code is running inside the database. This is the strength of Lua: one size doesn't have to fit all, and you don't have to sacrifice performance if you need customization. The second part of the talk will be about implementation details, performance numbers, a performance comparison with other queue vendors (beanstalkd, rabbitmq) in particular, and an overview of the implementation from language bindings point of view: how we make database API available in Lua, what are the challenges and performance hurdles of such binding.

High level application scripting with Enlightenment Foundation Libraries and LuaJIT video
Daniel Kolesa (Samsung Electronics UK Ltd)

The Enlightenment Foundation Libraries is a suite of graphics and other libraries for writing applications written in C. It's very lighweight and powerful, but its C API greatly reduces user friendliness; I aim to solve this problem by introducing a LuaJIT based scripting runtime into core EFL. This will allow everyone to write their applications easily in the Lua language, while having access to EFL APIs that are automatically generated and thus always up to date thanks to our elaborate language independent API description system.

At the end of the rainbow slides video
Ignacio Burgueño (inConcert)

First time I laid hands on a computer, it was a brazilian clone of the ZX Spectrum, an 8 bit computer from 1982. Many years ago, I wrote an emulator in C for it. So when Lua 5.3 came out with its fancy bitwise operators, the logical thing for me to do was to try to port it. In this talk I'll discuss the ins and outs of its development, the challenges faced and the places were Lua simplified the job enormously.

Always be testing slides video
Ignacio Burgueño (inConcert)

You just wrote a Lua module and would like to test it with different Lua versions? No problem. Is a mix of Lua and C? And you want to make sure it works with different compilers? Sure. And you want to test it with different operating systems? We got you covered. In this talk I'll give an overview of some of the available options in the continuous integration market and the benefits of running your tests automatically.

Experience of game prototyping with MOAI: from low-level to framework video
Dmitry Potapov (LogicEditor)

* Briefly: my reasons for choosing MOAI * Concept of game: tiled-based maze adventure + match-3 battles * Implementing basic parts: * Game model: Loop, maps, actors, abilities etc * Model controller: player action processing etc * GUI: manager, panels, map views, primitives, sprites, configs * Benefits of engine: * high quality of code * open source - self-documented, easy extension etc * support of tools: tiled, texture packer etc * can develop under Linux * Problems: * rather small community * lack of documentation (not so important since we have sources) * weak GUI frameworks * bugs in functionality * bugs in build scripts * Conclusion: Is the game worth the candle?

CodeFlow, an advanced IDE for Lua slides video
Jean-Luc Jumpertz (Celedev)

CodeFlow is an IDE that we have designed for interactively developing iOS applications in Lua. The idea of the talk is to put the focus on a few IDE features that could be of interest for a large part of the Lua community (at least for those who aren't allergic to the concept of IDE :). These highlights will cover: - a quick tour of what a real syntax-driven Lua source editor can bring, - a brief focus on Lua Environments, a powerful but often misunderstood feature of Lua since 5.2, showing how a builtin Lua Env support in the IDE can help the developer to use them effectively, - a discussion about how Lua modules are managed, and about the benefits of rewriting Lua 'require' function for matching specific needs, - an overview of the debugger which is an essential part of the system, associated with a stack-context-aware command line interface (i.e. that allows to use and modify local variables and upvalues of the selected Lua stack level) - a demo of interactive Lua-to-C bindings generation and how it is integrated with the rest of the IDE.