Available rocks

30log - 30 lines library for object orientation

30log, in extenso "30 Lines Of Goodness" is a minified 30-lines library for object-orientation in Lua. It features class creation, instantiation, inheritance.
latest sources | project homepage | License: MIT

abelhas - A particle swarm optimization (PSO) package for Lua

Abelhas (aka Lua PSO) is a Lua library for particle swarm optimization (PSO), a population-based optimization algorithm inspired by the social behavior of some species, like fishes and birds, and used for solving a multitude of numeric problems with linear and discrete search spaces. The first particle swarm optimization algorithm was invented by Dr. James Kennedy and Russell Eberhart, in 1995, and since then several versions and variants have been created. Abelhas is one of them.

For people familiarized with particle swarms, Abelhas is a particle swarm optimizer that uses global neighborhood, speed limits and particle replacement. It does not have the concept of inertia.
latest sources | project homepage | License: MIT/X11

AesFileEncrypt - A simple file encryption library

Binding to Dr Brian Gladman's implementation. Encryption libray use a. RFC2898 for key derivation (using HMAC-SHA1) b. AES in CTR mode for encryption c. HMAC-SHA1 for authentication d. A Random Data Pool based on Peter Gutmann's ideas
latest sources | project homepage | License: GPL

alien - Lua->C FFI

Alien lets a Lua application call load dynamic libraries and call C functions in a portable way, using libffi.

External dependencies: ffi

latest sources | project homepage | License: MIT/X11

alt-getopt - Process application arguments the same way as getopt_long

alt-getopt is a module for Lua programming language for processing application's arguments the same way BSD/GNU getopt_long(3) functions do. The main goal is compatibility with SUS "Utility Syntax Guidelines" guidelines 3-13.
latest sources | project homepage | License: MIT/X11

annotate - A decorator for docstrings and type checking

This Lua module provides a decorator that allows to associate Lua values with docstrings. A plugin that parses function signatures in those docstrings and compiles them to argument and return value type checking functions is included.
latest sources | project homepage | License: MIT

ansicolors - Library for color Manipulation.

Ansicolors is a simple Lua function for printing to the console in color.
latest sources | project homepage | License: MIT

ao - A library for audio output through Lua

Bindings for Libao, which is a cross-platform audio library that allows programs to output audio using a simple API.

External dependencies: libao

latest sources | project homepage | License: CC0

AskLua - Adds interactive help to other modules

AskLua provides a module that implements a help integrated system for on line use in the interactive interpreter, and for generating documentation in html and printed formats.
latest sources | License: Public domain

bencode - library for encoding and decoding bencoded data

bencode is a module for encoding and decoding bencoded data for the bittorrent filesharing protocols
latest sources | project homepage | License: MIT/X11

bit32 - Lua 5.2 bit manipulation library

bit32 is the native Lua 5.2 bit manipulation library, backported to Lua 5.1
latest sources | project homepage | License: MIT/X11

bitlib - Tiny library for bitwise operations

bitlib is a library providing bitwise operations.
latest sources | project homepage | License: MIT/X11

busted - Elegant Lua unit testing.

An elegant, extensible, testing framework. Ships with a large amount of useful asserts, plus the ability to write your own. Output in pretty or plain terminal format, JSON, or TAP for CI integration. Great for TDD and unit, integration, and functional tests.
latest sources | project homepage | License: MIT

CGILua - Tool for creating dynamic Web pages and manipulating data from Web forms

CGILua allows the separation of logic and data handling from the generation of pages, making it easy to develop web applications with Lua. CGILua can be used with a variety of Web servers and, for each server, with different launchers. A launcher is responsible for the interaction of CGILua and the Web server, for example using ISAPI on IIS or mod_lua on Apache.
latest sources | License: N/A

checks - Easy, terse, readable and fast function arguments type checking

This library declares a `checks()` function and a `checkers` table, which allow to check the parameters passed to a Lua function in a fast and unobtrusive way.

Althought provided here as a standalone library, it is part of Sierra Wireless' Aleos Applicaion Framework, available under the Eclipse Public License, currently at:

https://github.com/SierraWireless/luasched

latest sources | project homepage | License: Eclipse public license

cl - A command-line evaluator library that supports shell-like command lines and s-expressions.

latest sources | project homepage | License: Public Domain

Colors - HSL Color Theory Computation in Lua

Colors library provides methods to do color computation in HSL color space and for finding "harmonious" color palettes.
latest sources | project homepage | License: MIT/X11

ConcurrentLua - Concurrency Oriented Programming in Lua

ConcurrentLua is a system that implements Erlang-style concurrency for the Lua programming language. It is a system that brings an alternative to what scripting languages offer for concurrent and distributed programming.
latest sources | project homepage | License: MIT/X11

config - Easy configuration file loading

Allows to load config fileswith a lua-like syntax but with sugar. I.e: You can have a file like: foo = 3 bar.plop = 5 bar.zaz = { 3, 4 }

This will load just fine, even if this is not valid Lua code (bar is not defined)
latest sources | project homepage | License: MIT/X11

Copas - Coroutine Oriented Portable Asynchronous Services

Copas is a dispatcher based on coroutines that can be used by TCP/IP servers. It uses LuaSocket as the interface with the TCP/IP stack. A server registered with Copas should provide a handler for requests and use Copas socket functions to send the response. Copas loops through requests and invokes the corresponding handlers. For a full implementation of a Copas HTTP server you can refer to Xavante as an example.
latest sources | project homepage | License: MIT/X11

CopasTimer - Copas add-on to provide timers, background tasks and optionally events

Copas Timer is a module that adds a timer capability to the Copas scheduler. It provides the same base functions step and loop as Copas (it actually replaces them) except that it will also check for (and run) timers expiring and run background workers if there is no IO or timer to handle. It also adds methods to allow for a controlled exit from the loop. As an optional component an 'eventer' is available to dispatch events as background tasks in Copas Timer.
latest sources | project homepage | License: MIT/X11

corowatch - Watching and killing coroutines.

Provides a way to limit the runtime of a coroutine. This prevents rogue code from locking your Lua state by not yielding in a timely manner. Coroutines that take longer than the maximum specified can be killed.
latest sources | project homepage | License: MIT

Cosmo - Safe templates for Lua

Cosmo is a "safe templates" engine. It allows you to fill nested templates, providing many of the advantages of Turing-complete template engines, without without the downside of allowing arbitrary code in the templates.
latest sources | project homepage | License: MIT/X11

Coxpcall - Coroutine safe xpcall and pcall

Encapsulates the protected calls with a coroutine based loop, so errors can be dealed without the usual Lua 5.x pcall/xpcall issues with coroutines yielding inside the call to pcall or xpcall.
latest sources | project homepage | License: MIT/X11

cue - A cuesheet parser for Lua.

A cuesheet parser for Lua.
latest sources | project homepage | License: CC0

cw - Colorer for command-line programs

cw is a colorer for command-line programs. It is designed to simulate the environment of the commands being executed, so that when you type 'du', 'df', 'ping', etc. in your shell the output is automatically colored according to a definition script. You can easily change or add new scripts, and change the colors used.
latest sources | project homepage | License: GPL

Dado - Database Facilities for LuaSQL

Dado is a package that offers some facilities implemented over LuaSQL connection objects. Its main goals are: better error messages, iterators to access the result set and more homogeneity in some commonly used database operations.
latest sources | project homepage | License: MIT/X11

darksidesync - Thread synchronization support for bindings to libraries with their own threadpools

DarkSideSync is a binding support library that makes it easy to create bindings to libraries that run their own background threads, like pupnp or OpenZwave for example. No global locks are required and no foreign threads will be entering the Lua environment. Bindings using DarkSideSync will not require platform specific code for synchronization.
latest sources | project homepage | License: MIT

date - Date & Time module for Lua 5.x

Pure Lua Date & Time module for Lua 5.x featuring date and Time string parsing, time addition & subtraction, time span calculation, support for ISO 8601 Dates, local time support, strftime-like formatting.
latest sources | project homepage | License: Public Domain

deimos - Deimos Strong Typing System

Deimos is a strongly typed object system: Deimos objects have a defined schema which allows it to validate data. Schemas are defined in the syntax of Lua itself. Errors are thrown if data being tested doesn't conform to the schema, and validated data can be manipulated as if ordinary Lua tables.
latest sources | project homepage | License: MIT/X11

densearrays - A library for dense arrays of numbers or booleans

densearrays provides memory-efficient arrays for Lua. Arrays can contain numbers or boolean values, and can have up to eight dimensions.
latest sources | project homepage | License: MIT/X11

Diff - Diff functions

This module provides a small collection of functions for diffing text.
latest sources | project homepage | License: MIT/X11

dkjson - David Kolf's JSON module for Lua

dkjson is a module for encoding and decoding JSON data. It supports UTF-8.

JSON (JavaScript Object Notation) is a format for serializing data based on the syntax for JavaScript data structures.

dkjson is written in Lua without any dependencies, but when LPeg is available dkjson uses it to speed up decoding.
latest sources | project homepage | License: MIT/X11

enet - A library for doing network communication in Lua

