Resources

• Complementary lists

  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • awesome-lua - A curated list of quality Lua packages and resources.
  • nginx-resources
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Curlie: Lua - Collection of sites about Lua
  • Lua Tutorials and Courses - Top about Tutorials and Courses
  • Topics/Lua - See more topics about Lua
  • Topics/LuaJIT - See more topics about LuaJIT
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • awesome-resty - A list like this one, but focused on OpenResty.
  • awesome-torch
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • awesome-love2d - A list like this one, but focused on game dev and the LÖVE platform.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.
  • Where Lua is Used - A comprehensive list of stand-alone programs written in or extensible using Lua.

• Lua VM in Lua

  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • LuLu - a Lua 5.1 VM implementation in Lua language itself. Implements a VM interpreter and coroutine library, but reuses the host Lua environment for data types and standard library functions.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • LuLu - a Lua 5.1 VM implementation in Lua language itself. Implements a VM interpreter and coroutine library, but reuses the host Lua environment for data types and standard library functions.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • LuLu - a Lua 5.1 VM implementation in Lua language itself. Implements a VM interpreter and coroutine library, but reuses the host Lua environment for data types and standard library functions.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • LuLu - a Lua 5.1 VM implementation in Lua language itself. Implements a VM interpreter and coroutine library, but reuses the host Lua environment for data types and standard library functions.
  • Yueliang - Lua 5 in Lua 5 (5.0 and 5.1). The focus is on the front end of Lua, i.e. the lexical analyzer, the parser and the code generator, in order to generate binary chunks.
  • LuaVM - Lua Virtual Machine (and various tools) for Lua
  • LuaJIT Language Toolkit - an implementation of the Lua programming language written in Lua itself, as a starting point to implement a programming language that targets the LuaJIT virtual machine.

• Dialects, flavors and implementations

  • Céu - a reactive language that aims to offer a higher-level and safer alternative to C. “Structured Synchronous Reactive Programming”
  • Lua Implementations - Reimplementations of Lua compilers and interpreters.
  • SquiLu - A mix between [Squirrel](http://squirrel-lang.org/) 3.0.4 and Lua 5.1.5, trying to get the best of both. Squirrel scripting language modified with lua libraries
  • Céu - a reactive language that aims to offer a higher-level and safer alternative to C. “Structured Synchronous Reactive Programming”
  • Lua Implementations - Reimplementations of Lua compilers and interpreters.

• Lua 5.1

  • LuaJIT - High-performance Just-In-Time compiler for Lua.
  • Agena - based on Lua 5.1 C source, but has significant syntax differences
  • LuaJIT - High-performance Just-In-Time compiler for Lua.
  • LuaJIT 2 - OpenResty's Branch of LuaJIT 2 (fork)
  • RaptorJIT - A dynamic language for system programming (LuaJIT fork for Linux/x86-64 server applications)
  • Moonjit - JIT Compiler for the Lua. Fork of LuaJIT to continue development
  • LuaVela - an implementation of Lua 5.1 based on LuaJIT 2.0, for Linux x86-64 only.
  • LjTools - LuaJIT Assembler/Disassembler - Tool to study LuaJIT 2.0 Bytecode with GUI
  • Shine - a general purpose, dynamic, multi-paradigm programming language which is based on a [modified version](https://github.com/richardhundt/tvmjit) of the LuaJIT VM with features geared more to programming in the large.
  • Metalua - a compiler for a superset of the Lua 5.1 language, which supports compile-time metaprogramming.
  • Typed Lua - An Optional Type System for Lua
  • Typed Lua + OO Support - A Class System for Typed Lua
  • Firth - pre-alpha-1-a-forth-like-language-for-dsl-creation/) - A simple Forth-like language intended for DSL creation, implemented in Lua.
  • Typed Lua + IDE Support
  • Idle - At the core of Idle sits a tweaked and significantly enhanced version of Lua 5.1. Includes a GUI module, built from scratch; usable ("good enough") to create simple GUIs and dialog boxes.
  • GSL Shell - an interactive command line interface that gives easy access to a collection of numeric algorithms and functions based on the GNU Scientific Library (GSL).

• Lua 5.3

  • Titan - a system programming language, designed to be a statically-typed, ahead-of-time (AOT) compiled sister language to Lua, focused on performance. It is designed to seemlessly interoperate with Lua.
  • Pallene - rio.br/~roberto/docs/pallene-sblp.pdf) [[Slides]](https://gligneul.github.io/luaworkshop2018/) - a statically typed, ahead-of-time (AOT) compiled sister language to Lua, with a focus on performance. Pallene is also designed to seamlessly interoperate with Lua.
  • Ravi - ZOBHw1Mk2U) - a derivative of Lua 5.3 with limited optional static typing and features LLVM and Eclipse OMR powered JIT compilers.
  • golua - A Lua 5.3 engine implemented in Go by Azure
  • DCLua - A Lua 5.3 VM and compiler written in Go.
  • Jual - an embeddable Virtual Machine (VM) that implements the JualScript language (a subset of ECMA Script or JavaScript). The implementation is derived from Lua 5.3.
  • Jual - an embeddable Virtual Machine (VM) that implements the JualScript language (a subset of ECMA Script or JavaScript). The implementation is derived from Lua 5.3.

