Brozula is a luajit bytecode compiler that generates ES5 JavaScript. This means you can write webapps using lua code, compile it to bytecode, and run the lua in either node.js or a browser environment.

This project is not done. I just started it while I was at Lua Workshop 2012 in DC. Currently it can parse nearly all luajit bytecode and execute a subset of the lua language. This is not a lua -> bytecode compiler. You'll need the luajit binary to do that part of the conversion. Performance seems pretty good so far in initial benchmarks. Only time will tell how this scales.

Brozula can be used as either a nodejs module or a browser library. To see how to use in the browser, look at index.html. To use in nodejs, use the brozula module in npm.

There is a command-line-interface to brozula called brozula that can be installed by installing the npm module globally.

npm install -g brozula

I'll let the tool speak for itself since it's self documented.

There is also a recording of using it in action.

$ brozula
Usage: brozula [OPTION...] program.lua[x]
Brozula compiles lua files to bytecode and then executes them using a JS VM
The lua -> luax (luajit bytecode) step is done by using luajit

Examples:
  brozula myprogram.lua
  brozula --print myprogram.lua
  brozula -pb myprogram.luax

 Main operation mode:

  -x, --execute          Execute the generated javascript
                         (This is the default behavior)
  -p, --print            Print the generated javascript
  --serve port           Serve the current folder over HTTP auto-compiling
                         any lua scripts requested

 Operation modifiers:

  -u, --uglify           Compress the generated javascript using uglify-js
  -b, --beautify         Beautify the generated javascript using uglify-js
  -l, --lines            Show line numbers when printing

One use of this is to write end-to-end lua webapps using something like luvit or moonslice for the server-side half, and writing your browser-side scripts in lua that's then executed in the browser using Brozula.

I plan on adding child process support to luv so that a moonslice framework can be built for doing everything from a single place.

The question comes up all the time. How can I ship a JavaScript app without sharing my code with the world. JavaScript minimizers do a pretty good job at this, but we can do better.

If you want your JavaScript code protected from prying eyes, write it in Lua! Then you only have to share the binary bytecode publicly which is considerably harder to make sense of and near impossible to trace back to the original code.

For example, consider the following lua module that calculates factorials:

local function fact (n)
  if n == 0 then
    return 1
  else
    return n * fact(n-1)
  end
end
return fact

The only code you have to store in your node-webkit or web app would be brozula and the following bytecode:

00000000  1b 4c 4a 01 02 37 00 01  03 01 00 02 0b 09 00 00  |.LJ..7..........|
00000010  00 54 01 03 80 27 01 01  00 48 01 02 00 54 01 05  |.T...'...H...T..|
00000020  80 2b 01 00 00 15 02 01  00 3e 01 02 02 20 01 01  |.+.......>... ..|
00000030  00 48 01 02 00 47 00 01  00 00 c0 00 02 14 03 00  |.H...G..........|
00000040  01 00 01 00 03 31 00 00  00 30 00 00 80 48 00 02  |.....1...0...H..|
00000050  00 00 00                                          |...|
00000053

Notice that even the fact variable name was optimized out by luajit's compiler. Your original lua code never has to be released to the public since the JavaScript engines can't make any sense out of lua code anyway.

Brozula converts this bytecode to JavaScript something like:

(function(){function r(r){return null===r?["nil"]:"object"==typeof r?["table"]:[typeof r]}
function t(r){return Array.isArray(r)?r:void 0===r?[]:[r]}function e(r,t){
return Object.defineProperty(r,"__metatable",{value:t}),[r]}function n(){
console.log(Array.prototype.join.call(arguments,"  "))}function o(r,t){
return r?arguments:(a(t),void 0)}function a(r){throw r}function u(r){for(var e,n,o,a="0";;)
switch(a){case"0":if(0!==r){a="5";break}return n=1,[n];case"5":return n=this.__proto__.closure[0],
o=r-1,e=t(n(o)),n=e[0],e=void 0,n=r*n,[n];case"a":return[]}}function c(){for(var r,t="0";;)
switch(t){case"0":r=u.bind(Object.create(this)),this.closure=[r],t="2";break;case"2":return[r]}}
var i={type:r,setmetatable:e,print:n,assert:o,error:a};return c.apply(i,arguments)})();

Brozula is licensed under the MIT license.