Awesome Lua – Massive Collection of Resources

A curated list of quality Lua packages and resources.

Packages

• Implementations, Interpreters, and Bindings
• Package Managers
• Build Tools and Standalone Makers
• Debugging and Profiling
• IDEs and Plugins
• Utility Belts
• Game Engines
• Game Development
• Logging
• Web/Networking Platforms
• OpenResty
• Command-line Utilities
• Concurrency and Multithreading
• Templating
• Documentation
• Object-oriented Programming
• File system and OS
• Time and Date
• Image Manipulation
• Digital Signal Processing
• Hardware and Embedded Systems
• Math and Scientific Computing
• Parsing and Serialization
• Humanize
• Compression
• Cryptography
• Network
• Data Stores
• Message Brokers
• Testing
• Foreign Function Interfaces
• Analysis Tools and ASTs
• Experimental, etc
• Scriptable by Lua
• Miscellaneous

Resources

• Community
• References
• Style Guides
• Tutorials
• Articles
• Talks & Slides
• Books
• Other Lists

Implementations, Interpreters, and Bindings

• Lua – Lua’s original ANSI C interpreter.
  • Lua Repo – The official Lua repo, as seen by the Lua team, mirrored to GitHub.
• LuaJIT – High-performance Just-In-Time compiler for Lua.
• LLVM-Lua – Compiles Lua to LLVM.
• lua.vm.js – Lua VM on the web; a direct port of the C interpreter via LLVM, emscripten, and asm.js.
• Moonshine – A Lua VM implemented in JavaScript. Slower than lua.vm.js, but with better docs, examples, and JS interfacing.
• Fengari – The Lua VM rewritten in Javascript with seamless JS and DOM interoperability.
• MoonSharp – A Lua interpreter written entirely in C# for the .NET, Mono and Unity platforms.
• UniLua – A pure C# implementation of Lua 5.2, focused on compatibility with the Unity game engine.
• lupa – Python bindings to LuaJIT2.
• golua – Golang bindings to the Lua C API.
• GopherLua – Lua 5.1 VM and compiler implemented in Go with Go APIs.
• LuaBridge – A lightweight library for mapping data, functions, and classes back and forth between C++ and Lua.

Note: From LuaJIT to Lua to lua.vm.js to Moonshine, a basic benchmark sees performance drop by roughly a factor of 6 with each hop.

Package Managers

• LuaRocks – De-facto tool for installing Lua modules as packages called “rocks”, plus public rock repository and website. Much like npm or pip.

Build Tools and Standalone Makers

• Lake – A build engine written in Lua, similar to Ruby’s rake.
• Luabuild – Highly customizable Lua 5.2 build system.
• luastatic – Simple tool for turning Lua programs into standalone executables.
• omnia – A batteries-included creator of standalone executables, built on top of luastatic.

Debugging and Profiling

• 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.
• MobDebug – Powerful remote debugger with breakpoints and stack inspection. Used by ZeroBraneStudio.
• lovebird – Browser-based debug console. Originally made for LÖVE, but works in any project with LuaSocket support.

IDEs and Plugins

• Lua Development Tools – Eclipse plugin which provides code completion, debugging, and more. Built on Metalua.
• Lua for IDEA – IntelliJ IDEA plugin which, among other things, provides code completion, smart highlighting, and experimental debugging.
• ZeroBraneStudio – Lightweight, customizable, cross-platform Lua-dedicated IDE with code completion and analysis, written in Lua. Has broad debugging support for numerous Lua engines.
• BabeLua – Lua editor/debugger extension for VS2012-13 with highlighting, auto-completion, linting, and formatting capabilities.
• lua-mode – Emacs major mode for editing Lua.
• vscode-lua – VSCode intellisense and linting.

Utility Belts