• Compiles to Lua

  • MoonScript - A programmer friendly language that compiles to Lua 5.1.
  • Fennel - a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.
  • Urn - a Lisp dialect with a focus on minimalism which compiles to Lua.

• Package Managers

  • ULua - Universal Lua Distribution
  • LuaPlus - Full LuaPlus distribution (fork of Lua 5.1) for Windows
  • LuaRocks - De-facto tool for installing Lua modules as packages called "rocks", public rock repository and website.
  • LuaPower - the LuaJIT distribution for Windows, Linux and OS X

• IDE, Plugins and text editor

  • SciTE - a SCIntilla based Text Editor, with embedded Lua interpreter.
  • vscode-lua - VSCode intellisense and linting.
  • Textadept - A fast, minimalist, and remarkably extensible cross-platform text editor
  • ZeroBrane Studio - a lightweight Lua IDE with code completion, syntax highlighting, live coding, code analyzer, and debugging support for Lua 5.x, LuaJIT, and other Lua engines.
  • Howl Editor - A general purpose, fast and lightweight editor with a keyboard-centric minimalistic user interface. Built on LuaJIT and fully programmable using Lua or Moonscript.

• Data structures

  • binarystream - Lua library to work with binary data (needs ffi support)
  • lua-users: Data Structures - Here are implementations of various data structures in Lua or related discussions.
  • array.lua - A small library with useful methods to handle Lua's table when it's working like an Array
  • lua-users: Data Structures - Here are implementations of various data structures in Lua or related discussions.
  • Tuple - Tuple of Values for Lua.

• Programming Paradigms

  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • FRLua - Functional Reactive programming capabilities in Lua.
  • RxLua - Reactive Extensions for Lua
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • 30log - a small class system for OOP in Lua
  • middleclass - A simple OOP library for Lua. It has inheritance, metamethods (operators), class variables and weak mixin support.
  • PLoop - a C# like style object-oriented program system for lua.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • Luvent - Simple Event Library for Lua
  • lua_async - Asynchronous and event driven programming in lua
  • toynet - A simple event-driven I/O for Lua, coroutine based.
  • lua-reactor-light - Lightweight lua reactor. Depends only on luasocket and exposes NodeJS-style API
  • Lua Fun - a high-performance functional programming library for Lua
  • Moses - Utility library for functional programming in Lua
  • lamda - A functional programming library for Lua, inspired by Ramda.
  • Safer - Paranoid Lua programming
  • LOOP - Class Models for Lua
  • Reactor design pattern
  • lua-reactor - React-style ui component system for Lua

