Open Source Lua Frameworks for BSD

IUP is a portable toolkit for building graphical user interfaces. It offers a configuration API in three basic languages: C, Lua and LED. IUP purpose is to allow a program to be executed in different systems without any modification.

Lapis is a framework for building web applications in Lua (or MoonScript) that primarily targets OpenResty, a high-performance web platform that runs on a customized version of Nginx. Lapis can also be used in other server environments, being compatible with any modern version of Lua. With OpenResty, Lua is run directly inside of the Nginx worker using LuaJIT, giving you the smallest barrier between the webserver and your code. Have a look at Web Framework Benchmarks just to see how OpenResty stacks up against other platforms. Utilizing the power of Lua coroutines, you can write clean code that looks synchronous but can achieve high throughput by automatically running asynchronously without blocking. Networking operations like database queries and HTTP requests will automatically yield to allow for handling concurrent requests, all without all that callback spaghetti seen in other asynchronous platforms.

Doom Nvim is a Neovim interpretation of the doom-emacs framework, adapted to Vim philosophy. Our goal is to provide a configurable, extensible, performant and stable basis for any neovim configuration.

LuaRadio is 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. LuaRadio is built on LuaJIT, has a small binary footprint of under 750 KB (including LuaJIT), has no external hard dependencies, and is MIT-licensed. LuaRadio can be used to rapidly prototype software radios, modulation/demodulation utilities, and signal processing experiments. It can also be embedded into existing radio applications to serve as a user-scriptable engine for signal processing. LuaRadio blocks are written in pure Lua, but can use LuaJIT's FFI to wrap external libraries, like VOLK, liquid-dsp, and others, for computational acceleration, sophisticated processing, and interfacing with SDR hardware.

wxLua is a Lua scripting language wrapper for the wxWidgets cross-platform GUI library. It consists of executables for editing, running, and debugging wxLua scripts, a library for extending C++ programs with a fast, small, fully embeddable scripting language, and a variety of sample programs. With wxLua you can quickly write full-featured programs with graphics, networking, printing, etc. for MS Windows, Linux, and OSX.

CD (Canvas Draw) is a platform-independent graphics library. It is implemented in several platforms using native graphics libraries: Windows (GDI) and X-Windows (XLIB). The canvas is an abstract surface that can be a window, an image or a metafile.

IM is a toolkit for Digital Imaging. IM is based on 4 concepts: Image Representation, Storage, Processing and Capture. The main goal of the library is to provide a simple API and abstraction of images for scientific applications.

A framework for interacting with tests within NeoVim. For any runner without an adapter you can use neotest-vim-test which supports any runner that vim-test supports. The vim-test adapter does not support some of the more advanced features such as error locations or per-test output. If you're using the vim-test adapter then install vim-test too.

LuaUnit is a popular unit-testing framework for Lua, with an interface typical of xUnit libraries (Python unittest, Junit, NUnit, ...). It supports several output formats (Text, TAP, JUnit, etc.) that can be used directly or work with continuous integration platforms (Jenkins, Maven, etc.). LuaUnit may be installed as a rock or directly added to your project. For simplicity, LuaUnit is contained into a single file and has no external dependency. LuaUnit may also be used as an assertion library, to validate assertions inside a running program. In addition, it provides a pretty stringifier that converts any type into a nicely formatted string (including complex nested or recursive tables).

LOVE is a free 2D game engine which enables easy game creation in Lua.

hiperGL - Is a 2D OpenGL hardware accelerated blitter, graphic loader, frame manager, a DIV like sprite system, and more utilities for creating video games. It works under SDL. It's portable, and easy to use.

!!! Albion 2 has moved to http://albion2.org !!!

A mature cross-platform C++ library for use as a default application framework. Features include: * Threading & synchronization * Socket programming: SSL, NanoMsg & ZMQ * File I/O utilities: zlib, ini, yaml * Native Database access: MySQL, SQLite, BerkleyDB, Postgre, REDIS and ODBC * Built-in mini XML parser; optional EXPAT, LIBXML and MSXML support * Network protocol stack: HTTP, FTP, SMTP, POP3, SOAP, XMLRPC * Scripting languages: Perl, Python, JavaScript, VBScript, Java, Lua, TCL, Squirrel * Cloud Computing: AWS * Encryption: OpenSSL * Platforms: Linux/Posix, Windows, Arduino * Over 500+ highly reusable classes. 4000+ fully documented functions. Follow the 'Wiki' link above to explore everything about the framework.

This is a game engine that helps game developer to produce game easier.It is writen in C++ and all of the functions are fixed into classes as the engine is designed in the method of Object-Oriented.

CoPP is an object-oriented framework for developing algorithms for robot path planning. One of of the design goals is to make it easy to make comparisons between various path planning algorithms.

CppLua is an object oriented framework to deal with Lua objects and functions in C++. Member functions can be registered into Lua and Lua functions and tables can be used in C++ code with a very simple and intuitive syntax.

A fast and minimalist web framework based on OpenResty.

LuaDist is a CMake built module distribution and deployment tool for the Lua programming language. It aims to achieve zero configuration runtime environment for Lua modules and libraries be it source or binary.

Lightweight Linq-like library for Lua. For the latest version of this project, refer to http://code.google.com/p/lualinq/ Sorry for that. The syntax is very similar to LINQ and reminds of SQL, for those who already know those languages. It’s released with a BSD 3 clause license. It uses a very basic subset of Lua, which allows it to be used also in very restrictive embedding scenarios (e.g. videogames). The focus on data instead of processing makes it suitable for all those scripts where querying the hosting application entities is paramount: RPG videogames, Adobe Photoshop Lightroom.

Luvit implements the same APIs as Node.js, but in Lua. This helps teams migrate without having to learn a new way of programming. Choose your async model; we don’t mind; we encourage experimentation. If you don’t like callbacks and event emitters, use coroutines and write blocking-style code without actually blocking your event loop. The various projects in the luvit ecosystem can be mixed and matched to build the ideal runtime for your application. The luvit CLI tool can be used as a scripting platform just like node. This can be used to run lua scripts as standalone servers, clients, or other tools.

Networking and sockets in scripting languages is difficult and often overcomplicated! Monasic is a server daemon (service) which does all the low level work to create a simple message-based environment, allowing easy access to networking via scripts.

NiL is a modular multi-purpose gaming engine including a multiplayer worm game a little like quake, except it's 2d and a little like worms except it's realtime.

Ninja INI is a simple, lightweight, and fast INI file reader & writer. It supports 3 levels (sections, keys, and containers), multiple keys with same name, parse command-line (argc & argv). Written in C++ with STL design and optional bindings to Lua.

Universal, platform independet, scriptable, networking game engine with physics and sound support.

This project aims at writing a threaded, object-oriented and scriptable game engine targetting the .NET platform, using a mixture of c# or managed c++ ports of famous c/c++ components such as OGRE, CEGUI, Newton, Lua, Python, Audiere, OpenAL, etc...