Binding to ENet, network communication layer on top of UDP.

External dependencies: enet

latest sources | project homepage | License: MIT

fbclient - A pure-Lua binding of the Firebird client library

A collection of pure Lua modules that allows you to connect and execute queries against the Firebird Relational Database. It is a modular, 3-layer interface, aiming at full API coverage.
latest sources | project homepage | License: MIT/X11

Flu - Filesystems in Lua Userspace.

External dependencies: attr, fuse

latest sources | project homepage | License: MIT

haricot - A beanstalkd client.

Haricot is a client for Beanstalkd (http://kr.github.com/beanstalkd/).
latest sources | project homepage | License: MIT/X11

hsm_statechart - State machine engine based on UML statecharts.

hsm-statechart is a hierarchical statechart engine, written in C. The Lua extension makes it dead simple to write statemachines: you just declare a table.

chart = { state= { event= function() end, substate={ ... } } } Both event handlers and states are key:value pairs. Event names map to functions ( or, for simple transitions, directly to a state name ), while states names map to sub-tables. After defining a statechart, two calls: hsm= hsm_statechart( chart ) and hsm.signal( event_name ) are all that are need to run the statemachine.

Statemachines can be used for everything from building roboust text parsers, to managing the control flow for applications, or even writing AI in games.
latest sources | project homepage | License: New BSD License

HTK - A library of Lua constructors to create HTML code

HTK is a library of Lua constructors that create HTML elements in a structured way.
latest sources | project homepage | License: MIT/X11

htmlparser - Parse HTML text into a tree of elements with selectors

Call parse() to build up a tree of element nodes. Each node in the tree, including the root node that is returned by parse(), supports a basic set of jQuery-like selectors. Or you could walk the tree by hand.
latest sources | project homepage | License: MIT

i18n - A very complete internationalization library for Lua

i18n can handle hierarchies of tags, accepts entries in several ways (one by one, in a table or in a file) and implements a lot of pluralization rules, fallbacks, and more.
latest sources | project homepage | License: MIT

inotify - Inotify bindings for Lua

External dependencies: inotify

latest sources | project homepage | License: MIT

inspect - Lua table visualizer, ideal for debugging

inspect will print out your lua tables nicely so you can debug your programs quickly. It sorts keys by type and name, handles data recursion
latest sources | project homepage | License: MIT

json2lua - A command-line tool to convert JSON to Lua

latest sources | project homepage | License: MIT/X11

JSON4Lua - JSON4Lua and JSONRPC4Lua implement JSON (JavaScript Object Notation) encoding and decoding and a JSON-RPC-over-http client for Lua.

JSON4Lua and JSONRPC4Lua implement JSON (JavaScript Object Notation) encoding and decoding and a JSON-RPC-over-http client for Lua. JSON is JavaScript Object Notation, a simple encoding of Javascript-like objects that is ideal for lightweight transmission of relatively weakly-typed data. A sub-package of JSON4Lua is JSONRPC4Lua, which provides a simple JSON-RPC-over-http client and server (in a CGILua environment) for Lua.
latest sources | project homepage | License: GPL

jumper - Fast and easy-to-use pathfinding library for grid-based games

Jumper is a pathfinding library designed for grid-based games. It aims to be fast and lightweight. It also features wide range of search algorithms, a clean public interface with chaining features which makes it very friendly and easy to use.
latest sources | project homepage | License: MIT

lake - A Lua-based Build Tool

lake is a build engine in Lua, which directly executes dependency rules. Provides cross-platform support for both GCC and MSVC compilers, particularly for building Lua C extensions.
latest sources | project homepage | License: MIT/X11

lalarm - An alarm library for Lua

An alarm library for Lua based on the signal() call and the POSIX signal SIGALRM.
latest sources | project homepage | License: Public domain

Lanes - Multithreading support for Lua

Lua Lanes is a portable, message passing multithreading library providing the possibility to run multiple Lua states in parallel.
latest sources | project homepage | License: MIT/X11

lapis - A web framework for MoonScript & Lua

latest sources | project homepage | License: MIT

lascii85 - An ASCII85 library for Lua

An ASCII85 library for Lua. Ascii85 is a form of binary-to-text encoding developed by Adobe Systems. It is more efficient at encoding binary data as ASCII characters than Base64, resulting in only an approximately 25% increase in data size versus 33% for base64.
latest sources | project homepage | License: Public domain

lbase64 - A Base64 library for Lua

A Base64 library for Lua. Base64 is a base-64 transfer encoding that uses the characters A-Z, a-z, and 0-9 in that order for the first 62 digits.
latest sources | project homepage | License: Public domain

lbc - A simple arbitrary precision library

A simple arbitrary precision library for Lua, based on code from GNU bc.
latest sources | project homepage | License: GNU General Public License version 2 or later

lbci - A bytecode inspector library

A bytecode inspector library.
latest sources | project homepage | License: Public domain, MIT

lcomplex - Support for complex numbers in Lua

This code provides support for complex numbers in Lua using the functions available in C99.
latest sources | project homepage | License: MIT/X11

lcurses - ncurses binding for Lua

lcurses is a C library for Lua 5.1 that wraps the curses API.

External dependencies: ncurses

latest sources | project homepage | License: MIT/X11

ldecNumber - Lua decNumber, a Lua 5.1 wrapper for IBM decNumber

Lua decNumber, a Lua 5.1 wrapper for IBM decNumber, implements the proposed General Decimal Arithmetic standard IEEE 754r. It has the Lua 5.1 arithmetic operators and more, full control over rounding modes, and working precision up to 69 decimal digits.
latest sources | project homepage | License: MIT/X11

ldoc - A Lua Documentation Tool

LDoc is a LuaDoc-compatible documentation generator which can also process C extension source. Markdown may be optionally used to render comments, as well as integrated readme documentation and pretty-printed example files
latest sources | project homepage | License: MIT/X11

Leg - A Lua 5.1 grammar

Leg offers a complete Lua 5.1 grammar, along with a small API for user manipulation.
latest sources | project homepage | License: MIT/X11

lgdbm - A database library for Lua using GDBM

A database library for Lua based on GNU dbm. GNU dbm is a set of database routines that use extensible hashing. It works similar to the standard Unix dbm routines.

External dependencies: gdbm

latest sources | project homepage | License: Public domain

lgi - Lua bindings to GObject libraries

Dynamic Lua binding to any library which is introspectable using gobject-introspection. Allows using GObject-based libraries directly from Lua.
latest sources | project homepage | License: MIT/X11

lglob - extended global static analysis tool for Lua

lglob is based on David Manura's globalsplus.lua script and parses the bytecode output of luac to flag the setting and getting of globals and their fields. (both 'ToString' and 'math.sine' are considered errors). The whitelist used can be set, and required modules are tracked.
latest sources | project homepage | License: MIT/X11

linenoise - A binding for the linenoise command line library

latest sources | project homepage | License: MIT/X11

linenoise-windows - A binding for the linenoise command line library

latest sources | project homepage | License: MIT/X11

lmapm - A complete arbitrary precision library

A complete arbitrary precision library for Lua, based on MAPM.

External dependencies: mapm

latest sources | project homepage | License: Public domain

lmathx - C99 extensions for the math library

An extension of the Lua math library with the functions available in C99.
latest sources | project homepage | License: Public domain

lnotify - Simple bind from libnotify to Lua.

Simple library binding libnotify to Lua, quite easy to use, supporting emergency levels. Popping up notifications from Lua to your desktop now is a piece of cake.

External dependencies: notify

latest sources | project homepage | License: MIT/X11

LOOP - Class Models for The Lua Language

LOOP stands for Lua Object-Oriented Programming and is a set of packages for supporting different models of object-oriented programming in the Lua language. LOOP provides five interoperable class-hierarchy-based object models for Lua. Its class library provides many useful use examples ranging from single-table data structures to utilities for debugging, serialization, multi-threading and more.
latest sources | project homepage | License: MIT/X11

lpack - A library for packing and unpacking binary data

A library for packing and unpacking binary data. The library adds two functions to the string library: pack and unpack.
latest sources | project homepage | License: Public domain

lpc - Lua Process Call

Allows Lua scripts to call external processes while capturing both their input and output(in contrast to Lua's popen function that can only capture one or the other).
latest sources | project homepage | License: MIT/X11

lpdf - A library for generating PDF documents based on PDFlib

External dependencies: pdflib

latest sources | project homepage | License: Public Domain

LPeg - Parsing Expression Grammars For Lua

LPeg is a new pattern-matching library for Lua, based on Parsing Expression Grammars (PEGs). The nice thing about PEGs is that it has a formal basis (instead of being an ad-hoc set of features), allows an efficient and simple implementation, and does most things we expect from a pattern-matching library (and more, as we can define entire grammars).
latest sources | project homepage | License: MIT/X11

lposix - A POSIX library for Lua.

A library binding a number of POSIX functions, which supplements the basic set of ANSI C functions provided by the standard Lua libraries. POSIX is a Portable Operating System Interface standard defined by IEEE.
latest sources | project homepage | License: Public domain

lpty - A simple facility for lua to control other programs via PTYs.

This is a simple wrapper around unix PTYs. PTYs can be opened, lua controls the master side of the PTY. Programs can be started with the client side of those PTYs as their controlling terminals.
latest sources | project homepage | License: MIT/X11

lrandom - A library for generating random numbers.

A library for generating random numbers based on the Mersenne Twister, a pseudorandom number generating algorithm developped by Makoto Matsumoto and Takuji Nishimura (alphabetical order) in 1996/1997.
latest sources | project homepage | License: Public domain

Lrexlib-GNU - Regular expression library binding (GNU flavour).

Lrexlib is a regular expression library for Lua 5.1 and 5.2, which provides bindings for several regular expression libraries. This rock provides the GNU bindings.

External dependencies: gnu

latest sources | project homepage | License: MIT/X11

Lrexlib-oniguruma - Regular expression library binding (oniguruma flavour).

Lrexlib is a regular expression library for Lua 5.1 and 5.2, which provides bindings for several regular expression libraries. This rock provides the oniguruma bindings.

External dependencies: onig

latest sources | project homepage | License: MIT/X11

Lrexlib-PCRE - Regular expression library binding (PCRE flavour).

Lrexlib is a regular expression library for Lua 5.1 and 5.2, which provides bindings for several regular expression libraries. This rock provides the PCRE bindings.

External dependencies: pcre

latest sources | project homepage | License: MIT/X11

Lrexlib-POSIX - Regular expression library binding (POSIX flavour).

Lrexlib is a regular expression library for Lua 5.1 and 5.2, which provides bindings for several regular expression libraries. This rock provides the POSIX bindings.

External dependencies: posix

latest sources | project homepage | License: MIT/X11

Lrexlib-TRE - Regular expression library binding (TRE flavour).

Lrexlib is a regular expression library for Lua 5.1 and 5.2, which provides bindings for several regular expression libraries. This rock provides the TRE bindings.

External dependencies: tre

latest sources | project homepage | License: MIT/X11

lsocket - simple and easy socket support for lua.

lsocket is a library to provide socket programming support for lua. It is not intended to be a complete socket api, but easy to use and good enough for most tasks. Both IPv4 and IPv6 are supported, as are tcp and udp, and also IPv4 broadcasts and IPv6 multicasts.
latest sources | project homepage | License: MIT/X11

lsqlite3 - A binding for Lua to the SQLite3 database library

lsqlite3 is a thin wrapper around the public domain SQLite3 database engine. The lsqlite3 module supports the creation and manipulation of SQLite3 databases. After a require('lsqlite3') the exported functions are called with prefix sqlite3. However, most sqlite3 functions are called via an object-oriented interface to either database or SQL statement objects.

External dependencies: sqlite

latest sources | project homepage | License: MIT/X11

ltcltk - A binding for lua to the tcl interpreter and to the tk toolkit.

This is a binding of the tcl interpreter to lua. It allows for calls into tcl, setting and reading variables from tcl and registering of lua functions for use from tcl. Also, a binding to the tk toolit is included.
latest sources | project homepage | License: MIT/X11

ltermbox - A termbox library package

Its general purpose is to serve as the simplest ncurses alternative.
latest sources | project homepage | License: New BSD License

lua-aplicado - A random collection of application level Lua libraries

latest sources | project homepage | License: MIT/X11

Lua-APR - Apache Portable Runtime binding for Lua

Lua/APR is a binding to the Apache Portable Runtime (APR) library. APR powers software such as the Apache webserver and Subversion and Lua/APR makes the APR operating system interfaces available to Lua.
latest sources | project homepage | License: MIT

lua-chan - Simple and fast message queue for Lua

latest sources | project homepage | License: MIT

lua-cjson - A fast JSON encoding/parsing module

The Lua CJSON module provides JSON support for Lua. It features: - Fast, standards compliant encoding/parsing routines - Full support for JSON with UTF-8, including decoding surrogate pairs - Optional run-time support for common exceptions to the JSON specification (infinity, NaN,..) - No dependencies on other libraries
latest sources | project homepage | License: MIT

lua-cmsgpack - MessagePack C implementation and bindings for Lua 5.1

latest sources | project homepage | License: Two-clause BSD

lua-Coat - Yet Another Lua Object-Oriented Model

lua-Coat is a Lua 5.1 port of Coat (http://www.sukria.net/perl/coat/), a Perl5 module which mimics Moose (http://www.iinteractive.com/moose/), an object system for Perl5 which borrows features from Perl6, CLOS (LISP), Smalltalk and many other languages.
latest sources | project homepage | License: MIT/X11

lua-CoatPersistent - an ORM for lua-Coat

lua-CoatPersistent is an Object-Relational Mapping for lua-Coat. It is built over the modules LuaSQL and Dado. It could support all database engine which has a driver in LuaSQL.
latest sources | project homepage | License: MIT/X11

lua-CodeGen - a template engine

lua-CodeGen is a "safe" template engine.

lua-CodeGen enforces a strict Model-View separation.

lua-CodeGen allows to split template in small chunk, and encourages the reuse of them by inheritance.

lua-CodeGen is not dedicated to HTML, it could generate any kind of textual code.
latest sources | project homepage | License: MIT/X11

lua-csnappy - a fast compressor/decompressor

lua-csnappy is a binding of the csnappy library which implements the Google's Snappy (de)compressor.
latest sources | project homepage | License: BSD

lua-discount - Binding to a fast C implementation of the Markdown text-to-html markup system

latest sources | project homepage | License: BSD

lua-espeak - A speech synthesis library for Lua

Lua-eSpeak is a Lua bindind to eSpeak, a compact open source software speech synthesizer for English and several other languages. It produces good quality English speech using a different synthesis method from other open source TTS engines.

External dependencies: espeak

latest sources | project homepage | License: GNU GPL v3

lua-ev - Lua integration with libev

lua-ev: Lua integration with libev (http://dist.schmorp.de/libev)

External dependencies: libev

latest sources | project homepage | License: MIT/X11

lua-geoip - Bindings for MaxMind's GeoIP library

External dependencies: geoip

latest sources | project homepage | License: MIT/X11

lua-hiredis - Bindings for hiredis Redis-client library

latest sources | project homepage | License: MIT/X11

lua-http-parser - A Lua binding to Ryan Dahl's http request/response parser.

latest sources | project homepage | License: MIT

lua-iconv - Lua binding to the iconv

Lua binding to the POSIX 'iconv' library, which converts a sequence of characters from one codeset into a sequence of corresponding characters in another codeset.

External dependencies: iconv

latest sources | project homepage | License: MIT/X11

lua-imlib2 - A binding to the imlib2 image manipulation library

External dependencies: imlib2

latest sources | project homepage | License: MIT/X11

lua-inih - Bindings for inih, simple .INI file parser

latest sources | project homepage | License: MIT/X11

lua-llthreads - Low-Level threads for Lua

latest sources | project homepage | License: MIT/X11

lua-log - Asynchronous logging library

latest sources | project homepage | License: MIT/X11

lua-MessagePack - a pure Lua implementation

MessagePack is an efficient binary serialization format.

It lets you exchange data among multiple languages like JSON but it's faster and smaller.
latest sources | project homepage | License: MIT/X11

lua-nucleo - A random collection of core and utility level Lua libraries

latest sources | project homepage | License: MIT/X11

lua-path - File system path manipulation library

latest sources | project homepage | License: MIT/X11

lua-Spore - a generic ReST client

lua-Spore is an implementation of SPORE (Specification to a POrtable Rest Environment), see http://github.com/SPORE/specifications.

Some specifications of service are available at http://github.com/SPORE/api-description.
latest sources | project homepage | License: MIT/X11

lua-stdlib - General Lua Libraries

stdlib is a library of modules for common programming tasks, including list, table and functional operations, regexps, objects, pickling, pretty-printing and getopt.
latest sources | project homepage | License: MIT/X11

lua-term - Terminal functions for Lua

latest sources | project homepage | License: MIT/X11

lua-TestLongString - an extension for testing long string

lua-TestLongString is a port of the Perl5 module Test::LongString.

It is an extension of lua-TestMore.

It provides functions for comparing and testing strings that are not in plain text or are especially long.
latest sources | project homepage | License: MIT/X11

lua-TestMore - an Unit Testing Framework

lua-TestMore is a port of the Perl5 module Test::More.

It uses the Test Anything Protocol as output, that allows a compatibility with the Perl QA ecosystem.

It's an extensible framework.

It allows a simple and efficient way to write tests (without OO style).

Some tests could be marked as TODO or skipped.

Errors could be fully checked with error_like().

It supplies a Test Suite for Lua itself.
latest sources | project homepage | License: MIT/X11

lua-tinycdb - Provides support for creating and reading constant databases

latest sources | project homepage | License: MIT/X11

Lua-TTyrant - TokyoTyrant API for Lua.

A complete API binding exposing the functions from the C library of the TokyoTyrant key-value database server straight into Lua (i.e. it uses the Tyrant C functions rather than implementing the Tyrant protocol over TCP).

External dependencies: libtokyotyrant

latest sources | project homepage | License: MIT

lua-websockets - Websockets for Lua

Provides sync and async clients and servers for copas.
latest sources | project homepage | License: MIT/X11

lua-xmlreader - An implementation of the XmlReader API using libxml2.

External dependencies: libxml2

latest sources | project homepage | License: MIT/X11

lua-yajl - Integrate the yajl JSON library with Lua.

External dependencies: yajl

latest sources | project homepage | License: MIT/X11

lua-zmq - Lua bindings to zeromq2, with LuaJIT2 FFI support.

External dependencies: zeromq

latest sources | project homepage | License: MIT/X11

lua-zmq-threads - Lua bindings to zeromq2, with LuaJIT2 FFI support.

latest sources | project homepage | License: MIT/X11

lua2json - A command-line tool to convert Lua to JSON

latest sources | project homepage | License: MIT/X11

lua_bufflib - A library for string buffers in Lua

A library for string buffers in Lua.

The buffer code in this library is largely adapted from Lua 5.2's luaL\_Buffer code. The main difference is that Buffers store their contents in the registry instead of the stack when their length exceeds LUAL\_BUFFERSIZE. This prevents the C char array holding the current contents from being garbage collected until a larger array is required or the Buffer is reset or garbage collected. You don't need to know any of this to use the library, it's just extra information for people curious about the implementation.

Just like regular strings in Lua, string buffers can contain embedded nulls (\0).

Similar to Lua's string library, most Buffer methods can be called as `buff:method(...)` or `bufflib.method(buff, ...)` (where `buff` is a Buffer). Note that not all methods use the same name in the Buffer metatable and the `bufflib` table. The primary examples of this are the metamethods, which use the required metamethod names in the metatable and more descriptive names in the `bufflib` table (e.g. the `__len` metamethod is the same as `bufflib.length`).

In addition to the functions shown here, you can call any method from the global `string` table (not just functions from the string library) on a Buffer (either as a method or a function from the `bufflib` table) by prefixing the name with `s_`. When you call a Buffer method with the `s_` prefix, it calls the equivalent `string` function with the Buffer's contents as the first argument followed by any other arguments supplied to the method. None of these methods modify the original Buffer.

For example, `bufflib.s_gsub(buff, ...)` and `buff:s_gsub(...)` are both equivalent to `str:gsub(...)` (where `buff` is a Buffer and `str` is the Buffer's contents as a string).

Buffers define metamethods for equality (==), length (#), concatenation (..) and tostring(). See the documentation of each metamethod for details.
latest sources | project homepage | License: MIT/X11

lua_cliargs - A command-line argument parser.

This module adds support for accepting CLI arguments easily using multiple notations and argument types.

cliargs allows you to define required, optional, and flag arguments.
latest sources | project homepage | License: MIT

Lua_Signal - Library for handling signals

Lua support for ANSI C signals.
latest sources | project homepage | License: N/A

luabins - Trivial Lua Binary Serialization Library

Luabins allows to save tuples of primitive Lua types into binary chunks and to load saved data back.
latest sources | project homepage | License: MIT/X11

LuaBitOp - Lua Bit Operations Module

Lua BitOp is a C extension module for Lua 5.1 which adds bitwise operations on numbers. Lua BitOp is Copyright © 2008 Mike Pall. Lua BitOp is free software, released under the MIT/X license (same license as the Lua core).
latest sources | project homepage | License: MIT/X license

LuaCOM - Use COM libraries from Lua

LuaCOM is an add-on library to the Lua language that allows Lua programs to use and implement objects that follow Microsoft's Component Object Model (COM) specification and use the ActiveX technology for property access and method calls.
latest sources | project homepage | License: MIT/X11

LuaCov - Coverage analysis tool for Lua scripts

LuaCov is a simple coverage analysis tool for Lua scripts. When a Lua script is run with the luacov module, it generates a stats file. The luacov command-line script then processes this file generating a report indicating which code paths were not traversed, which is useful for verifying the effectiveness of a test suite.
latest sources | project homepage | License: MIT/X11

LuaCrypto - A Lua frontend to OpenSSL

LuaCrypto is a Lua frontend to the OpenSSL cryptographic library. The OpenSSL features that are currently exposed are: digests (MD5, SHA-1, HMAC, and more), encryption, decryption and crypto-grade random number generators.

External dependencies: openssl

latest sources | project homepage | License: MIT

LuaCURL - Lua module binding CURL

LuaCURL is Lua 5.x compatible module providing Internet browsing capabilities based on the CURL library. The module interface follows strictly the CURl architecture and is very easy to use if the programmer has already experience with CURL.

External dependencies: curl

latest sources | project homepage | License: MIT/X11

luadaemon - Daemonize Lua Applications

Allows you to daemonize a Lua script/application, drop its uid/gid, ...
latest sources | project homepage | License: MIT/X11

LuaDate - Date & Time module for Lua 5.x

Pure Lua Date & Time module for Lua 5.x featuring date and Time string parsing, time addition & subtraction, time span calculation, support for ISO 8601 Dates, local time support, strftime-like formatting.
latest sources | project homepage | License: Public Domain

luadbi - Database abstraction layer

LuaDBI is a database interface library for Lua. It is designed to provide a RDBMS agnostic API for handling database operations. LuaDBI also provides support for prepared statement handles, placeholders and bind parameters for all database operations. This rock is the front end DBI module. You will need one or more backend DBD drivers to use this software.
latest sources | project homepage | License: MIT/X11

luadbi-mysql - Database abstraction layer

LuaDBI is a database interface library for Lua. It is designed to provide a RDBMS agnostic API for handling database operations. LuaDBI also provides support for prepared statement handles, placeholders and bind parameters for all database operations. This rock is the MySQL DBD module. You will also need the base DBI module to use this software.

External dependencies: mysql

latest sources | project homepage | License: MIT/X11

luadbi-postgresql - Database abstraction layer

LuaDBI is a database interface library for Lua. It is designed to provide a RDBMS agnostic API for handling database operations. LuaDBI also provides support for prepared statement handles, placeholders and bind parameters for all database operations. This rock is the PostgreSQL DBD module. You will also need the base DBI module to use this software.

External dependencies: postgres

latest sources | project homepage | License: MIT/X11

luadbi-sqlite3 - Database abstraction layer

LuaDBI is a database interface library for Lua. It is designed to provide a RDBMS agnostic API for handling database operations. LuaDBI also provides support for prepared statement handles, placeholders and bind parameters for all database operations. This rock is the Sqlite3 DBD module. You will also need the base DBI module to use this software.

External dependencies: sqlite

latest sources | project homepage | License: MIT/X11

luadns - Lua DNS

Allows Lua scripts to call on the system's DNS library to resolve hosts, get MX records, ...
latest sources | project homepage | License: MIT/X11

LuaDoc - LuaDoc is a documentation tool for Lua source code

LuaDoc is a documentation generator tool for Lua source code. It parses the declarations and documentation comments in a set of Lua source files and produces a set of XHTML pages describing the commented declarations and functions.

The output is not limited to XHTML. Other formats can be generated by implementing new doclets. The format of the documentation comments is also flexible and can be customized by implementing new taglets.
latest sources | project homepage | License: MIT/X11

luaepnf - Extended PEG Notation Format (easy grammars for LPeg)

This Lua module provides sugar for writing grammars/parsers using the LPeg library. It simplifies error reporting and AST building.
latest sources | project homepage | License: MIT

LuaExpat - XML Expat parsing

LuaExpat is a SAX (Simple API for XML) XML parser based on the Expat library.

External dependencies: expat

latest sources | project homepage | License: MIT/X11

luafam - Lua File Alteration Monitoring Interface

Allows Lua scripts to use FAM to monitor file changes

External dependencies: fam

latest sources | project homepage | License: MIT/X11

LuaFFT - Lua package that includes functions for Fast Fourier Transformations.

This is a port of the KissFFT Library which is a C implementation of the Fast Fourier Transformation (FFT). It contains an easy-to-use function to carry out FFTs. For complex numbers, a module from the Numeric Lua Library has been used.
latest sources | project homepage | License: MIT/X11

LuaFileSystem - File System Library for the Lua Programming Language

LuaFileSystem is a Lua library developed to complement the set of functions related to file systems offered by the standard Lua distribution. LuaFileSystem offers a portable way to access the underlying directory structure and file attributes.
latest sources | License: N/A

LuaGL - Lua bindings for OpenGL

It's a library that provides access to all of the OpenGL functionality from Lua 5.x. OpenGL is a portable software interface to graphics hardware.

External dependencies: glut, opengl

latest sources | project homepage | License: MIT/X11

LuaGRAPH - A binding to the graphviz graph library

LuaGRAPH is a binding to the graphviz library. It allows to create, manipulate, layout and render graphs using the Lua programming language.

External dependencies: graphviz

latest sources | project homepage | License: MIT/X11

luahaml - An implementation of the Haml markup language for Lua.

Lua Haml is an implementation of the Haml markup language for Lua.
latest sources | project homepage | License: MIT/X11

LuaHelp - Help pages for Lua

LuaHelp provides a simple interface to manual pages, called Lua Help Pages (LHP). From the interpreter, just call "help()" for a more detailed description.
latest sources | project homepage | License: Public domain

LuaHTML - LuaHTML is a template engine that allows the use of Lua code in your HTML websites.

LuaHTML is a template engine that allows the use of Lua code in your HTML websites. It stays close to the Lua philosophy and is easy to use.
latest sources | project homepage | License: Public Domain

luahue - A Lua library and tools to control Philips Hue light bulbs.

The library is a loose wrapper around the REST API provided by Philips. In addition, two command line utilities are included to demonstrate the use of the API. The first, `huectl`, is a generic tool that let's you control the various properties such as on/off, color, and brightness. The second utility, `huebwmon`, changes the colors of lights based on network utilization.
latest sources | project homepage | License: MIT

LuaIDL - A OMG IDL Compiler Front End

LuaIDL is an OMG IDL (Interface Definition Language) compiler front end, written in the Lua programming language. It can be used to perform a simple IDL parsing with low effort as well as it can be used to implement a complete and flexible IDL compiler. LuaIDL is very small, easy to install and to use. It offers a callback mechanism that allows its extension to generate different output formats. Additionally, it is very portable because it is completely implemented in Lua and does not have external dependencies.
latest sources | project homepage | License: MIT/X11

luaish-windows - luaish is a better REPL for Lua. luaish is based on lua.lua which is a Lua interpreter front-end written in Lua by David Manura.

latest sources | project homepage | License: MIT/X11

luajson - customizable JSON decoder/encoder

LuaJSON is a customizable JSON decoder/encoder using LPEG for parsing.
latest sources | project homepage | License: MIT/X11

lualogging - A simple API to use logging features

LuaLogging provides a simple API to use logging features in Lua. Its design was based on log4j. LuaLogging currently supports, through the use of appenders, console, file, rolling file, email, socket and SQL outputs.
latest sources | project homepage | License: MIT/X11

luamacro - A macro preprocessor for Lua

Provides intelligent lexical macros that can be scoped. By default it translates and runs code, keeping track of line numbers. LuaMacro 2 uses a LPeg lexical scanner and no longer needs the token filter patch.
latest sources | project homepage | License: MIT/X11

luanotify - Simple bind from libnotify to Lua.

Simple library binding libnotify to Lua, quite easy to use, supporting emergency levels. Pop up notifications from Lua to your desktop now is a piece of cake.

External dependencies: notify

latest sources | project homepage | License: MIT/X11

LuaPOD - Library for parsing POD files using Lua

Plain Old Documentation, or just POD, is a simple documentation format used mainly among users of the Perl programming language. LuaPOD is a tool that allows to translate a POD file into HTML using Lua and the LPeg library.
latest sources | project homepage | License: MIT/X11

luaposix - Lua bindings for POSIX (including curses)

A library binding various POSIX APIs, including curses. POSIX is the IEEE Portable Operating System Interface standard. luaposix is based on lposix and lcurses.
latest sources | project homepage | License: MIT/X11

LuaProfiler - Profiling for Lua scripts

LuaProfiler is a time profiler designed to help finding bottlenecks on your Lua program. If you use LuaProfiler into your program, it will generate a log of all your function calls and their respective running times. You can use this log to generate a summary of the functions your program uses, along with how long it stayed in each of them, or you can import the log into a spreadsheet for further analysis.
latest sources | project homepage | License: MIT/X11

LuaPSQL - PostgreSQL client bindings for Lua

LuaPSQL provides bindings to PostgreSQL's libpq client library.

External dependencies: libpq

latest sources | project homepage | License: MIT

luarepl - A reusable REPL component for Lua, written in Lua

latest sources | project homepage | License: MIT/X11

luars232 - Serial (RS-232) support

This module adds support for manipulation of the serial port in Lua. It statically links librs232 (see the project homepage for the stand-alone library).
latest sources | project homepage | License: MIT/X11

LuaSec - A binding for OpenSSL library to provide TLS/SSL communication over LuaSocket.

This version delegates to LuaSocket the TCP connection establishment between the client and server. Then LuaSec uses this connection to start a secure TLS/SSL session.

External dependencies: openssl (on unix)

latest sources | project homepage | License: MIT

luasoap - Support for SOAP

LuaSOAP provides a very simple API that convert Lua tables to and from XML documents
latest sources | project homepage | License: MIT/X11

LuaSocket - Network support for the Lua language

LuaSocket is a Lua extension library that is composed by two parts: a C core that provides support for the TCP and UDP transport layers, and a set of Lua modules that add support for functionality commonly needed by applications that deal with the Internet.
latest sources | project homepage | License: MIT

LuaSocket-Unix - Unix Domain Sockets for the Lua language

socket.unix is a LuaSocket module that implements support for Unix Domain Sockets.
latest sources | License: N/A

LuaSofia - LuaSofia is a Lua binding of Sofia-Sip library

Sofia-SIP is an open-source SIP User-Agent library, compliant with the IETF RFC3261 specification. It can be used as a building block for SIP client software for uses such as VoIP, IM, and many other real-time and person-to-person communication services. The primary target platform for LuaSofia is GNU/Linux.
latest sources | project homepage | License: GNU LGPL

luaSolidState - Library for storing and loading data

luaSolidState is a Lua library that allows easy and painless storing of tables in Lua.
latest sources | project homepage | License: Public Domain

LuaSQL-MySQL - Database connectivity for Lua (MySQL driver)

LuaSQL is a simple interface from Lua to a DBMS. It enables a Lua program to connect to databases, execute arbitrary SQL statements and retrieve results in a row-by-row cursor fashion.

External dependencies: mysql

latest sources | project homepage | License: MIT/X11

LuaSQL-Postgres - Database connectivity for Lua (Postgres driver)

LuaSQL is a simple interface from Lua to a DBMS. It enables a Lua program to connect to databases, execute arbitrary SQL statements and retrieve results in a row-by-row cursor fashion.

External dependencies: pgsql

latest sources | project homepage | License: MIT/X11

LuaSQL-SQLite3 - Database connectivity for Lua (SQLite3 driver)

LuaSQL is a simple interface from Lua to a DBMS. It enables a Lua program to connect to databases, execute arbitrary SQL statements and retrieve results in a row-by-row cursor fashion.

External dependencies: sqlite

latest sources | project homepage | License: MIT/X11

luassert - Lua Assertions Extension

Adds a framework that allows registering new assertions without compromising builtin assertion functionality.
latest sources | project homepage | License: MIT

LuaStatsd - A lua interface to a statsd server

luastatsd is a lua client library to the etsy/statsd statistics daemon.

For more info, see : * http://codeascraft.etsy.com/2011/02/15/measure-anything-measure-everything/ * https://github.com/etsy/statsd
latest sources | project homepage | License: MIT/X11

LuaSVN - Library for using Subversion from Lua

LuaSVN is a library that allows to use some Subversion (SVN) facilities inside Lua programs. Subversion is an open source version control system.

External dependencies: apr, apr_util, subversion

latest sources | project homepage | License: MIT/X11

luasyslog - Syslog logging for Lua

Addon for lualogging to log to the system log on unix systems.
latest sources | project homepage | License: MIT/X11

luatexts - Trivial Lua human-readable binary-safe serialization library

latest sources | project homepage | License: MIT/X11

LuaXML - a module that maps between Lua and XML without much ado

LuaXML provides a minimal set of functions for the processing of XML data in Lua. It offers a very simple and natural mapping between the XML data format and Lua tables, which allows one to parse XML data just using Lua's normal table access and iteration methods: Substatements and text content is represented as array data having numerical keys, attributes and tags use string keys. This representation makes sure that the structure of XML data is exactly preserved in a read/write cycle.
latest sources | project homepage | License: MIT/X11

luaxpl - xPL framework for Lua

xPL is an open source home automation protocol. LuaxPL provides all the basic ingredients for building your own xPL applications. Additionally it includes commandline utilities to send and log xPL traffic. A device template is included and the commandline utilities can be used as examples to quickly get up and running. One application is included to detect occupancy of a home based on smartphone detection (network connections). See http://xplproject.org.uk for more information on xPL.
latest sources | project homepage | License: MIT/X11

luaYAML - A YAML parser binding for Lua, using the syck library.

External dependencies: syck

latest sources | project homepage | License: BSD

LuaZip - Library for reading files inside zip files

LuaZip is a lightweight Lua extension library used to read files stored inside zip files. The API is very similar to the standard Lua I/O library API.

External dependencies: zzip

latest sources | project homepage | License: MIT/X11

lub - Lubyk base module.

lub: helper code, class declaration.

lub.Autoload: autoloading classes in modules.

lub.Dir: a simple directory traversal class.

lub.Template: a simple templating class.
latest sources | project homepage | License: MIT

Luchia - Lua API for CouchDB.

Luchia provides both low-level and high-level access to CouchDB (http://couchdb.apache.org), using an object-oriented approach.

All of the basic operations are supported, including: CRUD operations on databases, documents, and attachments (both inline and standalone); uuid generation (server side); various utility functions.
latest sources | project homepage | License: Modified BSD

ludent - A naive Lua indenter / formater / beautifier.

latest sources | project homepage | License: MIT/X11

luma - Lpeg-based macro system for Lua

Luma is a macro system for Lua that allows you to define macros with arbitrary syntax, but clearly delimited when surrounded by Lua code. Luma is inspired by Scheme's syntax-rules/syntax duo, and uses Lpeg for grammars and Cosmo for templates.
latest sources | project homepage | License: MIT/X11

lunamark - General markup format converter using lpeg.

Lunamark is a lua library and command-line program for conversion of markdown to other textual formats. Currently HTML, Docbook, ConTeXt, LaTeX, dzslides, and Groff man are the supported output formats, but it is easy to add new writers or modify existing ones. The markdown parser is written using a PEG grammar and can also be modified by the user.
latest sources | project homepage | License: MIT/X11

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

Lunary is a framework to read and write structured binary data from and to files or network connections. The aim is to provide an easy to use interface to describe any complex binary format, and allow translation to Lua data structures. The focus is placed upon the binary side of the transformation, and further processing may be necessary to obtain the desired Lua structures. On the other hand Lunary should allow reading and writing of any binary format, and bring all the information available to the Lua side.
latest sources | project homepage | License: MIT

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

Lunary is a framework to read and write structured binary data from and to files or network connections. This rock is a pure-Lua implementation of Lunary, without dependencies on any binary module. Because of that some features will be disabled. To use Lunary to its full extent, use the 'Lunary' rock.
latest sources | project homepage | License: MIT

lunary-optim - Optimizations for Lunary.

Lunary is a framework to read and write structured binary data from and to files or network connections. This rock provides faster implementation of some of the built-in datatypes of Lunary.
latest sources | project homepage | License: MIT

lunatest - xUnit-style + randomized unit testing framework

Lunatest is an xUnit-style unit testing framework, with additional support for randomized testing (a la QuickCheck).

It's upwardly compatible from lunit, except it does not change any functions in the standard library (by using assert_true() instead of assert()).
latest sources | project homepage | License: MIT/X11

lunit - A unit testing framework for Lua

Lunit is a unit testing framework for lua, written in lua. It provides 27 assert functions, and a few misc functions for usage in an easy unit testing framework. Lunit comes with a test suite to test itself. The testsuite consists of approximately 710 assertions.
latest sources | project homepage | License: MIT/X11

lunitx - Lunitx is a unit testing framework for lua, written in lua.

Lunitx is a unit testing framework for lua, written in lua, based heavily on Lunit 0.5, but modified to work with Lua 5.2. Lunitx provides 27 assert functions, and a few misc functions for usage in an easy unit testing framework. Lunit comes with a test suite to test itself. The testsuite consists of approximately 710 assertions.
latest sources | project homepage | License: MIT/X11

Luno - General purpose libraries for Lua.

Luno is a pure Lua implementation of a series of extensions for common tasks not covered in the standard library. The library comprises extended functions for dealing with strings, tables and io as well as some other general purpose functions like deep copy of tables.

Luno offers a small framework for object oriented programming. It is possible do declare a class, define a contructor, methods and even use inheritance.

Luno also provides support for functional programming. Functions like map, filter, reduce and many list operations are available. Also, support for function composition and partial parameter application (sometimes refered to as currying) is implemented.

Note: Luno means Lua (moon) in esperanto.
latest sources | project homepage | License: MIT

LUSE - Lua bindings for the Filesystems in Userspace (FUSE) library

LUSE is a Lua binding for the FUSE (Filesystems in Userspace) library. It lets developers create a filesystem in Lua. Since FUSE itself is not very fast, LUSE tries to not further slow things down, and adopted a userdata-based approach to data passing.

External dependencies: fuse

latest sources | project homepage | License: MIT/X11

lustache - {{Mustache}} rendering for Lua

lustache allows you to use the Mustache templating standard in Lua by passing in a string, data, and partial templates. It precompiles and caches templates for speed, and allows you to build complex strings such as html pages by iterating through a table and inserting values. Find out more about Mustache at http://mustache.github.com.
latest sources | project homepage | License: MIT

lut - Utility module for lubyk. Contains a documentation generator and testing facilities.

lub.Doc: a powerful documentation generator for Lua code with support for litterate programming, cross-reference linking, images, latex math, etc. lub.Test: unit testing framework.
latest sources | project homepage | License: MIT

luuid - A library for UUID generation

A library for generating universally unique identifiers based on libuuid, which is part of e2fsprogs.

External dependencies: libuuid

latest sources | project homepage | License: Public domain

LXSH - Lexing & syntax highlighting in Lua

LXSH is a collection of lexers and syntax highlighters written in Lua using the excellent pattern-matching library LPeg. The syntax highlighters can generate HTML, LaTeX (PDF) and RTF output.
latest sources | project homepage | License: MIT

lyaml - libYAML binding for Lua

Read and write YAML format files with Lua.

External dependencies: yaml

latest sources | project homepage | License: MIT/X11

lzlib - Lua bindings to the ZLib compression library

This package provides a library to access zlib library functions and also to read/write gzip files using an interface similar to the base io package.

External dependencies: zlib

latest sources | project homepage | License: MIT/X11

lzmq - Lua bindings to ZeroMQ 3

External dependencies: zmq3

latest sources | project homepage | License: MIT/X11

Markdown - Markdown text-to-html markup system.

A pure-lua implementation of the Markdown text-to-html markup system.
latest sources | project homepage | License: MIT

Math-Evol - Evolution search optimization

This module implements the evolution search strategy. This evolution strategy is a random strategy, and as such is particularly robust and will cope well with large numbers of variables, or rugged objective functions.
latest sources | project homepage | License: MIT/X11

Math-RungeKutta - Runge-Kutta methods for integrating systems of differential equations

RungeKutta.lua offers algorithms for the numerical integration of simultaneous differential equations of the form dY/dt = F(t,Y) where Y is an array of variables whose initial values Y(0) are known, and F is a function known from the dynamics of the problem.
latest sources | project homepage | License: MIT/X11

Math-WalshTransform - Fast Hadamard and Walsh Transforms

These routines implement fast Hadamard and Walsh Transforms and their inverse transforms. Also included are routines for converting a Hadamard to a Walsh transform and vice versa, for calculating the Logical Convolution of two lists, or the Logical Autocorrelation of a list, and for calculating the Walsh Power Spectrum - in short, almost everything you ever wanted to do with a Walsh Transform.
latest sources | project homepage | License: MIT/X11

MD5 - Basic cryptographic library

MD5 offers basic cryptographic facilities for Lua 5.1: a hash (digest) function, a pair crypt/decrypt based on MD5 and CFB, and a pair crypt/decrypt based on DES with 56-bit keys.
latest sources | project homepage | License: MIT/X11

microlight - A compact set of Lua utility functions.

Microlight provides a table stringifier, string spit and substitution, useful table operations, basic class support and some functional helpers.
latest sources | project homepage | License: MIT/X11

microscope - Creates images of arbitrary Lua values using GraphViz

This Lua module dumps arbitrarily complex Lua datastructures as GraphViz .dot-files that can be transformed into a variety of image formats.
latest sources | project homepage | License: MIT

MIDI - Reading, writing and manipulating MIDI data

This module offers functions for handling MIDI files, with operations such as concatenating, merging and searching through scores; and converting to and from MIDI, and the Score and Opus structures inspired by Sean Burke's MIDI-Perl CPAN module.
latest sources | project homepage | License: MIT/X11

midialsa - Provides access to the ALSA sequencer

This is a call-compatible translation into Lua of the Python module alsaseq.py by Patricio Paez. It gives access to the ALSA library, offering functions client, connectfrom, connectto, fd, id, input, inputpending, output, start, status, stop and syncoutput, plus some functions to interface with the MIDI.lua module.

External dependencies: alsa

latest sources | project homepage | License: MIT/X11

mimetypes - A simple library for looking up the MIME types of files.

This is a simple library for guessing a file's MIME type. It includes a (hopefully) comprehensive database of MIME types, but it allows you to create your own should you have specific requirements. It can guess types both by extension and by the complete filename.
latest sources | project homepage | License: MIT/X11

Mixlua - A preprocessor for files including embedded Lua code

Mixlua is a library for Lua 5.1 which provides an onload preprocessor for lua files and allows mixing of Lua code with other data. It provides loadstring() and loadfile() functions similar to the Lua ones but with aditional arguments for specifing how the data elements are recognized and handled. So CGILua's Lua Page format can be parsed using mix.loadfile("filename", "", "=")
latest sources | project homepage | License: MIT/X11

MobDebug - MobDebug is a remote debugger for the Lua programming language

MobDebug allows you control the execution of another Lua program remotely, set breakpoints, and inspect the current state of the program.

MobDebug is based on [RemDebug](http://www.keplerproject.org/remdebug/) and extends it in several ways:

1. fixed several existing bugs; 2. added new commands: LOAD, RELOAD, OUT, STACK; 3. added support for [MoSync](http://mosync.com/) using [MobileLua](https://github.com/divineprog/mobilelua); 4. added support for debugging wxwidgets applications; 5. tested integration with [ZeroBrane Studio IDE](http://studio.zerobrane.com/); 6. removed dependency on LuaFileSystem; 7. added ability to pause and abort running applications; 8. added pretty printing and handling of multiple results in EXEC; 9. added stack and local/upvalue value reporting (STACK); a. added on/off commands to turn debugging on and off (to improve performance); b. added support for coroutine debugging (see examples/README for details); c. added support for [Moai](http://getmoai.com/) debugging.
latest sources | project homepage | License: MIT/X11

moonscript - A programmer friendly language that compiles to Lua

latest sources | project homepage | License: MIT

moses - Utility library for functional programming in Lua

A utility library provinding handy functions for common programming tasks and support for functional programming. It complements the built-in Lua table library, making easier operations on arrays, lists, collections and objects, through 88 weird, bizarre and odd functions.
latest sources | project homepage | License: MIT

Nancy - A simple web site builder

Nancy is a simple web site builder, using just four simple commands to weave fragments of HTML, CSS, Javascript and whatever else you like into a web site. Using Nancy you can build pretty much any web site whose logical structure mirrors its URL layout, and which does not rely on dynamically computed content.
latest sources | project homepage | License: GNU General Public License

netcheck - A LuaSocket addon that checks changes in the network connection

NetCheck provides a few functions to verify the connection is (un)changed. Connects, disconnects, loopback, IP changes etc. can be detected with a single call.
latest sources | project homepage | License: MIT/X11

nixio - System, Networking and I/O library for Lua

Nixio is a multi-platform library offering a wide variety of features such as IPv4, IPv6 and UNIX networking, large file I/O, file system operations, system and process control, POSIX user/group management, basic cryptographical hashing, hmac and TLS support, bit operations and binary conversion.

External dependencies: openssl

latest sources | project homepage | License: Apache 2.0

NumLua - Numerical routines for Lua

Numeric Lua is a numerical package for the Lua programming language. It includes support for complex numbers, multidimensional matrices, random number generation, fast Fourier transforms, and special functions. Most of the routines are simple wrappers for well known numerical libraries: complex numbers and part of the extended math modules come from C99; other special functions, including statistical functions, are adapted from Netlib's SLATEC and DCDFLIB; random number generation is based on Takuji Nishimura and Makoto Matsumoto's Mersenne Twister generator as the "engine" (uniform deviates) and Netlib's RANLIB for the remaining deviates; fast Fourier transforms are implemented from FFTW; and the matrix package draws most of its numeric intensive routines from Netlib's ubiquitous BLAS and LAPACK packages.

External dependencies: fftw3, hdf5

latest sources | project homepage | License: MIT

OAuth - Lua OAuth, an OAuth client library.

Lua client for OAuth 1.0 enabled servers.

External dependencies:

latest sources | project homepage | License: MIT/X11

objectlua - A class-oriented OOP module for Lua

This is an implementation of a class-oriented Lua module, coded entirely in Lua. Its goal is to provide Lua with minimal and reusable OOP, as well as to be easily predictable and extensible.
latest sources | project homepage | License: MIT

odbc - ODBC library for Lua

External dependencies: odbc (on unix), odbc (on windows)

latest sources | project homepage | License: MIT/X11

OiL - An Object Request Broker in Lua

OiL stands for ORB in Lua and it is a very portable and lightweight implementation of easy-to-use object request brokers (ORB) written in Lua. OiL ORBs are made of assembled components that can be selectively chosen or replaced to create ORBs with different features. Currently, it provides components that support cooperative multithreading (with coroutines), interoperability with CORBA (through IIOP), interception of CORBA invocations, etc.
latest sources | project homepage | License: MIT/X11

Orbit - MVC for Lua Web Development

Orbit is a library for developing web applications according to the Model-View-Controller paradigm in Lua.
latest sources | project homepage | License: MIT/X11

penlight - Lua utility libraries loosely based on the Python standard libraries

Penlight is a set of pure Lua libraries for making it easier to work with common tasks like iterating over directories, reading configuration files and the like. Provides functional operations on tables and sequences.
latest sources | project homepage | License: MIT/X11

Petrodoc - Making Rockspecs, HTML and RSS from a single source

Petrodoc allows you to use a single configuration file to generate a rockspec, HTML documentation (with Luadoc) and an RSS feed for new releases.
latest sources | project homepage | License: MIT/X11

Pluto - Heavy duty persistence for Lua

Pluto is a library which allows users to write arbitrarily large portions of the "Lua universe" into a flat file, and later read them back into the same or a different Lua universe. Object references are appropriately handled, such that the file contains everything needed to recreate the objects in question.

External dependencies: lua_sources

latest sources | project homepage | License: Public domain

pop3 - Simple POP3 client library for Lua 5.1/5.2

latest sources | project homepage | License: MIT/X11

prototype - A small library for prototype based OO programming.

Although Lua is more suited to prototype based OO programming almost all OO examples/tutorials cover class based OO. This module provides the means to create highly configurable object hierarchies using prototype based OO programming in Lua.
latest sources | project homepage | License: MIT

prtr-dump - A simple module to dump a Lua value to a string or a file.

The prtr-dump module is a simple Lua module that pretty-prints some Lua values in such a way that they are human-readable, while still being valid Lua source to be reloaded by the Lua interpreter.
latest sources | project homepage | License: MIT

prtr-path - A simple module to manipulate file paths in Lua.

The prtr-path module is a simple Lua module that manipulates file paths. Path objects can be created from strings, and concatenated together using the / operator. Additionally they provide some useful accessors, methods and metamethods.
latest sources | project homepage | License: MIT

prtr-test - A simple module to help in writing Lua modules self-tests.

The prtr-test module is a simple Lua module that defines a global 'expect' function, similar to 'assert' but that takes one more initial parameter, an expected value, that the actual tested value must match (rather than just being true as is the case of 'assert').
latest sources | project homepage | License: MIT

push - Lua library implementing knockout.js-like observable properties.

When dealing with keeping multiple data layers in sync as common in GUIs (View-ViewModel or View-Model relations), it is easy to introduce bugs and unfocused code blocks. The actual intent is shadowed by syncing boilerplate for all form fields/model bindings. That is especially true for HTML applications, where databinding is additionally complicated by DOM access, and here knockout.js kicks in. This library tries to provide the observable part as a modular core for other projects. It is actually written in MoonScript and as such the lua files are a nice autogenerated byproduct (and nothing more to me).
latest sources | project homepage | License: MIT/X11

ReCaptcha - A Lua interface to reCaptcha.

reCaptcha is a free captcha web service that shows the visitors words from old books helping digitize them. This, module provides a Lua interface to recaptcha. You will need to get your own API key from recaptcha.net to use it.
latest sources | project homepage | License: MIT/X11

redis-lua - A Lua client library for the redis key value storage system.

A Lua client library for the redis key value storage system.
latest sources | project homepage | License: MIT/X11

RemDebug - Remote Debugger for the Lua programming language

RemDebug is a remote debugger for Lua. It lets you control the execution of another Lua program remotely, setting breakpoints and inspecting the current state of the program. RemDebug can also debug CGILua scripts.
latest sources | project homepage | License: MIT/X11

Rings - Create new Lua states from within Lua

Rings is a library which provides a way to create new Lua states from within Lua. It also offers a simple way to communicate between the creator (master) and the created (slave) states.
latest sources | project homepage | License: MIT/X11

say - Lua String Hashing/Indexing Library

Useful for internationalization.
latest sources | project homepage | License: MIT

schema - Schema

Schema is a module that allows the declaration of data structures composed of Entities and Fields. Its primary use is to define the model for ORMs and Form generators, but it can be used to declare any such structure.
latest sources | project homepage | License: MIT/X11

semver - An implementation of semantic versioning (semver.org) in Lua

See details in http://semver.org
latest sources | project homepage | License: MIT

serpent - Lua serializer and pretty printer

latest sources | project homepage | License: MIT

servicekit-posix - Long-lived daemons and/or services for Lua

ServiceKit provides a simple way to create background services ("daemons") in Lua, with a platform-agnostic API. This particular package is for Unix operating systems that are Posix compliant.
latest sources | project homepage | License: MIT/X11

set - Straightforward Set library

Creating and manipulating sets, including + (union), - (subtraction), * (intersection), len(), and tostring()
latest sources | project homepage | License: MIT

sha2 - Lua binding for Aaron Gifford's SHA-2 implementation

Lua Binding for the SHA-2 (SHA-256/384/512) BSD-licensed C implementation by Aaron Gifford. Also contains a HMAC implementation in Lua.
latest sources | project homepage | License: MIT/X11

Shake - A Simple Lua Test Engine

Shake is a simple and transparent test engine for Lua that assumes that tests only use standard assert and print calls. Shake uses Leg and LPeg to preprocess test files and extract a lot more information than what is usually available when tests use standard Lua assertions.
latest sources | project homepage | License: MIT/X11

Simulua - Simulua is a discrete-event process-oriented simulation library for Lua.

Simulua is a discrete-event simulation library for Lua. The simulation in Simulua is process-oriented, that is, the operation path of a simulated system is obtained from interactions of processes running in parallel and managed by an event list.
latest sources | project homepage | License: MIT/X11

slncrypto - A cryptography library

A cryptography support library for Lua, developed for the Selene database project.
latest sources | project homepage | License: MIT/X11

slnunicode - A Unicode library

A Unicode support library for Lua, developed for the Selene database project.
latest sources | project homepage | License: Tcl License + MIT/X11

SocialLua - Library for interfacing with many sites and services

SocialLua is a set of modules that aims to provide simple Lua function wrappers for many internet sites and service APIs.
latest sources | project homepage | License: Public Domain

specl - Behaviour Driven Development for Lua

Develop and run BDD specs written in Lua for RSpec style workflow.
latest sources | project homepage | License: GPLv3+

Sputnik - A wiki and a framework for wiki-like applications

Sputnik is a wiki written in Lua. It is also a platform for building a range of wiki-like applications, drawing on Lua's strengths as an extension language.

Out of the box Sputnik behaves like a wiki with all the standard wiki features: editable pages, protection against spam bots, history view of pages, diff, preview, per-page-RSS feed for site changes. (See http://sputnik.freewisdom.org/en/Features for more details.)

At the same time, Sputnik is designed to be used as a platform for a wide range of "social software" applications. A simple change of templates and perhaps a few spoons of Lua code can turn it into a photo album, a blog, a calendar, a mailing list viewer, or almost anything else. So, you can think of it as a web framework of sorts. In addition to allowing you to add custom bells and whistles to a wiki, Sputnik provides a good foundation for anything that's kind of like a wiki but not quite. Sputnik stores its data as versioned "pages" that can be editable through the web (just like any wiki). However, it allows those pages to store any data that can be saved as text (prose, comma-separated values, lists of named parameters, Lua tables, mbox-formatted messages, XML, etc.) While by default the page is displayed as if it carried Markdown-formatted text, the way the page is viewed (or edited, or saved, etc.) can be overriden on a per-page basis by over-riding or adding "actions".
latest sources | project homepage | License: MIT/X11

statsd - Statsd client.

Statsd client for Lua 5.1+. Uses the luasocket library for UDP.
latest sources | project homepage | License: MIT/X11

stdlib - General Lua libraries

stdlib is a library of modules for common programming tasks, including list, table and functional operations, regexps, objects, pickling, pretty-printing and getopt.
latest sources | project homepage | License: MIT/X11

StringDistance - Damerau-Leveinshtein Distance

String Distance is a package that offers two algorithms to calculate string distances: Levenshtein and Damerau-Levenshtein.
latest sources | project homepage | License: MIT/X11

stringio - Reading and writing Lua strings as file objects

stringio.open() gives you a file-like object which has Lua 5.2 compatible methods like read() and lines(); stringio.create() gives you an object with a write() method, and a value() method for the created string.
latest sources | project homepage | License: MIT/X11

stringy - C extension for fast string methods

Includes fast methods for endswith, startswith, split and strip. Implementations of split and strip from the wiki and book. This was implemented as a learning exercise. Additions are welcome if the library is kept simple. Usage is:

> require "stringy" > = stringy.strip(" asdf ") asdf

> = table.concat(stringy.split("aXbXc", "X"), "|") a|b|c

> = stringy.startswith("asdf", "as") true > = stringy.endswith("asdf", "as") false
latest sources | project homepage | License: MIT/X11

struct - A library to convert Lua values to and from C structs

This library offers basic facilities to convert Lua values to and from C structs. Its main functions are struct.pack, which packs multiple Lua values into a struct-like string; and struct.unpack, which unpacks multiple Lua values from a given struct-like string.
latest sources | project homepage | License: MIT/X

tamale - Erlang-style pattern matching for Lua

Tamale adds structural pattern matching (as in Erlang, Prolog, etc.) to Lua. Pattern matching unpacks and matches on data structures like regular expressions do on strings.

Rather than writing a series of nested ifs to test and extract from a structure, you can build a test function from a series of rules, and it will generate a dispatch function (with variable captures, etc.).
latest sources | project homepage | License: MIT/X11

tango-complete - Remote procedure calls (RPC) for Lua.

latest sources | project homepage | License: MIT/X11

tango-copas - Remote procedure calls (RPC) for Lua.

latest sources | project homepage | License: MIT/X11

telescope - A test/spec library for Lua.

Telescope is a test/spec library for Lua.
latest sources | project homepage | License: MIT/X11

tethys - Tethys SMTP Server

Easy to use, small, understandable, extensible SMTP server.
latest sources | project homepage | License: GPL-3

tincan - Dead simple persistent key value store library.

latest sources | project homepage | License: ISC

tlua - A simple task runner

Tlua helps reuse and run snippets of code from the command line.
latest sources | project homepage | License: MIT/X11

twitter - A Twitter library for Lua.

A Twitter library for Lua.
latest sources | project homepage | License: CC0

typical - A typing library that offers more flexibility than type()

latest sources | project homepage | License: MIT/X11

uuid - Generates uuids in pure Lua

Generates uuids in pure Lua, but requires a good random seed or a unique string. Please check the documentation.
latest sources | project homepage | License: Apache 2.0

validate-args - Function argument validation

validate.args is a Lua module that provides a framework for validation of arguments to Lua functions as well as complex data structures. The included validate.inplace module provides "live" validation during assignment of values to elements in tables.
latest sources | License: GPL-3

vararg - Manipulation of variable arguments

'vararg' is a Lua library for manipulation of variable arguments (vararg) of functions. These functions basically allows you to do things with vararg that cannot be efficiently done in pure Lua, but can be easily done through the C API.
latest sources | project homepage | License: MIT/X11

Vert - Creates isolated development environment

Vert is a tool for building isolated development environments akin to VirtualEnv in Python. It handles compiling and installing Lua to a local directory as well as setting up LuaRocks.
latest sources | License: MIT/X11

web_sanitize - Lua library for sanitizing untrusted HTML

latest sources | project homepage | License: MIT

webrocks - Web-based local interface for LuaRocks

webrocks provides the script wrocks, which runs a little local webserver and launches your browser. You can then install or remove rocks interactively. Defaults to localhost:8080, but -addr=ADDR and -port=PORT will override, if you wish to run it remotely on a server. -nolaunch will suppress the launching of the browser.
latest sources | project homepage | License: MIT/X11

winapi - Minimal but useful bindings to Windows API

winapi can enumerate and access windows and process, read and write to the registry, monitor filesystem changes and provides flexible ways to launch processes.
latest sources | project homepage | License: MIT/X11

WSAPI - Lua Web Server API

WSAPI is an API that abstracts the web server from Lua web applications. This is the rock that contains the base WSAPI libraries plus the CGI adapters.
latest sources | project homepage | License: MIT/X11

WSAPI-Basic_Auth - HTTP Basic Authentication for WSAPI

A module implemented HTTP basic access authentication for WSAPI. This provides a run() function that wraps around the run() function for your WSAPI handler.
latest sources | License: MIT/X11

WSAPI-FCGI - Lua Web Server API FastCGI Adapter

WSAPI is an API that abstracts the web server from Lua web applications. This is the rock that contains the FCGI module lfcgi.

External dependencies: fastcgi (on unix)

latest sources | project homepage | License: MIT/X11

WSAPI-Xavante - Lua Web Server API - Xavante Handler

WSAPI is an API that abstracts the web server from Lua web applications. This is the rock that contains the Xavante adapter and launcher.
latest sources | project homepage | License: MIT/X11

Xavante - Lua Web Server Library

Xavante is a Lua HTTP 1.1 Web server that uses a modular architecture based on URI mapped handlers. This rock installs Xavante as a library that other applications can use.
latest sources | project homepage | License: MIT/X11

xctrl - module to query and manipulate X11 managers and windows

xctrl can do things like return a list of all top-level windows, retrieve window information, set title and position of windows, work with the X cliipboard, and send fake keyboard events to a window. (Author Jeff Pohlmeyer)

External dependencies: x11

latest sources | project homepage | License: GPL2

XSSFilter - A filter to prevernt cross-site scripting (XSS) attacks

XSSFilter is a module for filtering out unsafe tags from (X)HTML. To avoid having second-guessing how different clients handle strange HTML input, the filter assumes that the input is subset of valid XML and returns nil if the input doesn't parse. If the input does parse, we then traverse the tree and check each element and its attributes against a configuration table, replacing anything that's not allowed with a message. There is a default configuration table that shoots for a balance between security and features, but the client can either supply their own or modify the default.
latest sources | project homepage | License: MIT/X11

yaml - Lua YAML serialization using LibYAML

This module is a Lua binding for Kirill Siminov's excellent LibYAML. LibYAML is generally considered to be the best C YAML 1.1 implementation.

External dependencies: yaml

latest sources | project homepage | License: MIT

zee - Experimental lightweight editor

Zee is a lightweight editor. Zee is aimed at small footprint systems and quick editing sessions (it starts up and shuts down instantly).
latest sources | project homepage | License: GPLv3+

ZipWriter - Library for creating ZIP archive for Lua 5.1/5.2

This package provides a library to create zip archives. This library support non seekable streams (e.g. socket), ZIP64 format and AES encrypting.
latest sources | project homepage | License: MIT/X11