• I/O

  • lunary - A binary format I/O framework for Lua.
  • lua-nixio - a multi-platform library for IPv4, IPv6 and UNIX networking, POSIX user/group management, TLS support. System, Networking and I/O library for Lua.
  • LuaSys - a portable Lua library providing access to system and networking functions.

• [CLI](https://luarocks.org/labels/commandline)

  • Readline - Interface to the readline library
  • linenoise - A small self-contained alternative to readline and libedit.
  • lcurses - curses Terminal Screen Control
  • LTUI - A cross-platform terminal ui library based on Lua
  • ljlinenoise - a pure LuaJIT port of [linenoise](https://github.com/antirez/linenoise), a small alternative to readline and libedit.

• Network

  • LuaSocket - Network support for the Lua language
  • lua-httpclient - a unified wrapper around a ``openresty/ngx.location.capture`` or ``luasocket`` and ``luasec`` as drivers.
  • lua-websockets - This project provides Lua modules for Websocket Version 13 conformant clients and servers.
  • Lua-cURLv3 - Lua binding to libcurl
  • Turbo - a asynchronous networking suite and framework built for LuaJIT 2 to building fast and scalable network applications. It uses a event-driven, non-blocking, threadless design.
  • lua-handlers - Provides a set of async. callback based handlers for working with raw TCP/UDP socket, ZeroMQ sockets, or HTTP client/server. You can get node.js style non-blocking IO with lua-handlers.
  • lua-http - HTTP Library for Lua. Supports HTTP(S) 1.0, 1.1 and 2.0; client and server.
  • Ratchet - The purpose of the ratchet library is to provide in Lua an asynchronous socket control mechanism for large numbers of sockets without using OS-level threads or losing the ease of synchronous socket programming.
  • lsocket - simple and easy socket support for lua.
  • llsocket - low-level socket module [this module is under heavy development]
  • lua-resty-socket - A module offering interoperability between the LuaSocket and cosocket APIs
  • lua-net - Lua networking library that wraps around lua-socket to make networking easy.
  • dromozoa-socks - Toolkit for network and I/O programming

• Database drivers

  • LuaSQL - a simple interface from Lua to various DBMS. Connect to ODBC, ADO, Oracle, MySQL, SQLite, Firebird and PostgreSQL databases.
  • LuaDBI - Multi-backend SQL database interface library for Lua. It is designed to provide a RDBMS agnostic API. Supports DB2, Oracle, MySQL, PostgreSQL and SQLite databases with native database drivers.
  • LuaSQLite3 - a Lua wrapper for the SQLite3 library.
  • PL/Lua - an implementation of Lua as a loadable procedural language for PostgreSQL.
  • pgmoon - a PostgreSQL client library written in Lua for OpenResty
  • Tarantool - is an in-memory database and application server.
  • Redis - A Lua client library for the Redis key value storage system.
  • lredis - a Redis (in-memory data structure store) client library for Lua
  • LuaSQLite3 - a Lua wrapper for the SQLite3 library.

• Multitasking

  • Threads
  • comparison of options
  • lua-users: MultiTasking
  • lua-llthreads - Low-Level threads (pthreads and WIN32 threads) for Lua.
  • lua-llthreads2 - drop-in replacement for ``lua-llthreads`` library with several additional functionality.
  • luaproc - rio.br/~roberto/docs/ry08-05.pdf) - multi-threading library. Message-passing model which allows multiple threads per OS thread.
  • Lua Lanes - a lightweight, native, lazy evaluating multithreading library for Lua 5.1 to 5.4. Library implementing a message passing model with one OS thread per Lua thread.
  • ltask - lua multi task library, use n os thread for m lua states.
  • Effil - Multithreading support for Lua. It allows to spawn native threads and safe data exchange.
  • Lumen - Simple concurrent task scheduling.
  • Coil - A tiny cooperative threading module for Lua.
  • comparison of options
  • lua-users: MultiTasking
  • coroutines - preempted form of [concurrency](https://en.wikipedia.org/wiki/Concurrent_computing) known as [cooperative multitasking](https://en.wikipedia.org/wiki/Cooperative_multitasking). This means that coroutines provide concurrency but not [parallelism](https://en.wikipedia.org/wiki/Parallel_computing).
  • Copas - Dispatcher based on coroutines that can be used for asynchronous networking. (It uses LuaSocket for TCP/IP stack and LuaSec for SSL support)
  • cqueues - Embeddable asynchronous networking, threading, and notification framework for Lua on Unix. Library for managing sockets, signals, and threads based on an event loop with coroutines.

• Native OS APIs

  • luaposix - Lua bindings for POSIX APIs.
  • luapower/winapi - Windows, common controls and dialogs, message loop and system APIs for LuaJIT.
  • winapi - Minimal Windows API
  • lua-win32lib - Small lib exposing some Win32 API to lua
  • w32wrappers - Wrappers for Win32 API functions & constants.
  • win32_api_luajit - Cosmin's win32 api for luajit (with adjustments)
  • ljsyscall - Unix system calls for LuaJIT
  • minisock - a minimal Lua socket library for unix / tcp / udp connections. The API is very close to the standard Unix system calls.
  • lunix - Bindings to common Unix system APIs, striving for thread-safety.
  • luaunix - A Lua Binding for Selected Unix functions and System Calls
  • dromozoa-unix - Lua bindings for UNIX system interface

• Libraries

  • Libraries And Bindings - a list of libraries implemented in Lua or implemented in another language (e.g. C) but having a Lua interface.
  • LPeg - a new pattern-matching library for Lua, based on Parsing Expression Grammars (PEGs). [[1]](http://www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf) [[2]](http://www.inf.puc-rio.br/~roberto/docs/ry10-01.pdf)
  • LuaWebDriver - code.com/blog/2018/11/6.html) - a browser automation library using WebDriver API.
  • LuaCS - code.com/blog/2018/5/23.html) - a CSS Selectors parser library for Lua
  • XMLua - code.com/blog/2017/12/25.html) - An user-friendly XML/HTML processing library for Lua based on libxml2
  • luaexpat - a SAX XML parser based on the Expat (a stream-oriented XML parser) library.
  • LuaExpatUtils - Utilities for working with LOM XML Documents
  • luapower/expat - A ffi binding for the Expat XML parser.
  • lua-cjson - Lua CJSON is a fast JSON encoding/parsing module for Lua
  • neturl - A Robust URL Parser (with the ability to parse querystrings) and Builder for Lua.
  • lucihttp - HTTP utility library with Lua binding9
  • LPegLabel - a conservative extension of the ``LPeg`` library that provides an implementation of Parsing Expression Grammars (PEGs) with labeled failures.
  • lpeg_patterns - A collection of LPEG patterns
  • luatz - Time, Date and Timezone library for lua
  • Libraries And Bindings - a list of libraries implemented in Lua or implemented in another language (e.g. C) but having a Lua interface.
  • lualinq - Lightweight library which allows functional querying and transformation of lua arrays and objects

