Resources

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

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

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

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

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

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

  • 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

  • Starlight - A Lua to ECMAScript 6 transpiler.

• 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

• IDE, Plugins and 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.
  • Lua for IDEA - IntelliJ IDEA plugin which, among other things, provides code completion, smart highlighting, and experimental debugging.
  • 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.
  • SciTE - a SCIntilla based Text Editor, with embedded Lua interpreter.

• Data structures

  • Tuple - Tuple of Values for Lua.
  • 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.

• 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.
  • RE-AspectLua - 65002006000100002) - a Lua 5.1 extension that allows the declaration of aspects.

• I/O

  • lunary - A binary format I/O framework for Lua.

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

  • Readline - Interface to the readline library
  • linenoise - A small self-contained alternative to readline and libedit.
  • ljlinenoise - a pure LuaJIT port of [linenoise](https://github.com/antirez/linenoise), a small alternative to readline and libedit.

• GUI

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

• Testing

  • busted - BDD-style unit testing framework with great docs and Moonscript support.

• 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

• Database drivers

  • LuaSQL - a simple interface from Lua to various DBMS. Connect to ODBC, ADO, Oracle, MySQL, SQLite, Firebird and PostgreSQL databases.

• 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

• 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

• Libraries

  • lualinq - Lightweight library which allows functional querying and transformation of lua arrays and objects
  • Libraries And Bindings - a list of libraries implemented in Lua or implemented in another language (e.g. C) but having a Lua interface.

• Utilities

  • base2base - A pure Lua base-to-base converter
  • LuaTools - tools for use with Lua. Some of these tools written in Lua.

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

• Asynchronous I/O

  • Luvit - Lua + libUV + jIT = pure awesomesauce

• 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

• Scientific Computing

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

• 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.Space - The Lua Community Blog
  • lua nova - welcome to the moon

• Style Guides

  • Lua-users style guide - A general, high-level style guide; unopinionated, easily agreed on.

• Guides / Tutorials

  • Lecture Notes based on PiL - course notes based on Programming in Lua book
  • 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.
  • Devhints.io: Cheatsheet for Lua
  • 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
  • RIP Tutorial: Lua - Getting started with Lua
  • The.Lua.Tutorial - An Introduction to Lua and The Crash Course to Lua.
  • LuaGuide - A guide to help people learn 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 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.
  • 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
  • Implementing Proper Getter/Setters in Lua - a class in Lua (OOP)
  • Linked Lists in Lua - an example of creating custom data structures in Lua
  • Hooks in Lua for AOP - pre/post method hooks in Lua for AOP
  • Lua states, threads, libraries and memory layout - Diagrams and explains some more advanced concepts of the Lua VM, particularly when interfacing with C.
  • 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.

• 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

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

• 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 VM and Bytecode

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

• Complementary lists

  • awesome-lua - A curated list of quality Lua packages and resources.
  • nginx-resources
  • 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.
  • 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