• Lua Fun – High-performance functional programming library designed for LuaJIT.
• Moses – Functional programming utility belt, inspired by Underscore.js.
• Penlight – Broad, heavyweight utility library, inspired by Python’s standard libs. Provides the batteries that Lua doesn’t.
• lua-stdlib – Middle-weight standard library extension; adds some useful data structures, utility functions, and basic functional stuff.
• Microlight – A little library of useful Lua functions; the ‘extra light’ version of Penlight.
• compat53 – Compatibility module providing Lua-5.3-style APIs for Lua 5.2 and 5.1.
• RxLua – Reactive Extensions, Observables, etc.

Game Engines

• LÖVE 2D – Desktop game development platform. Cross-platform, feature-complete, well-adopted.
• Corona SDK – Development platform for iOS and Android. Proprietary, but used by numerous top games and apps, totaling over 150 million downloads.
• MOAI – Open source, cross-platform, mobile game development framework. Minimalist C++ engine powered by Lua scripting.
• Drystal – Open source, games can run on Linux or on any platform with a recent web browser.
• Amulet – Open source, audio/visual toolkit suitable for small games and experimentation. It runs on Windows, Mac, Linux, HTML5 and iOS.
• LÖVR – 3D framework for creating virtual reality experiences, inspired by LÖVE 2D.

Game Development

• Corona
  • Coronium – Simple cloud platform supporting analytics, data objects, user management, and more.
• LÖVE
  • awesome-love2d – A list like this one, but focused on game dev and the LÖVE platform.
  • lurker – Shortens the iteration cycle by auto-swapping changed Lua files in a running LÖVE project.
  • HUMP – A set of lightweight helpers for LÖVE; a game-oriented utility belt.
• MOAI
  • moaifiddle – Edit and share short scripts for the MOAI game engine and run them in the browser using WebGL.
• Jumper – Fast, lightweight, and easy-to-use pathfinding library for grid-based games.
• lume – Utility belt library geared toward game development.
• NoobHub – Network multiplayer for Corona, LÖVE, and more, following a simple pub-sub model.
• Collision detection
  • bump.lua – Minimal rectangle-based collision detection which handles tunnelling and basic collision resolution.
  • HardonCollider – Detect collisions between arbitrarily positioned and rotated shapes of any type.
• Tweening
  • flux – A fast, lightweight tweening library for Lua with easing functions and the ability to group tweens together.
  • tween.lua – Small library for tweening, with several easing functions.
• Examples
  • termtris – A tetris clone, written in literate style with “an emphasis on learn-from-ability”.
  • PacPac – A Pac-man clone, made with LÖVE.
  • Mari0 – Fusion of Mario and Portal, made with LÖVE. See also its wikipedia entry.
  • Journey to the Center of Hawkthorne – 2D platformer based on Community’s Digital Estate Planning episode, made with LÖVE.

Logging

• lua-log – Asynchronous logging library with pluggable writers for file system, network, ZeroMQ, and more.
• LuaLogging – Log4j-inspired logging library supporting various appenders.
• luasyslog – Log to syslog, based on LuaLogging.

Web/Networking Platforms

• OpenResty – A fast and scalable web application platform created by extending Nginx with Lua. Today’s de-facto Lua web platform, used heavily by Cloudflare, Taobao, Tencent, and others.
• turbo – Event-driven, non-blocking, LuaJIT-based networking suite and framework, inspired by Tornado.
• Kepler Project – A collection of web-oriented projects using a common set of standards and components.
• Pegasus.lua – Pegasus.lua is a http server to work with web applications written in Lua language.

OpenResty

• awesome-resty – A list like this one, but focused on OpenResty.
• Core platform
  • ngx_lua – The core piece of OpenResty. Embeds Lua in Nginx and exposes, among other things, the cosocket API for non-blocking sockets (compatible with LuaSocket’s API).
  • OpenResty GitHub Organization – Home of the repositories for ngx_lua, ngx_openresty, and many related modules.
• Third-party modules
  • lua-resty-http – Lua HTTP client driver, built on the cosocket API.
• Frameworks & tools
  • Lapis – Full-stack framework for Lua and OpenResty. Like the Django or Rails of Lua. Supports Moonscript.
  • ledge – Lua module providing scriptable, RFC-compliant HTTP cache functionality.
  • Sailor — An MVC web framework compatible with OpenResty, Apache and other webservers.
  • Kong – Microservice & API Management Layer.

