The evolution of Lua

  title={The evolution of Lua},
  author={Roberto Ierusalimschy and Luiz Henrique de Figueiredo and Waldemar Celes Filho},
  journal={Proceedings of the third ACM SIGPLAN conference on History of programming languages},
We report on the birth and evolution of Lua and discuss how it moved from a simple configuration language to a versatile, widely used language that supports extensible semantics, anonymous functions, full lexical scoping, proper tail calls, and coroutines. 

Figures and Tables from this paper

Moonlight Chords

This work studies chords through the implementation of a chords library in Lua, a high level synchronization construction adequate for multithreaded environments.

A look at the design of Lua

Simplicity, small size, portability, and embeddability set Lua apart from other scripting languages.

Silmaril, A Functional Language for Distributed Parallel Evaluation

Formal program syntax, evaluation semantics and typing rules are presented, along with examples of the networked revision-control system and introspective capabilities, for a modern high-level language for implicit parallel distributed computing.

Contrasting compile-time meta-programming in metalua and converge.

This paper describes and compares two modern, dynamically typed languages Converge and Metalua, which both have macro-like systems, and shows how, in different ways, they build upon traditional macro systems to explore new ways of constructing programs.

Thorn: robust, concurrent, extensible scripting on the JVM

The principal contributions are a careful selection of features that support the evolution of scripts into industrial grade programs - e.g., an expressive module system, an optional type annotation facility for declarations, and support for concurrency based on message passing between lightweight, isolated processes.

Concurrency Oriented Programming in Lua

A system that provides Erlang-style concurrency has been designed and implemented for the Lua programming language and will help further change the view on the way to achieve concurrency.

OCamlJIT 2.0 - Faster Objective Caml

The current state of an ongoing research project to improve the performance of the OCaml byte-code interpreter using Just-In-Time native code generation is presented, its design and implementation is described, and performance measures are given.

Reflection-based language support for the heterogeneous capture and restoration of running computations

This work is devoted to the study of the problem of user-level capture and restoration of running computations in heterogeneous environments. Support for those operations has traditionally been

Reflection-Based Heterogeneous Migration of Computations

This work extends the Lua programming language with a reflective API that provides the programmer fine control over the capture and restoration mechanisms, and achieves flexibility through computational reflection.


This paper takes the Lua programming language and explains the mechanisms it offers to support embedding concurrency, and shows how these mechanisms can be useful for creating lightweight concurrency models.



The Evolution of an Extension Language: A History of Lua

The trajectory of Lua is described, from its creation as an in-house language for two specific projects, until Lua 4.0, released in November 2000, which discusses the evolution of some of its concepts and the main landmarks in its evolution.

Lua—An Extensible Extension Language

This paper describes Lua, a language for extending applications. Lua combines procedural features with powerful data description facilities, by using a simple, yet powerful, mechanism of tables .

The Implementation of Lua 5.0

We discuss the main novelties of the implementation of Lua 5.0: its register- based virtual machine, the new algorithm for optimizing tables used as arrays, the implementation of closures, and the

Coroutines in Lua

This paper presents and discusses the corou- tine facilities provided by the language Lua, a full implementation of the concept of asymmetric coroutines, and shows that this powerful construct supports easy and succint implementations of useful control behaviors.

Lua 5.1 Reference Manual

Lua is an extension programming language designed to support general procedural programming with data description facilities. It also offers good support for object-oriented programming, functional

Domain-specific languages: an annotated bibliography

The literature available on the topic of domain-specific languages as used for the construction and maintenance of software systems is surveyed, and a selection of 75 key publications in the area is listed.

Lua-An Extensible Extension Language

Lua presents a mechanism offallbacks that allows programmers to extend the semantics of the language in some unconventional ways, as a noteworthy example, fallbacks allow the user to add different kinds of inheritance to the language.

Revised5 Report on the Algorithmic Language Scheme

The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis

Closure Generation Based on Viewing Lambda as Epsilon Plus Compile

Revised 6 Report on the Algorithmic Language Scheme

This document describes rationales for some of the design decisions behind the Revised Report on the Algorithmic Language Scheme. The focus is on changes made since the last revision on the report.