Lua Implementations

wiki

Reimplementations of Lua compilers and interpreters: (sorted by target/host platform)

• ANSI C / Lua Bytecodes
  • [Lua] (5.1) - Compiles Lua source to standard Lua bytecodes. Lua VM interprets Lua bytecodes. Implemented in ANSI C. This is the standard reference implementation of Lua. Highly robust.
• x86, x64, ARM, PPC, MIPS
  • [LuaJIT] (5.1) - A just-in-time (JIT) compiler for Lua 5.1. Much better performance [1].
  • [LJX] (5.2/5.3) - Experimental fork of LuaJIT 2.1 implementing 5.2+ API/ABI and [various other hacks].
• LLVM (JIT)
  • LlvmLua (5.1) - Converts Lua bytecode to LLVM IR code. Supports both JIT and static compiling. Limited to the CPUs LLVM supports. Implemented in C/C++.
• Lua
  • [Yueliang] (5.1/5.0) - Compiles Lua source to standard Lua byte codes. Implemented in Lua. This is a no-brainer port, but it also includes an optional more native style port of the parser/lexer.
  • [LuLu] (5.1) - Lua 5.1 VM implemented in Lua. Implements a VM interpreter and coroutine library, but reuses the host Lua environment for data types and standard library functions.
  • [Metalua] (5.1) - Compiles a superset of Lua, supporting Lisp-style macros and syntax extensions, to standard Lua bytecodes. Implemented in Lua (with some C). Parser (source -> AST translator), which is reusable separately, implemented in Lua via the gg parser translator (implemented in Lua), which is partially based on Yueliang.
  • See also LuaCompilerInLua, LuaInterpreterInLua, StringLibraryInLua
• Java
  • [Kahlua][24] (5.1) - Virtual Machine and compiler for (a subset of) Lua in Java J2ME (CLDC 1.1). Implemented in Java. VM interprets standard Lua bytecodes. Uses Java's garbage collection[2]. [Differences] Compiler forked from LuaJ.
  • [Mochalua] (5.1) - Lua virtual machine, libraries and API ported to Java J2ME CLDC 1.1 [25]. VM interprets standard Lua bytecodes.
  • [luaj] (5.1) - Lightweight, fast Java-centric Lua interpreter written for both J2ME and J2SE, including libraries for basic, string, table, package, math, coroutine packages, an optional compiler, luajava bindings, and [JSR-223] pluggable scripting engine bindings

  Lua 5.2 support as of version 3.0, which is in Beta at this time (2014-01-18).

  • [Jill] (5.1) - Java Implementation of Lua Language. Originally produced under a commercial contract, now open source. VM, compiler, API, and libraries running on JME CLDC 1.1. VM interprets standard Lua bytecodes. The libraries exist to the extent that CLDC supports them (no io.*, and math.* is reduced). Runs on JSE as well. 33 classes.
  • Older: [JLua] [jua]
• .NET
  • [LuaCLR] - (5.1) Compiles Lua source to .NET CLR. Implemented in Lua.
  • [Lua2IL] Note: Link dead 14/10/13- (5.0) Translates Lua 5.0 bytecodes to .NET CLR (IL instructions). This is the precursor of LuaCLR. [3] (FIX:what is the translator implemented in?)
  • [Nua] (5.1) - Compiles Lua source to the .NET Dynamic Languages Runtime (DLR). Implemented in C#. [4]
  • [XNua] NOTE: link dead 14/10/13 - (5.1). Compiles Lua source to .NET bytecodes (particularly Xbox 360). Implemented in C#. Uses .NET's garbage collection[5] and has other differences/limitations[6].
  • [Kopi Lua] - (5.1) A line-for-line port of the Lua source code (compiler, VM, GC, libraries etc.) to C#. Byte-code compatible with the C version.
  • [SharpLua] - A Lua implementation in C# based off of Lua 5.1.5.
  • [AluminumLua] - "A fast, lightweight Lua scripting engine written entirely in C#."
  • [Quorra] - Aims to provide full functionality and compatibility with Lua in .NET / Mono
  • [UniLua] - (5.2) A pure C# implementation of Lua 5.2 focus on compatibility with Unity3D.
  • [NLua] - (5.1.5/5.2.2) A mix of C# implementation with native binding, compatible with .NET/iOS/Android/WinPhone?.
  • [NeoLua] - NeoLua?, A Lua 5.2 implementation for the Dynamic Language Runtime (DLR).

• Parrot VM
  • [Parrot VM] (5.1) - Compiles Lua source to Parrot VM byte codes (PMC). Implemented in Perl. Standard libraries implemented in PIR[7]. [SVN]
