Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

Why choose Lua?

Lua is a proven, robust language:

Lua has been used in many industrial applications (e.g., Adobe's Photoshop Lightroom), with an emphasis on embedded systems (e.g., the Ginga middleware for digital TV in Brazil) and games (e.g., World of Warcraft). Lua is currently the leading scripting language in games. Lua has a solid reference manual and there are several books about it. Several versions of Lua have been released and used in real applications since its creation in 1993. Lua featured in HOPL III, the Third ACM SIGPLAN History of Programming Languages Conference, in June 2007.

Lua is fast:

Lua has a deserved reputation for performance. To claim to be "as fast as Lua" is an aspiration of other scripting languages. Several benchmarks show Lua as the fastest language in the realm of interpreted scripting languages. Lua is fast not only in fine-tuned benchmark programs, but in real life too. A substantial fraction of large applications have been written in Lua.

Lua is portable:

Lua is distributed in a small package and builds out-of-the-box in all platforms that have an ANSI/ISO C compiler. Lua runs on all flavors of Unix and Windows, and also on mobile devices (such as handheld computers and cell phones that use BREW, Symbian, Pocket PC, etc.) and embedded microprocessors (such as ARM and Rabbit) for applications like Lego MindStorms.

For specific reasons why Lua is a good choice also for constrained devices, read this summary by Mike Pall. See also a poster created by Timm Müller.

Lua is embeddable:

Lua is a fast language engine with small footprint that you can embed easily into your application. Lua has a simple and well documented API that allows strong integration with code written in other languages. It is easy to extend Lua with libraries written in other languages. It is also easy to extend programs written in other languages with Lua. Lua has been used to extend programs written not only in C and C++, but also in Java, C#, Smalltalk, Fortran, Ada, Erlang, and even in other scripting languages, such as Perl and Ruby.

Platform: Cross platform                License:MIT License

Reference:https://www.lua.org/about.html

lua-TestMore is a port of the Perl5 module Test::More.

Platform: OS Independent; License: MIT/X Consortium License

Reference: https://luaforge.net/projects/testmore/

LuaUnit is a unit testing framework modeled after Python unit testing framework.

Platform: OS Independent; License: Public Domain

Reference: https://phil.freehackers.org/programs/luaunit/

lunit is a unit testing framework for Lua, written in lua. It provides currently 27 assert functions, 8 type checking functions and a few miscellaneous functions for usage as an easy unit testing framework.

Platform: OS Independent; License: MIT License

Reference: http://www.nessie.de/mroth/lunit/

Shake is a simple test engine for Lua that assumes that tests only use assert() and print() calls. If you are looking for something similar to JUnit, check lunit and luaunit instead. Shake depends on Leg and LPeg.

Platform: Cross-platform; License: MIT/X Consortium License

Reference: https://luaforge.net/projects/shake/

LuaJIT is a Just-In-Time (JIT) Compiler for Lua. It's fully compatible with standard Lua 5.1 and can significantly boost the performance of your Lua programs. LuaJIT is open source software, released under the MIT/X license. LuaJIT builds out-of-the-box on all popular x86 operating systems (Linux, Windows, OSX etc.). It runs fine as a 32 bit application under x64-based systems, too. "Since its first release in 2005, LuaJIT has been at the forefront of dynamic language performance. In 2008 Mike Pall announced that he was working on a complete rewrite based on trace compiler technology. It breaks with a long tradition of method-at-a-time JIT compilers and seems especially well suited for compiling dynamic languages. As LuaJIT shows, this approach yields performance that can rival even offline, static language compilers."

Platform: Cross-platform; License: MIT/X license

Reference: https://www.ditii.com/2010/01/21/luajit-just-in-time-jit-compiler-for-lua-dynamic-language/

LLVM-Lua, is a JIT and static Lua compiler that uses Low Level Virtual Machine (LLVM) as the compiler backend.

Platform: Cross-platform; License: MIT License

Reference: https://code.google.com/p/llvm-lua/

luac is the Lua compiler. It translates programs written in the Lua programming language into binary files that can be loaded and executed with lua_dofile in C or with dofile in Lua.

Platform:unknown                       License:unknown

Reference:https://www.lua.org/manual/4.0/luac.html

LuaDec for Lua  is a Lua decompiler targeting lua

It is based on Hisham Muhammad's luadec which targeted lua

LuaDec is free software and uses the same license as the original LuaDec

Platform: Windows NT/2000; License: MIT License

Reference: https://luadec51.luaforge.net/

Lua for Windows (LfW) combines Lua binaries, Lua libraries with a Lua-capable editor in a single install package for the Microsoft Windows operating system. LfW contains everything you need to write, run and debug Lua scripts on Windows. A wide variety of libraries and examples are included that are ready to use with Microsoft Windows. LfW runs on Windows 2000 and newer versions of Windows. Lua and its associated libraries are also available for other operating systems, so most scripts will be automatically cross-platform.

Platform: Windows; License: MIT License

Reference: https://code.google.com/p/luaforwindows/