Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

my-awesome-lua

My list of quality Lua packages and resources.
https://github.com/MegaBedder/my-awesome-lua

Last synced: 2 days ago
JSON representation

  • Resources

    • 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
      • 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.
      • 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.
      • 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.
      • 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.
      • 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.
      • 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 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).
      • Typed Lua - An Optional Type System for Lua
      • LuaJIT 2 - OpenResty's Branch of LuaJIT 2 (fork)
      • Moonjit - JIT Compiler for the Lua. Fork of LuaJIT to continue development
      • RaptorJIT - A dynamic language for system programming (LuaJIT fork for Linux/x86-64 server applications)
      • 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.
      • LjTools - LuaJIT Assembler/Disassembler - Tool to study LuaJIT 2.0 Bytecode with GUI
      • Metalua - a compiler for a superset of the Lua 5.1 language, which supports compile-time metaprogramming.
      • LuaJIT - High-performance Just-In-Time compiler for Lua.
      • LuaVela - an implementation of Lua 5.1 based on LuaJIT 2.0, for Linux x86-64 only.
      • 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

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

    • Package Managers

      • 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
      • ULua - Universal Lua Distribution
      • 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.

    • 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.
      • SciTE - a SCIntilla based Text Editor, with embedded Lua interpreter.
      • 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.
      • vscode-lua - VSCode intellisense and linting.
      • Textadept - A fast, minimalist, and remarkably extensible cross-platform text editor
      • Lua for IDEA - IntelliJ IDEA plugin which, among other things, provides code completion, smart highlighting, and experimental debugging.
      • Textadept - A fast, minimalist, and remarkably extensible cross-platform text editor

    • Scientific Computing

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

    • Blogs / Sites

    • Glossaries

    • Style Guides

    • Guides / Tutorials

    • Articles

    • Books

      • Lua Programming - A shorter overview of the language, up to date for Lua 5.2, and available online.
      • 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 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.
      • Programming in Lua (PiL) - Intro to all aspects of Lua programming, written by Lua's chief architect. The official book first edition was aimed at Lua 5.0, remains largely relevant and available online.
      • Programming Gems - A collection of articles covering existing wisdom and practices on programming well in Lua, in a broad variety of use cases.

    • Web Browser

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

    • Miscellaneous

      • Prosody - a server for Jabber/XMPP written in Lua.
      • 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.
      • 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).
      • 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).
      • Snabb Switch - a simple and fast packet networking toolkit.
      • 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.
      • MoonGen - a fully scriptable high-speed packet generator built on [DPDK](https://en.wikipedia.org/wiki/Data_Plane_Development_Kit) and LuaJIT.
      • Microlight - A little library of useful Lua functions, intended as the 'light' version of Penlight
      • lua-ext - Standard library / extensions for Lua. math, operator functions, execution platform, Set implementation for Lua, I/O on strings; instead of files.
      • 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.
      • Penlight - A set of pure Lua libraries focusing on input data handling, functional programming, and OS path management. Inspired by the Python standard libraries.

    • Web Frameworks

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

    • Compiles to Lua

      • 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.
      • MoonScript - A programmer friendly language that compiles to Lua 5.1.

    • Asynchronous I/O

      • Luvit - Lua + libUV + jIT = pure awesomesauce
      • LuaNode - Asynchronous I/O for Lua, using the [Reactor pattern](https://en.wikipedia.org/wiki/Reactor_pattern) like Node.js, EventMachine or Twisted.
      • Luver - a ``luvit`` without ``lit``.
      • Lua Corovel - Asynchronous, event-loop development environment for Lua
      • 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

    • Database drivers

      • LuaSQL - a simple interface from Lua to various DBMS. Connect to ODBC, ADO, Oracle, MySQL, SQLite, Firebird and PostgreSQL databases.
      • PL/Lua - an implementation of Lua as a loadable procedural language for PostgreSQL.
      • Redis - A Lua client library for the Redis key value storage system.
      • Tarantool - is an in-memory database and application server.
      • 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.
      • pgmoon - a PostgreSQL client library written in Lua for OpenResty
      • lredis - a Redis (in-memory data structure store) client library for Lua
      • LuaSQLite3 - a Lua wrapper for the SQLite3 library.
      • LuaSQLite3 - a Lua wrapper for the SQLite3 library.
      • LuaSQL - a simple interface from Lua to various DBMS. Connect to ODBC, ADO, Oracle, MySQL, SQLite, Firebird and PostgreSQL databases.

    • 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.
      • Terra - a low-level system programming language that is embedded in and meta-programmed by the Lua programming language.

    • 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.
      • DCLua - A Lua 5.3 VM and compiler written in Go.
      • 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
      • 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.
      • 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.

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

    • Transpiler Lua to JS and vice versa

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

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

    • 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.
      • Lua Fun - a high-performance functional programming library for Lua
      • Moses - Utility library for functional programming in Lua
      • 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.
      • Luvent - Simple Event Library for Lua
      • Safer - Paranoid Lua programming
      • lamda - A functional programming library for Lua, inspired by Ramda.
      • toynet - A simple event-driven I/O for Lua, coroutine based.
      • 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.
      • lua_async - Asynchronous and event driven programming in lua
      • lua-reactor-light - Lightweight lua reactor. Depends only on luasocket and exposes NodeJS-style API

    • I/O

      • lunary - A binary format I/O framework for Lua.
      • LuaSys - a portable Lua library providing access to system and networking functions.
      • 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.

    • [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.
      • LTUI - A cross-platform terminal ui library based on Lua
      • lcurses - curses Terminal Screen Control

    • 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.
      • wxLua - a wrapper around the [wxWidgets](http://www.wxwidgets.org/) cross-platform C++ GUI library.

    • 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
      • 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-cURLv3 - Lua binding to libcurl
      • 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-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.

    • 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
      • 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.
      • 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.
      • Coil - A tiny cooperative threading module for Lua.
      • lua-llthreads2 - drop-in replacement for ``lua-llthreads`` library with several additional functionality.
      • lua-llthreads - Low-Level threads (pthreads and WIN32 threads) for Lua.
      • luaproc - rio.br/~roberto/docs/ry08-05.pdf) - multi-threading library. Message-passing model which allows multiple threads per OS thread.
      • Lumen - Simple concurrent task scheduling.
      • 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
      • ljsyscall - Unix system calls for LuaJIT
      • 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)
      • minisock - a minimal Lua socket library for unix / tcp / udp connections. The API is very close to the standard Unix system calls.

    • 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.
      • 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.
      • luatz - Time, Date and Timezone library for lua
      • lpeg_patterns - A collection of LPEG patterns
      • lucihttp - HTTP utility library with Lua binding9
      • 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.
      • LPegLabel - a conservative extension of the ``LPeg`` library that provides an implementation of Parsing Expression Grammars (PEGs) with labeled failures.
      • 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)

    • 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.
      • Serpent - Lua serializer and pretty printer.
      • Strictness - a small module to track access and assignment to undefined variables in Lua
      • lua-marshal - fast table serialization for Lua
      • LuaTools - tools for use with Lua. Some of these tools written in Lua.

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

    • Lua Workshop

    • Publications and Researchs

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

    • Lua VM and Bytecode

    • 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.
      • uFAQ - Lua Unofficial FAQ

    • 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.
      • algernon - Small self-contained web server with Lua, Markdown, QUIC, Redis and PostgreSQL support
      • nginx-lua-prometheus - Prometheus metric library for Nginx written in Lua
      • OpenStar - Lua WAF, Nginx+Lua, OpenResty, LuaJIT, WAF+, CDN
      • Orange - A Gateway based on OpenResty (Nginx+lua) for API Monitoring and Management.

    • Debugging

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

    • Testing

      • Luacheck - A tool for linting and static analysis of Lua code.
      • LuaUnit - a popular unit-testing framework for Lua, with an interface typical of xUnit libraries.
      • lualint - lua linter and static analysis of global variable
      • LuaInspect - a tool that does Lua code analysis, with plugins for HTML and SciTE.
      • busted - BDD-style unit testing framework with great docs and Moonscript support.
      • luassert - Assertion library extending Lua's built-in assertions.

    • 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

    • Implementations, Interpreters, and Bindings

      • Lua Repo - The official Lua repo, as seen by the Lua team, mirrored to GitHub.
      • Lua - Lua's original ANSI C interpreter.

    • 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

      • luastatic - Build a standalone executable from a Lua program.
      • Luabuild - A Custom Lua 5.2 Builder (tool to build a static Lua with bundled libraries)
      • srlua - A tool for building self-running Lua programs.
      • Lake - A build engine written in Lua, similar to Ruby's rake.
      • 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.
      • slua - A static build of Lua 5.3 for Linux, with a few extension libraries.

    • Message broker / queues

      • lzmq - Lua binding to ZeroMQ version 3.2 or 4.x library. This library has C and FFI version of binding.
      • 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.

    • Cryptographic

      • 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.
      • lua-argon2 - the Argon2 password hashing function. Compatible with Lua 5.x and LuaJIT.
      • luatweetnacl - Lua binding to the NaCl ("Tweet" version) crypto library

    • Lua 5.2

    • 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.
      • Lua Binaries - a distribution of the Lua libraries and executables compiled for several platforms.

    • File System

      • luafilesystem - LuaFileSystem complements the set of file system functions offered by the standard Lua distribution.
Programming Languages
Lua 66 C 35 Go 5 JavaScript 4 C++ 3 TypeScript 1 Shell 1 MoonScript 1 Perl 1 HTML 1
Categories
Resources 379
Sub Categories
Complementary lists 29 Programming Paradigms 25 Lua VM in Lua 24 Guides / Tutorials 21 Articles 18 Lua 5.1 17 Multitasking 16 Libraries 16 Miscellaneous 14 Network 13 Native OS APIs 11 Compiles to JS, asm.js or WebAssembly for Browser 11 Database drivers 10 Books 9 Debugging 8 Web Frameworks 8 Utilities 7 Publications and Researchs 7 IDE, Plugins and text editor 7 Lua 5.3 7 Testing 6 Web Plataforms 6 Asynchronous I/O 6 Dialects, flavors and implementations 6 Build Tools and Standalone Makers 6 Package Managers 5 [CLI](https://luarocks.org/labels/commandline) 5 Data structures 5 Cryptographic 4 Lua Workshop 4 Lua VM and Bytecode 4 Frequently Asked Questions (FAQ) 4 Batteries Included 4 [Lua Technical Notes](https://www.lua.org/notes/) 4 Compiles to Lua 3 GUI 3 Style Guides 3 Transpiler Lua to JS and vice versa 3 I/O 3 Blogs / Sites 3 Game Framework 2 Distribution 2 Message broker / queues 2 Implementations, Interpreters, and Bindings 2 Lua 5.2 1 Glossaries 1 Web Browser 1 Digital Signal processing 1 Scientific Computing 1 File System 1
Keywords
lua 39 luajit 9 functional-programming 4 lua-bindings 3 jit 3 nginx 3 luarocks 3 c 2 openresty 2 array 2 collection 2 networking 2 jit-compiler 2 curses 2 love2d 2 table 2 postgresql 2 awesome-list 2 awesome 2 corona-sdk 1 gideros 1 torch 1 awsome 1 linter 1 tables 1 human-readable 1 tls13 1 sqlite 1 server-sent-events 1 redis 1 quic 1 moai 1 nodejs 1 pubsub 1 wtfpl 1 metrics 1 monitoring 1 prometheus 1 api 1 geoip 1 json 1 kore 1 functional 1 object 1 underscore 1 kubernetes 1 kong 1 docker 1 devops 1 consul 1