• C API
  • LuaToCee (5.1) - Translates Lua source to C API calls. Implemented in Lua (based on Metalua's parser implemented in Lua).
  • [luac2c] (5.1) - Translates Lua byte codes to C API calls. Implemented in Lua.
• JavaScript
  • [Lua2js] - Initial work[8][26][27] (5.1) - Translates Lua subset to JavaScript. Implemented in Lua.
  • [lua.js] - converts Lua code directly to ECMAscript or ActionScript.
  • [ljs] - Lua VM implemented in JavaScript, in development
  • [js-lua] - Uses aelua, a GWT (Java to JavaScript compiler) port of Jill, a Lua implementation in Java.
  • [brozula] - LuaJIT bytecode compiler generating ES5 JavaScript.
  • See also [9] LuaList:2009-10/msg00764.html LuaList:2010-07/msg00560.html
• ActionScript - variant of JavaScript included in Flash.
  • [flua] (5.0) NOTE: link dead 14/10/13 - Lua 5.0 VM in ActionScript. VM interprets standard Lua bytecodes. Implemented in ActionScript.
  • [lua-alchemy][Lua under Alchemy][28] (5.1) - Standard Lua 5.1 compiler and VM implemented in ActionScript (Flash variant of JavaScript) with inline AVM2 bytecodes in an .swc file. This .swc was machine translated from the standard Lua sources using Alchemy[10][11], which is a backend to LLVM[12]. (So, this is not a manual reimplementation but rather an interesting machine translation.) [example:Phyzios]
  • [lua.js] - converts Lua code directly to ECMAscript or ActionScript.
• Leonardo VM
  • [LuaLeo] (3.1) - Lua implemented on [Leonardo VM]
• OCaml
  • [Lua-ML] (2.5) - Lua 2.5 interpreter. Implemented in Objective Caml.
• Erlang
  • [luerl] - Lua implemented in Erlang, by Robert Virding, one of the creators of Erlang. [13][14]
• Go
  • [goluago] - port of the Lua 5.1 interpreter to the Go Language Toolchain (first 8c/6c/5c, ultimately maybe pure Go) -- preliminary [29]

Reimplementations only of the Lua lexer or parser (no code generator or VM):

• See LuaGrammar.

Bindings to Standard Lua:

• BindingCodeToLua

Other languages implemented in Lua:

• Lisp:
  • [LuaLisp] (5.0?)
  • [Mun] (5.1) Lisp on Lua (sorta)
  • Related: [lcl] (Lhf);
  • [ClojureScript/Lua] NOTE: link dead 14/10/13- backend for ClojureScript that targets Lua. Still requires Java for the compiler.
• Forth: see "Chapter 6: Boostraping a Forth in 40 lines of Lua code" by EduardoOchs in Lua Programming Gems (see LuaBooks) [15] (5.1)
• ANSI C: [Clue] (5.1) - Translates C to Lua source code. Implemented in C, using sparse[16], which is also implemented in C.
• Lua: see Yueliang above (5.1)
• [MoonScript] - Language inspired by [CoffeeScript]. Compiles to Lua source.
• [number-lua] NumberScript to Lua converter (based on [JavaScript NumberScript]) - [esoteric] programming language using only numbers. LuaList:2012-06/msg00627.html
• [Gaia] (5.1) - Gaia aims to provide a parser and bytecode generator for the Lua VM to aid in targetting the Lua VM as a runtime for other dynamic languages. At this stage only Lua 5.1 is supported.
• [Lupa] (Luajit) - Lupa - multi-paradigm object oriented, dynamic language.
• [Nyanga] (Luajit) - Nyanga - Object Oriented Lua Dialect.

Languages based on Lua

These languages are based on the Lua implementation (e.g. adapted VM).

• Agena[17][30] - based on Lua C source, but has significant syntax differences
• Idle[18]
• Dao[19][31][32]
• [LuaPlus] - based on 5.0work, no longer appears maintained
• Bright[20][21] - more C like syntax, based on Lua 4.0, no longer appears maintained
• Squirrel[22]
• [SquiLu] - A mix between Squirrel and Lua, trying to get the best of both.
• Objective Lua[23]
• Python: [tinypy] - a small subset of Python written in the style of Lua (but not based on Lua code).
• MetaLua - brings compile-time metaprogramming to Lua. Compiles to standard Lua 5.1 bytecodes.
• [Killa]: a scripting language based in Lua 5.2 with a JavaScript-like syntax

Lua test suites

For test suites to check the correctness of Lua implementations, see UnitTesting.

See Also

• LuaDistributions / LuaBinaries - These are compilations or adaptations of Lua to different platforms. These differ from the above in that they are not complete reimplementations of Lua but rather have minor or no changes to the Lua source code.