Resources

• Libraries

  • 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.
  • 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)

• Lua 5.1

  • LuaJIT - High-performance Just-In-Time compiler for 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.
  • Agena - based on Lua 5.1 C source, but has significant syntax differences
  • 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).
  • 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.
  • Agena - based on Lua 5.1 C source, but has significant syntax differences
  • LuaVela - an implementation of Lua 5.1 based on LuaJIT 2.0, for Linux x86-64 only.
  • Firth - pre-alpha-1-a-forth-like-language-for-dsl-creation/) - A simple Forth-like language intended for DSL creation, implemented in Lua.

• Lua 5.2

  • Killa - like syntax

• 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.
  • 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.

• [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.

• 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)
  • Lua 5.2 Bytecode and Virtual Machine

• Lua VM in Lua

  • 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.
  • 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.
  • 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.
  • 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.

• 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.
  • Roberto Ierusalimschy • Talks
  • 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.

• 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.

• Miscellaneous

  • 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.
  • Prosody - a server for Jabber/XMPP written in Lua.
  • 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.
  • Penlight - A set of pure Lua libraries focusing on input data handling, functional programming, and OS path management. Inspired by the Python standard libraries.
  • lua-stdlib - General Lua libraries
  • SILE - a typesetting system; its job is to produce beautiful printed documents. Conceptually, SILE is similar to [TeX](https://en.wikipedia.org/wiki/TeX).

• Multitasking

  • Threads
  • 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.
  • 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

• Native OS APIs

  • luaposix - Lua bindings for POSIX APIs.
  • luapower/winapi - Windows, common controls and dialogs, message loop and system APIs for LuaJIT.
  • 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
  • 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.

• Network

  • 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.
  • LuaSocket - Network support for the Lua language
  • 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
  • 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.

• Package Managers

  • LuaRocks - De-facto tool for installing Lua modules as packages called "rocks", public rock repository and website.
  • ULua - Universal Lua Distribution
  • LuaPower - the LuaJIT distribution for Windows, Linux and OS X
  • LuaPlus - Full LuaPlus distribution (fork of Lua 5.1) for Windows
  • LuaDist - a multi-platform package management system that aims to provide both source and binary repository of modules for Lua.
  • LuaPlus - Full LuaPlus distribution (fork of Lua 5.1) for Windows
  • ULua - Universal Lua Distribution
  • Lit - Toolkit for the ``Luvit`` ecosystem

• Programming Paradigms

  • LOOP - Class Models for Lua
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.
  • Reactor design pattern
  • lua-reactor - React-style ui component system for Lua
  • 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

• Publications and Researchs

  • 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.
  • Programming with Multiple Paradigms in Lua
  • Coroutines in Lua
  • Lua.org: Papers and theses
  • Roberto Ierusalimschy • Publications
  • LabLua - Programming Language Research
  • LabLua - Programming Language Research
  • Programming with Multiple Paradigms in Lua
  • Coroutines in Lua
  • Roberto Ierusalimschy • Publications

• Scientific Computing

  • Torch - a scientific computing framework with wide support for machine learning algorithms that puts GPUs first.
  • SciLua - A complete framework for numerical computing based on LuaJIT

• 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.

• 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

• Transpiler Lua to JS and vice versa

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

• Utilities

  • base2base - A pure Lua base-to-base converter
  • 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.

• 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
  • Orbit - an MVC web framework for Lua, based on WSAPI. [[1]](https://luanova.org/orbit1-2/)
  • Sailor - A Lua MVC web framework.

• Web Plataforms

  • OpenResty - Turning Nginx into a Full-Fledged Scriptable Web Platform