Search this page for ‘OpenResty’ to find related packages under other categories (data stores in particular).

Command-line Utilities

• ansicolors – Simple function for printing to the console in color.
• cliargs – A simple command-line argument parsing module.
• lua-term – Terminal operations and manipulations.
• argparse – A feature-rich command line parser inspired by argparse for Python.

Concurrency and Multithreading

• Coroutine-based multitasking:
  • Lumen – Simple concurrent task scheduling.
  • ConcurrentLua – Implements an Erlang-style message-passing concurrency model.
  • cqueues – Library for managing sockets, signals, and threads based on an event loop with coroutines.
• Multithreading:
  • llthreads – A simple wrapper for low-level pthreads & WIN32 threads.
  • llthreads2 – Newer rewrite of llthreads.
  • lanes – Library implementing a message passing model with one OS thread per Lua thread.
  • luaproc – Message-passing model which allows multiple threads per OS thread and easily generalizes across a network. See also the paper where it originated.

For more on the differences (particularly between lanes and luaproc), see this comparison of options; somewhat dated, but covers how each one works and the significant differences.

Templating

• lustache – Mustache template implementation.
• etlua – Embedded Lua templates, ERB-style.
• lua-resty-template – Lua-oriented template engine for OpenResty, somewhat Jinja-like.

Documentation

• LDoc – Documentation generator which modernizes and extends LuaDoc.
• Locco – Lua port of Docco, the “quick-and-dirty, hundred-line-long, literate-programming-style documentation generator”.
• docroc – Parse comments into a Lua table to generate documentation.

Object-oriented Programming

• 30log – Minimalist OOP library with basic classes, inheritance, and mixins in 30 lines.
• middleclass – Simple but robust OOP library with inheritance, methods, metamethods, class variables and mixins.

File system and OS

• LuaFileSystem – Extends and complements Lua’s built-in set of file system functions.
• luaposix – Bindings for POSIX APIs, including curses.
• lunix – Bindings to common Unix system APIs, striving for thread-safety.
• lua-path – File system path manipulation library.

Time and Date

• LuaDate – Date and time module with parsing, formatting, addition/subtraction, localization, and ISO 8601 support.
• cron.lua – Time-related functions for Lua, inspired by JavaScript’s setTimeout and setInterval.
• luatx – Time, date, and timezone library.

Image Manipulation

• magick – Lua bindings to ImageMagick for LuaJIT using FFI.

Digital Signal Processing

• LuaFFT – An easy to use Fast Fourier Transformation package in pure Lua.
• Worp – Sound/music/DSP engine written for LuaJIT.

Hardware and Embedded Systems

• eLua – Lua, extended with optimizations and specific features for efficient and portable embedded software development.

Math and Scientific Computing

• SciLua – Numerical/scientific computing framework built on LuaJIT, with an interface to R.
• Torch7 – Scientific computing framework with wide support for machine learning algorithms, used by Facebook, Google, and more.
• lhf’s Lua Tools – Assorted libraries and tools, many math- or data-related.

Parsing and Serialization

• JSON
  • lua-cjson – Blazing fast JSON encoding/decoding implemented in C and exposed to Lua.
  • luajson – JSON encoder/decoder implemented in Lua on top of LPeg.
  • dkjson – JSON encoder/decoder implemented in pure Lua.
  • json.lua – A fast and tiny JSON library in pure Lua.
• XML
  • LuaExpat – SAX XML parser via binding to the Expat library.
  • SLAXML – Pure Lua SAX-like streaming XML parser.
• MessagePack
  • lua-MessagePack – Pure Lua implementation of MessagePack.
  • lua-cmsgpack – A MessagePack C implementation with Lua bindings, as used by Redis.=
• LPeg
  • LPeg – A pattern-matching library for Lua, based on Parsing Expression Grammars.
  • lpeg_patterns – A collection of LPeg patterns.
  • LuLPeg – A pure Lua implementation of LPeg v0.12.
  • LPegLJ – A pure LuaJIT implementation of LPeg v1.0.
  • LPegLabel – An extension of LPeg adding support for labeled failures.
