Lua Workshop 2017
will be held in San Francisco, CA,
on October 16–17, 2017,
courtesy of Kong.
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.
Register now to reserve a seat.
Please make your own travel and accommodation arrangements.
See the information on
last year's local page.
if you need help or have special requirements.
Registrations are now open.
There is no registration fee but registration is required
because space is limited.
To register to attend the workshop, please send a message to
including your full name and the name of your company or organization,
As confirmation, your name will appear in the
list of participants.
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.
Here is the preliminary schedule:
The workshop will be held at
the Kong HQ in the Financial District of San Francisco:
251 Post Street, 2nd floor, San Francisco CA 94108
The workshop is organized by
The organizers can be contacted at
- Charles Heywood
- Robert Burke (Cloudflare)
- Gary V. Vaughan
- Armando Galeana (Ubhuru Technologies)
- Michael Arnaldo Robayo
- Eric Wing (PlayControl Software)
- Akbar Pasha (Linden Lab)
- Chris Matzenbach (Banco do Brasil Americas)
- Shu Kit Chan (Yahoo)
- Rahul Varshney (Varshney And Sons)
- Roberto Ierusalimschy (PUC-Rio / Lua.org)
- Ana Lúcia de Moura (LabLua/PUC-Rio)
- Minh Hoang
- Hugo Gualandi (LabLua/PUC-Rio)
- Hisham Muhammad (Kong / LuaRocks.org)
- Andre Murbach Maidl (PUCPR)
- Patrick Donnelly (Red Hat, Inc.)
- Sricharan Vinnakota
- Gianna Scioletti (Alta Motors)
- Zac Nelson (Alta Motors)
- Robert Paprocki (Kong)
- Kurt Harriman
- Aapo Talvensaari (Kong)
- Enrique Garcia Cota (Kong)
- Taoufik Ennoure (Monroe College)
- Jim Mellander (Lawrence Berkeley National Laboratory)
- Rajive Joshi (RTI)
- Michael Trinkala (Mozilla)
- Noah Watkins (UC Santa Cruz)
- Michael Sevilla (UC Santa Cruz)
- Xin Xie (Apple)
- Thijs Schreijer (Kong)
- JP Keenan (Kong)
- Shashi Ranjan (Kong)
- Thibault Charbonnier (Kong)
- Gregory Aist (Telenav)
- Casey Carter (Telenav)
- Shalu Grover (Telenav)
- Reed Weichler
- Josh Enders (Pinterest)
- Gabriel Ligneul (CUJO)
- Lourival Neto (CUJO)
- Savio Sena (CUJO)
- Tomi Tavela
- Paulino Calderon (Websec)
- Pedro Tammela (CUJO)
- Doug Smith (Adobe)
- Noemi Rodriguez (PUC-Rio)
- Matt Widmann (Apple)
- Samuel Lepetit (Apple)
- Kynan Lalone (Pinterest)
- Jeff LeFevre (UC Santa Cruz)
- Asumu Takikawa (Igalia)
- Leaf Corcoran (itch.io)
- Marek Vavrusa (Cloudflare)
- Datong Sun (OpenResty)
- Chris Joy-Webb (Kong)
- Nate Bailey (Kong)
- Neil McKee (InMon Corp)
- Karen Inman (Kong)
- Yichun Zhang (OpenResty)
and Chris Matzenbach
(Banco do Brasil Americas)
IUP is the long-lived, cross-platform native GUI widget library, developed at PUC-Rio, the same university as Lua. IUP's thoughtful design keep it lightweight and fast (because it uses native GUI widgets) and also make it easy to bind other languages, such as Lua. Adoption of IUP should be great, but the lack of Mac OS X support has hindered it. It's time to fix this and bring IUP into the modern age. This talk will reveal my efforts to implement 4 new backends for IUP: Mac (Cocoa), iOS (CocoaTouch), Android, and a native web browser backend (via Emscripten).
How Much Does it Cost?
(PUC-Rio / Lua.org)
How much does a feature cost in a programming language? Frequently, when people propose new features for a software, the most common metric is lines of code. If a feature can be implemented in a few lines, why not add it? However, each feature has several hidden costs. Besides performance, features can have costs in documentation and testing. Some impair the conceptual integrity of the language, making it more difficult to learn. Some restrict alternative implementations. Some hinder its evolution, by narrowing unnecessarily the design space. In this talk, we will discuss these and other costs of adding features to a language, illustrating the discussion with several features already present in Lua.
The Titan Programming Language
In this talk we present Titan
, a new systems programming language that we are developing at LabLua to act as a sister language to Lua. Titan's design focuses on performance and is aimed at application development and as an alternative to some uses of C modules.
Efficient Layer 7 Search of IP Address Space in LuaJIT/OpenResty
Searching Internet Protocol (IP) address space has been a long-discussed topic in the context of network-layer services, with advancements in search algorithms coming decades ago. In application-layer contexts, such searches are relegated to second-class status, commonly executing in linear time, with many assumptions made about the request context and targeted search space. In Lua/OpenResty applications in particular, existing community implementations of IP address searching typically use an unoptimized linear search pattern, presenting a CPU bottleneck in high-concurrency environments. This talk features a discussion of existing IP space search implementations, both in theory and in practice, and unveils a new model designed to execute in a highly performant nature at scale, running in logarithmic time. We demonstrate the code flow (pure LuaJIT) and discuss the performance improvements and drawbacks over existing implementations. The discussion wraps with a performance analysis of existing vs. our implementation, using real-world examples of large CIDR block lists and traffic patterns.
What started as an experiment with the HTTP2 protocol has ended up being one of my more ambitious Lua projects. lua-http is a Lua library that offers http client and server functionality for both HTTP1, HTTP2 and websockets. It hopes to become the standard lua library for interacting with HTTP servers or clients. This talk will explore the lua-http API and demonstrate its use in a range of contexts.
Lua in the Ceph distributed storage system
(UC Santa Cruz)
Ceph is a massively distributed storage system offering object, file, and block abstractions, and is widely deployed within industry, academic, and scientific contexts. Lua is used within the Ceph file system to provide a mechanism for expressing load balancing policies, and within the object storage system to define dynamic transactional interfaces. This talk will provide an overview of the use of Lua within Ceph and where we would like to expand the integration.
Terrain-less Procedural Generation with Lua
Enrique Garcia Cota
Procedural Generation is used often to generate large amounts of content from a small(ish) set of rules. In videogames it's often applied to the generation of geographical / topological data. On this talk I would like to explore how Lua's expressiveness can be leveraged to generate other kinds of data.
Measuring Lua's Performance
Enrique Garcia Cota
On this talk I would like to explore the different ways there are for measuring the performance of a piece of code in Lua. We will visit common techniques and usual pitfalls, and also how the host application and the different Lua implementations influence the results.
Binding to YARA with LuaJIT
YARA is a tool aimed at (but not limited to) helping malware researchers to identify and classify malware samples. It offers command line tooling for developing signatures and examining samples, as well as a C API and bindings in several languages. This talk focuses on a Lua binding for YARA via LuaJIT's FFI capabilities. We will discuss the designs of the YARA API and it's performance implications in the context of LuaJIT FFI semantics, and the engineering effort needed to work around design limitations. We discuss the Lua API our library provides, and highlight performance benefits and implementation drawbacks for various environments, including OpenResty middleware/reverse proxy environments. The discussion wraps with an examination of future points of improvement in our binding library.
Lua's coroutines: the secret sauce in Nmap's Scripting Engine
(Red Hat, Inc.)
The Nmap Scripting Engine (NSE) is a powerful network security tool famous for its flexibility as well as its applicability to a broad range of network reconnaissance tasks. NSE's success is made possible by the Lua programming lanuage and its most underappreciated feature: coroutines. Through coroutines, NSE allows scripters to be blissfully ignorant of the mechanics of asynchronous network communication. This talk will cover how NSE makes this possible and some of the challenges and delights in orchestrating a symphony of scripts.
To type or not to type Lua
Andre Murbach Maidl
The main goal behind Typed Lua is to help Lua programmers catch bugs during the development phase. To do that we created a type system for Lua and implemented it as a type checker that programmers can use to annotate their code and run the compiler to check their programs. After type checking the generated code is pure Lua that runs on the unmodified Lua VM. During the design of Typed Lua we tried to accommodate several Lua idioms that are familiar to programmers such as the incremental evolution of tables and filters according to run-time type tags. However, some of these design decisions had impact on the usability of Typed Lua. In this talk we will reason about some of the challenges to type Lua along with their impact on the design and usability of Typed Lua. We will also discuss the relation and the migration of Typed Lua to the Titan language.
Safe browsing using Lua
CUJO is a smart firewall device designed to protect home networks. Among other features it allows users to browse websites safely on the Internet. For this, CUJO inspects HTTP(S) traffic for filtering both user's requests and website's responses. For example, it can prevent malwares from being downloaded or inappropriate content from being displayed for children (parental controls). This feature is implemented using Lunatik, that is Lua in the Linux kernel, and bindings for Netfilter/Iptables (NFLua) and for "zero-copy" memory (Luadata). In this talk we will discuss this implementation and show results on running it on thousands of active devices.
Navigating the smart card world with Lua
An argument for why Lua is a perfect tool for dealing with the nightmare of complexity that is the smartcard world, through an introduction to libse, a nascent Lua framework for wrangling smartcard interfaces. Includes an overview of standards such as ISO-7816, CCID, PC/SC, OpenPGP Smartcard, and PKCS#11; existing solutions such as OpenSC and GnuPG; and a discussion of the interoperability challenges which have hindered the open source community from fully embracing cryptographic hardware, stunting the commodification of these products and the emergence of a richer and more secure software ecosystem.