• Utilities

  • LuaTools - tools for use with Lua. Some of these tools written in Lua.
  • Allen - An utility library to manipulate strings, which provides a set of helpers for strings operations for Lua.
  • Strictness - a small module to track access and assignment to undefined variables in Lua
  • Serpent - Lua serializer and pretty printer.
  • lua-marshal - fast table serialization for Lua
  • LuaTools - tools for use with Lua. Some of these tools written in Lua.
  • base2base - A pure Lua base-to-base converter

• Miscellaneous

  • Prosody - a server for Jabber/XMPP written in Lua.
  • Penlight - A set of pure Lua libraries focusing on input data handling, functional programming, and OS path management. Inspired by the Python standard libraries.
  • Microlight - A little library of useful Lua functions, intended as the 'light' version of Penlight
  • Carbon - a full suite intended to make Lua more semantic, expressive, and powerful. It aims to provide a set of functionality comparable to .NET, and runs on Lua 5.1 and LuaJIT on any platform.
  • lua-ext - Standard library / extensions for Lua. math, operator functions, execution platform, Set implementation for Lua, I/O on strings; instead of files.
  • lua-apr - Apache Portable Runtime binding for Lua. APR powers software and makes the APR operating system interfaces available to Lua, serving as an extended standard library, focus in Threads, Processes, Directories.
  • Kong - a cloud-native, fast, scalable, and distributed Microservice Abstraction Layer (also known as an API Gateway, API Middleware or in some cases Service Mesh).
  • Snabb Switch - a simple and fast packet networking toolkit.
  • Telize - a High performance REST API built on Nginx and Lua allowing to get a visitor IP address and to query location information (IP Geolocation).
  • MoonGen - a fully scriptable high-speed packet generator built on [DPDK](https://en.wikipedia.org/wiki/Data_Plane_Development_Kit) and LuaJIT.
  • Luno - General purpose libraries for Lua.
  • lua-glib - glib/raw/b8e99210f24587b25602009e575d70221552436e/lua-glib.html) - Yet another Lua-to-glib binding. This package wraps the GLib library fairly thinly. It is meant to be a portability and utility library.
  • LGI - Dynamic Lua binding to GObject-based libraries using [GObject-Instrospection](https://gi.readthedocs.io/). Allows using GObject-based libraries directly from Lua.
  • lgob - lgob provides bindings of GObject-based libraries (like GTK+ and WebKitGTK+), for Lua 5.1 / 5.2 / LuaJIT. It consists of a compiler that parses [GObject-Instrospection](https://gi.readthedocs.io/) [gir files](https://github.com/gtk-rs/gir-files) and generates Lua modules.

• Asynchronous I/O

  • Luvit - Lua + libUV + jIT = pure awesomesauce
  • Luver - a ``luvit`` without ``lit``.
  • LuaNode - Asynchronous I/O for Lua, using the [Reactor pattern](https://en.wikipedia.org/wiki/Reactor_pattern) like Node.js, EventMachine or Twisted.
  • node-lua - a runtime environment and server engine for lua-based scripting that runs on multi-core machines in a multi-threaded manner.
  • Node.lua - a Lua runtime environment that uses an event-driven, non-blocking I/O model like Node.js
  • Lua Corovel - Asynchronous, event-loop development environment for Lua

• Web Browser

  • Luakit - A fast, extensible, and customizable web browser based on the WebKit web content engine and the GTK+ toolkit.

• Web Frameworks

  • Sailor - A Lua MVC web framework.
  • Ophal - The highly scalable Lua CMS/CMF and web platform
  • Lor Framework - a fast, minimalist Web & API framework for lua based on OpenResty
  • Orbit - an MVC web framework for Lua, based on WSAPI. [[1]](https://luanova.org/orbit1-2/)
  • Vanilla - An OpenResty Lua MVC Web Framework
  • Sailor - A Lua MVC web framework.
  • Orbit - an MVC web framework for Lua, based on WSAPI. [[1]](https://luanova.org/orbit1-2/)

• Digital Signal processing

  • LuaRadio - a lightweight, embeddable flow graph signal processing framework for software-defined radio. It provides a suite of source, sink, and processing blocks, with a simple API for defining flow graphs, running flow graphs, creating blocks, and creating data types.

• Blogs / Sites

  • lua nova - welcome to the moon
  • lua nova - welcome to the moon
  • Lua.Space - The Lua Community Blog

• Style Guides

  • Lua-users style guide - A general, high-level style guide; unopinionated, easily agreed on.
  • Lua-users style guide - A general, high-level style guide; unopinionated, easily agreed on.
  • Olivine style guide - A more opinionated and specific, and therefore more rigorous, guide.

• Guides / Tutorials

  • Lua-Users: Lua Tutorial - This tutorial is aimed at all newcomers to the language Lua. We start off with where to find relevant introductory material and then progress to using the language with tutorials in the [TutorialDirectory)](http://lua-users.org/wiki/TutorialDirectory).
  • Lua Short Reference - The Lua short reference provides a concise summary of the Lua 5.1 syntax and core libraries.
  • TutorialsPoint.com: Lua Tutorial - is designed for all those readers who are looking for a starting point to learn Lua. It has topics suitable for both beginners as well as advanced users.
  • Lua Tutorial | Novice Tutorial - Lua Application Scenario: Game development
  • The.Lua.Tutorial - An Introduction to Lua and The Crash Course to Lua.
  • Litt's Lua Laboratory - The 10% you need -- for 90% of your work
  • Lua for Programmers - Language Essentials, Data and Standard Libraries, More Advanced Concepts and Tips and Tricks.
  • Phrogz: Learning Lua - Learning Lua/From JS, Referenced Values, Metatables, and Simple Inheritance, and Pseudo-OOP Syntax and Scope.
  • Learn Lua from JavaScript - If you know JavaScript, learning Lua is a snap, as Tyler Neylon explains in this series
  • Learn Lua the Hard Way - a person has never programmed before at all
  • Lua-Users: Lua Tutorial - This tutorial is aimed at all newcomers to the language Lua. We start off with where to find relevant introductory material and then progress to using the language with tutorials in the [TutorialDirectory)](http://lua-users.org/wiki/TutorialDirectory).
  • Lua Short Reference - The Lua short reference provides a concise summary of the Lua 5.1 syntax and core libraries.
  • Lua Missions - A series of 'Missions' to work through which are designed to teach aspects of Lua along the way.
  • Lecture Notes based on PiL - course notes based on Programming in Lua book
  • Devhints.io: Cheatsheet for Lua
  • RIP Tutorial: Lua - Getting started with Lua
  • LuaGuide - A guide to help people learn Lua

• Lua Workshop

  • On the design of Lua - Roberto Ierusalimschy (PUC-Rio)
  • Practical LPeg
  • Functions in Lua - In this talk, we will discuss how the mechanism of first-class functions has impacted the design of Lua and will also glimpse at its implementation.

• Articles

  • A Look at the Design of Lua - Communications of the ACM, 2018
  • Small is Beautiful: the Design of Lua - Stanford EE 380: Computer Systems Colloquium (2010)
  • The H Speed Guide to Lua - Why Lua?, Developing with Lua, A quick look at Lua code, Talking with a Lua user
  • How uses Coroutines for non-blocking I/O - It uses coroutines for all asynchronous operations like database queries and HTTP requests.
  • Implementing Proper Getter/Setters in Lua - a class in Lua (OOP)
  • Linked Lists in Lua - an example of creating custom data structures in Lua
  • Lua: Good, bad, and ugly parts - A thorough summary of the good, different, bad, and ugly aspects of Lua 5.2, including many subtle quirks, by the author of ZeroBrane Studio.
  • A Look at the Design of Lua - Communications of the ACM, 2018
  • Embeddable scripting with Lua - Lua offers high-level abstraction without losing touch with the hardware
  • Embed Lua for scriptable apps - Incorporate application scripting using a small language built for the job
  • Lua: Good, bad, and ugly parts - A thorough summary of the good, different, bad, and ugly aspects of Lua 5.2, including many subtle quirks, by the author of ZeroBrane Studio.
  • lightweight concurrency in lua - Implementing fibers and a scheduler with Lua's Coroutines
  • Why we rewrote Lua in JS - Lua for the browser
  • Interfacing Lua with C - Lua provides an interface allowing to call C functions in Lua environment.
  • Asynchronous and Event-driven Programming in Lua - This article demonstrates how to bind libuv API to Lua environment.
  • Port Lua to Web Environment using WebAssembly (Wasm) - using emscripten to compile Lua
  • Hooks in Lua for AOP - pre/post method hooks in Lua for AOP

• Publications and Researchs

  • Programming with Multiple Paradigms in Lua
  • Coroutines in Lua
  • Roberto Ierusalimschy • Publications
  • LabLua - Programming Language Research
  • LabLua - Programming Language Research
  • The Implementation of Lua 5.0 - rio.br/~roberto/talks/lua5-imp.pdf) - discuss about 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 addition of coroutines.
  • Lua.org: Papers and theses

• [Lua Technical Notes](https://www.lua.org/notes/)

  • LTN12: Filters sources and sinks - Filters, Sources, Sinks, and Pumps
  • LTN13: Finalized Exceptions - LuaSocket's exception handling is based on Finalized Exceptions whitepaper.
  • LTN12: Filters sources and sinks - Filters, Sources, Sinks, and Pumps
  • LTN13: Finalized Exceptions - LuaSocket's exception handling is based on Finalized Exceptions whitepaper.

• Books

  • Table of contents - Read the table of contents of first edition.
  • Preface - Read the preface of first edition.
  • Source Code of the examples - Get the source code for some examples from the book.
  • Creating Solid APIs with Lua - Learn how you can build APIs by integrating the Lua and C programming languages.
  • Lua Programming - A shorter overview of the language, up to date for Lua 5.2, and available online.
  • Lua Quick Reference - This book covers: Object-oriented programming with Lua. Creating and working with Lua and C Modules. Lua's standard library and its C API. Collaborative multi-threading in Lua and C. How to program in and embed Lua 5.1 through 5.3, by the creator of Textadept.
  • Creating Solid APIs with Lua - Learn how you can build APIs by integrating the Lua and C programming languages.

• Lua VM and Bytecode

  • Lua 5.2 Bytecode and Virtual Machine
  • Lua 5.3 Bytecode Reference
  • A No-Frills Introduction to Lua 5.0 VM Instructions (NFI)
  • A No-Frills Introduction to Lua 5.1 VM Instructions (NFI)

• Glossaries

  • Lua 5.3 Glossary - A glossary of some essential Lua terms.

• Frequently Asked Questions (FAQ)

  • Lua FAQ - official Lua FAQ
  • Lua-Users FAQ - unofficial Lua FAQ, it is maintained by the Lua community.
  • Lua-Users FAQ - unofficial Lua FAQ, it is maintained by the Lua community.

• GUI

  • wxLua - a wrapper around the [wxWidgets](http://www.wxwidgets.org/) cross-platform C++ GUI library.
  • Yue - A library for creating native cross-platform GUI apps.

• Implementations, Interpreters, and Bindings

  • Lua Repo - The official Lua repo, as seen by the Lua team, mirrored to GitHub.

• Lua 5.2

  • Killa - like syntax

• Compiles to JS, asm.js or WebAssembly for Browser

  • Brozula - a LuaJIT bytecode interpreter that generates ES5 JavaScript.
  • glua - a Lua VM written in Go, to Javascript.
  • Lua.js - a project that can convert lua code to javascript. lua.js is fully written by javascript
  • lua.vm.js - Compile Lua via emscripten to asm.js. Originally by kripken (author of emscripten).
  • lua5.1.js - Lua 5.1, built with emscripten, with low-level API
  • LuaJS - Lua VM running in Javascript (using emscripten)
  • Luwa - Lua WASM JIT, a Lua runtime on top of WASM
  • wasm_lua - Lua VM running in a WASM environment
  • Fengari - Lua VM for the browser. A viable approach to using Lua in the browser and interacting with the DOM.
  • ljs - Lua VM implemented in Javascript
  • Moonshine - A lightweight Lua VM for the browser

• Transpiler Lua to JS and vice versa

  • js2lua - Javascript to Lua translator, using LuaJIT
  • lua.js - Translate Lua code into Javascript.
  • Starlight - A Lua to ECMAScript 6 transpiler.

• Distribution

  • LuaWiMix - A Lua distribution similar to LuaForWindows without anything but ilua, but with support for Lua 5.1 5.2 and 5.3 including optional luarocks and a switching mechanism.

• Batteries Included

  • Lua for Windows - a 'batteries included environment' for the Lua scripting language on Windows.
  • UFO - Un Finished Object - a portable distribution of LuaJIT with precompiled binaries, libraries and FFI bindings
  • NekoLua - A distribution of Lua customized
  • Omnia - Compile Lua, Fennel and MoonScript source code into standalone executables. Using ``luastatic``.

• Build Tools and Standalone Makers

  • srlua - A tool for building self-running Lua programs.
  • luastatic - Build a standalone executable from a Lua program.
  • Lake - A build engine written in Lua, similar to Ruby's rake.
  • Luabuild - A Custom Lua 5.2 Builder (tool to build a static Lua with bundled libraries)
  • slua - A static build of Lua 5.3 for Linux, with a few extension libraries.
  • Luapak - a command-line tool, multi-platform, adjustable, all-in-one (yet modular) solution for building a standalone, zero-dependencies, possibly statically linked (only on Linux) executable for (almost) any Lua program.

• Debugging

  • MobDebug - Remote debugger for Lua.
  • clidebugger - A simple command line interface debugger for Lua 5.1 written in pure Lua.
  • inspect.lua - Human-readable representation of Lua tables
  • chrome-devtools-client - Chrome DevTools client for Lua
  • lovebird - a Browser-based debug console. Originally made for LÖVE, but works in any project with LuaSocket support.
  • ProFi - Simple profiler that works with LuaJIT and produces a report file.
  • luatrace - Toolset for tracing/analyzing/profiling script execution and generating detailed reports.
  • StackTracePlus - Drop-in upgrade to Lua's stack traces which adds local context and improves readability.

• Testing

  • LuaUnit - a popular unit-testing framework for Lua, with an interface typical of xUnit libraries.
  • Luacheck - A tool for linting and static analysis of Lua code.
  • LuaInspect - a tool that does Lua code analysis, with plugins for HTML and SciTE.
  • lualint - lua linter and static analysis of global variable

• Cryptographic

  • lua-argon2 - the Argon2 password hashing function. Compatible with Lua 5.x and LuaJIT.
  • PLC - A small collection of crpytographic functions, and related utilities, implemented in pure Lua (version 5.3 or above)
  • Luazen - a small library with various encoding, compression and cryptographic functions. All the functions work on strings, there is no stream or chunked more complex interfaces.
  • luatweetnacl - Lua binding to the NaCl ("Tweet" version) crypto library

• Message broker / queues

  • lua-zmq - a library which extends the standard socket interfaces with an abstraction of asynchronous message queues. Lua bindings to ZeroMQ version 2.1, 2.2 or 3.2.
  • lzmq - Lua binding to ZeroMQ version 3.2 or 4.x library. This library has C and FFI version of binding.

• Web Plataforms

  • OpenResty - Turning Nginx into a Full-Fledged Scriptable Web Platform
  • VeryNginx - a very powerful and friendly nginx which provide WAF, Control Panel, and Dashboards.
  • OpenStar - Lua WAF, Nginx+Lua, OpenResty, LuaJIT, WAF+, CDN
  • nginx-lua-prometheus - Prometheus metric library for Nginx written in Lua
  • algernon - Small self-contained web server with Lua, Markdown, QUIC, Redis and PostgreSQL support

• Game Framework

  • Skynet - a lightweight online game framework which can be used in many other fields.
  • NoobHub - Network multiplayer and messaging for CoronaSDK, Moai, Gideros, LÖVE & Defold

• Scientific Computing

  • Torch - a scientific computing framework with wide support for machine learning algorithms that puts GPUs first.