A programmer friendly language that compiles to Lua.
Want to experiment? Try out the online compiler.

MoonScript is a dynamic scripting language that compiles into Lua. It gives you the power of one of the fastest scripting languages combined with a rich set of features.

local Thing do local _base_0 = { name = "unknown" } _base_0.__index = _base_0 local _class_0 = setmetatable({ __init = function() end, __base = _base_0, __name = "Thing" }, { __index = _base_0, __call = function(cls, ...) local _self_0 = setmetatable({}, _base_0) cls.__init(_self_0, ...) return _self_0 end }) _base_0.__class = _class_0 Thing = _class_0 end local Person do local _parent_0 = Thing local _base_0 = { say_name = function(self) return print("Hello, I am " .. tostring(self.name) .. "!") end } _base_0.__index = _base_0 setmetatable(_base_0, _parent_0.__base) local _class_0 = setmetatable({ __init = function(self, ...) return _parent_0.__init(self, ...) end, __base = _base_0, __name = "Person", __parent = _parent_0 }, { __index = function(cls, name) local val = rawget(_base_0, name) if val == nil then return _parent_0[name] else return val end end, __call = function(cls, ...) local _self_0 = setmetatable({}, _base_0) cls.__init(_self_0, ...) return _self_0 end }) _base_0.__class = _class_0 if _parent_0.__inherited then _parent_0.__inherited(_parent_0, _class_0) end Person = _class_0 end do local _with_0 = Person() _with_0.name = "MoonScript" _with_0:say_name() end
class Thing
  name: "unknown"

class Person extends Thing
  say_name: => print "Hello, I am #{@name}!"

with Person!
  .name = "MoonScript"
  \say_name!

MoonScript can either be compiled into Lua and run at a later time, or it can be dynamically compiled and run using the moonloader. It’s as simple as require "moonscript" in order to have Lua understand how to load and run any MoonScript file.

Because it compiles right into Lua code, it is completely compatible with alternative Lua implementations like LuaJIT, and it is also compatible with all existing Lua code and libraries.

The command line tools also let you run MoonScript directly from the command line, like any first-class scripting language.

A comprehensive overview of the language can be found in the reference manual, the rest of this page serves as an overview of the language.

Overview

MoonScript provides a clean syntax using significant whitespace that avoids all the keyword noise typically seen in a Lua script. Below is a sample of some constructs found in the language.

local x = 2323 local collection = { height = 32434, hats = { "tophat", "bball", "bowler" } } my_func = function(a) return x + a end print(my_func(100))
export my_func
x = 2323

collection =
  height: 32434
  hats: {"tophat", "bball", "bowler"}

my_func = (a) -> x + a

print my_func 100

It also adds table comprehensions, implicit return on functions, classes, inheritance, scope management statements import & export, and a convenient object creation statement called with.

local concat, insert do local _obj_0 = table concat, insert = _obj_0.concat, _obj_0.insert end local double_args double_args = function(...) local _accum_0 = { } local _len_0 = 1 local _list_0 = { ... } for _index_0 = 1, #_list_0 do local x = _list_0[_index_0] _accum_0[_len_0] = x * 2 _len_0 = _len_0 + 1 end return _accum_0 end local tuples do local _accum_0 = { } local _len_0 = 1 for k, v in ipairs(my_table) do _accum_0[_len_0] = { k, v } _len_0 = _len_0 + 1 end tuples = _accum_0 end
import concat, insert from table

double_args = (...) ->
  [x * 2 for x in *{...}]

tuples = [{k, v} for k,v in ipairs my_table]

It can be loaded directly from a Lua script without an intermediate compile step. It even knows how to tell you where errors occurred in the original file when they happen.

Installation

Installing with LuaRocks

If you're on Windows, then install the Windows binaries, otherwise the easiest way to install is to use LuaRocks.

LuaRocks can be obtained here or from your package manager.

After it is installed, run the following in a terminal:

$ luarocks install moonscript

This will provide the moon and moonc executables along with the moonscript and moon Lua module.

Windows Binaries

Precompiled Windows binaries are available to avoid the trouble of compiling:
http://moonscript.org/bin/moonscript-0.2.6.zip

Extract the contents into your PATH.

Optional

If you're on Linux and use watch mode (which compiles .moon files to .lua files as they are changed) you can install linotify to use inotify instead of polling.

Source

The source code to the project lives on github:
https://github.com/leafo/moonscript

Issues with the tool can be reported on the issue tracker:
https://github.com/leafo/moonscript/issues

The latest development version can be installed with the dev rockspec:

$ luarocks build http://moonscript.org/rocks/moonscript-dev-1.rockspec

Dependencies

In addition to Lua 5.1 or 5.2, the following Lua modules are required to run the compiler and associated tools:

All of the required ones can be retrieved automatically using the LuaRocks installation.

Learning

Extras & Addons

Editor Support

Vim syntax and indent:
https://github.com/leafo/moonscript-vim

Textmate (and Sublime Text) syntax and indent:
https://github.com/leafo/moonscript-tmbundle

SciTE (with scintillua) syntax:
https://github.com/leafo/moonscript/tree/master/extra/scintillua

Preconfigured and packaged version of SciTE for Windows with MoonScript support:
http://moonscript.org/scite/

Tools

Online Compiler:
http://moonscript.org/compiler/

Overview of Differences & Highlights

A more detailed overview of the syntax can be found in the documentation.

About

The syntax of MoonScript has been heavily inspired by the syntax of CoffeeScript. MoonScript is CoffeeScript for Lua.

MoonScript would not have been possible without the excellent tool LPeg for parsing.

Changelog

Fork me on GitHub
MoonScript Lua