• lyaml – YAML encoding/decoding via binding to LibYAML.
• lunamark – Converts Markdown to other textual formats including HTML and LaTeX. Uses LPeg for fast parsing.
• LXSH – A collection of lexers and syntax highlighters written with LPeg.
• lua-pb – Protocol Buffers implementation.

Humanize

• i18n.lua – Internationalization library with locales, formatting, and pluralization.
• inspect.lua – Human-readable representation of Lua tables.
• serpent – Serializer and pretty printer.
• Ser – Dead simple serializer with good performance.
• say – Simple string key-value store for i18n.

Compression

• lua-zlib – Simple streaming interface to zlib for gzip/gunzip.
• lua-zip – Lua binding to libzip. Reads and writes zip files.

Cryptography

• LuaCrypto – Lua bindings to OpenSSL.
• lua-lockbox – A collection of cryptographic primitives written in pure Lua.
• luatweetnacl – Bindings to tweetnacl, modern high-security cryptographic library.
• luaossl – “Most comprehensive OpenSSL module in the Lua universe” – used by lapis, kong, and lua-http.

Network

• LuaSocket – Networking extension which provides a socket API for TCP and UDP, and implements HTTP, FTP, and SMTP.
• lua-websockets – WebSocket client and server modules. Webserver-agnostic, implemented in Lua on top of LuaSocket.
• lua-cURLv3 – Lua binding to libcurl.
• lua-http – Asynchronous HTTP and WebSocket library with client and server APIs, TLS, and HTTP/2; based on cqueues.

Data Stores

• LuaSQL – Simple interface for connecting to ODBC, ADO, Oracle, MySQL, SQLite and PostgreSQL.
• pgmoon – Lua PostgreSQL driver for OpenResty, LuaSocket, and cqueues.
• lua-resty-mysql – Lua MySQL driver for OpenResty.
• lua-resty-cassandra – Lua Cassandra client driver for OpenResty and others.
• Redis
  • redis-lua – Pure Lua client library for Redis.
  • lua-resty-redis – Lua Redis client driver for OpenResty.
  • lredis – Asynchronous Redis client with pipelining and Pub/Sub support; based on cqueues.

Message Brokers

• lua-zmq – Lua bindings to ZeroMQ.
• lzmq – A newer Lua binding to ZeroMQ.
• lua-resty-kafka – Kafka client driver based on OpenResty cosockets.
• lua-resty-rabbitmqstomp – RabbitMQ client library based on OpenResty cosockets.

Testing

• busted – BDD-style unit testing framework with great docs and Moonscript support.
• telescope – Flexible and highly customizable testing library.
• luassert – Assertion library extending Lua’s built-in assertions.
• lust – Minimal test framework.

Foreign Function Interfaces

• LuaJIT FFI – LuaJIT’s mechanism for calling external C functions and using C data structures from pure Lua code.
• luaffi – Standalone FFI library, compatible with the LuaJIT FFI interface.

Analysis Tools and ASTs

• luadec51 – Lua Decompiler for Lua version 5.1.
• luacov – Simple coverage analyzer, used by busted and telescope for checking test coverage.
  • luacov-coveralls – LuaCov reporter for coveralls.io.
• luacheck – Simple static analyzer which detects accidental globals and undefined or shadowed locals.
• Metalua – Pure Lua parser and compiler, used for generating ASTs. A number of other tools make use of the Metalua parser in this way.
• LuaInspect – Lua’s most powerful code analysis and linting tool, built on Metalua. Used by ZeroBraneStudio, among others.
• LuaMinify – Minifier which also brings its own static analysis tools, lexer, and parser.
• Typed Lua – A typed superset of Lua that compiles to plain Lua.
• lua-parser – A Lua 5.3 parser written using LPegLabel, with improved error messages.

Experimental, etc

• punchdrunk.js – Moonshine + LÖVE API reimplementation = run LÖVE games in the browser.
• luvit – Node.js’s underlying architecture (libUV) with Lua on top instead of JavaScript.
• graphql-lua – Lua implementation of GraphQL.

Scriptable by Lua

• luakit – Fast, small, webkit based browser framework extensible by Lua.
• Hammerspoon – A powerful, extensible OS X automation tool. A community-maintained fork of Mjolnir.
• kpie – A scripting utility to juggle windows.
• lumail – A console-based mail client, with extensive scripting capabilities.
• AwesomeWM – A highly configurable and extensible window manager for X, scripted and configured by Lua.
• Textadept – Extremely lightweight, customizable, cross-platform editor, written (mostly) in (and scripted by) Lua.
• KoReader – An ebook reader application supports PDF, DJVU, EPUB, FB2 and much more, running on Kindle, Kobo, PocketBook and Android devices.

Miscellaneous

• MoonScript – Moonscript is a dynamic scripting language that compiles to Lua. It reduces verbosity and provides a rich set of features like comprehensions and classes. Its author calls it ‘CoffeeScript for Lua’.
• sitegen – A static site generator which uses MoonScript and supports HTML and Markdown, page grouping, and plugins.

Resources

Community

• lua-l – The official Lua mailing list, and one of the focal points of the Lua community.
• Lua.Space – The Lua community blog.
• Lua Users Foundation – An association of individuals with the mission of supporting and promoting Lua and its community and ecosystems.
• lua-users.org – A site for and by users of Lua, featuring an IRC channel, a web archive of lua-l, and a large wiki.
• Conferences/Meetups
  • Lua Workshop – Annual 2-day meeting of the Lua community, in rotating locations.
  • Lua Conf – Annual 1-day Lua conference in Brazil.
  • FOSDEM – Annual 2-day gathering of F/OSS developers in Brussels which sometimes has a “Lua devroom”.

References

• Reference Manual – The official definition of the Lua language.
• lua-users wiki – A large community-maintained collection of Lua information and resources, supplementing the official website.
• Lua Unofficial FAQ – Answers all sorts of Lua-related questions, including many of the form ‘How to ___?’.

Glossaries

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

Style Guides

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

Tutorials

• Lua Crash Course – Short crash course readover, or reference for when you forget the basics.
• Learn Lua in 15 Minutes – A well-commented example file which covers the basics.
• Learning Lua from JS – An overview of the similarities and differences between Lua and JS; a great start for JavaScript folks looking to pick up Lua.
• lua-users tutorial – In-depth collection of tutorials aimed at newcomers.
• Lua Missions – A series of ‘Missions’ to work through which are designed to teach aspects of Lua along the way.
• Creating an Image Server – Walks through setting up and using OpenResty to build a simple image processing server; a great starting point for playing with OpenResty.

Articles

• Embedding Lua in C – An introductory walkthrough of embedding Lua in a C program. A bit dated, but still a great walkthrough.
• Lua: Good, bad, and ugly parts – A thorough summary of the good, different, bad, and ugly aspects of Lua, including many subtle quirks, by the author of ZeroBraneStudio.
• Lua states, libraries, coroutines and memory – Diagrams and explains some more advanced concepts of the Lua VM, particularly when interfacing with C.

Talks & Slides

• Roberto’s Talks – History of talks given by Lua’s chief architect, with slides for each.
• Lua Workshop Talks – High-quality talks are given at each ~annual Lua Workshop, and a history of them is online, slides included.

Books

• Programming in Lua – The authoritative intro to all aspects of Lua programming, written by Lua’s chief architect. Three editions released; first edition available online.
• Lua Quick Reference – A quick reference on how to program in and embed Lua 5.1 through 5.3, by the creator of Textadept.
• Programming Gems – A collection of articles covering existing wisdom and practices on programming well in Lua, in a broad variety of use cases.
• Lua Programming – A shorter overview of the language, up to date for Lua 5.2, and available online.

Other Lists

• Awesome Julia
• Awesome Erlang
• Awesome Elm