7 ms·
Lua VM running in a WASM environment
- sillysaurus3 10y agoI'm running into an integer overflow error. Try this as input: https://gist.github.com/anonymous/f00581ecf4dba42501c9c569914a909a https://gist.github.com/anonymous/f00581ecf4dba42501c9c56991... Is there a way to debug it? It should print the following string: "print(1 + 2)" This is very cool.
- hisham_hm 10y agoA Lisp running on top of Lua on top of WASM? :)
- sillysaurus3 10y agoYup! I couldn't resist. https://github.com/sctb/lumen https://github.com/sctb/lumen I think there's some bug in indexing into Lua tables. print(str({1, 2})) should print "(1 2)", for example, but it triggers an integer overflow error. It's actually capable of compiling to both Lua and JS, so I was going to show off a Lisp running on top of Lua on top of WASM which generates JavaScript, completing the circle of life.
- sillysaurus3 10y agoDidn't work for me. Here's my Chrome OS X console output: http://i.imgur.com/RnA5mUb.png http://i.imgur.com/RnA5mUb.png Let me know if you need more info. EDIT: Ah, it's firefox-only. Is there some way I can help get it running on Chrome?
- joatmon-snoo 10y agoOn Chrome you need to turn wasm on apparently. The emscripten GH (https://github.com/kripken/emscripten/wiki/WebAssembly https://github.com/kripken/emscripten/wiki/WebAssembly) says you should also use Canary, but I see chrome://flags/#enable-webassembly in my Chrome flags, so I turned that on. Still doesn't work though; I'm getting this now: Uncaught TypeError: WebAssembly.instantiate is not a function at doNativeWasm (main.js:1) at Object.Module.asm (main.js:1) at main.js:1
- JasonSage 10y agoThat's implementing an older version of the WASM spec, hence why you need Canary.
- mappu 10y agoWorked without any configuration changes for me (Chromium 59 on Stretch).
- deleted 10y ago[deleted]
- alain_gilbert 10y agoWorked without any configuration changes. Chrome Version 57.0.2987.110 (64-bit)
- Svenskunganka 10y agoGo to chrome://help/ and it should update to latest version (Version 57.0.2987.110 (64-bit)), after that it works like a charm. This usually happens when you haven't restarted Chrome for a while.
- rzzzt 10y agoSupport for WebAssembly is enabled from version 57: https://www.chromestatus.com/feature/5453022515691520 https://www.chromestatus.com/feature/5453022515691520
- 6nf 10y agoMake sure you're on Chrome 57
- jshmrsn 10y agoThis could be be very useful for me. Long term, I would love to see a Lua to WASM compiler/transpiler with additional Lua runtime functionality efficiently implemented in WASM as well. Since WASM already has its own stack-based VM, why not skipthe additional Lua VM bytecode execution layer? I would love to work on this myself, but right now the time investment isn't practical for me.
- __s 10y agoI've got a Befunge JIT compiling directly to WASM: https://github.com/serprex/Befunge/tree/master/js https://github.com/serprex/Befunge/tree/master/js (hosted: http://etg.dek.im/funge/funge.html http://etg.dek.im/funge/funge.html ) Maybe I should move on to something a little more practical Note that there seems a lot of misinterpretation of WASM as a good VM bytecode target. You're stuck with i32/i64/f32/f64. Strings have to be manually managed through byte indexing. There's no GC. Targeting WASM directly is really close to targeting an actual ISA directly. So efficient implementation to WASM is going to come off closer to something like LuaJIT. It also doesn't facillitate self modifying code so lazily compiling will imply either using a trampoline to jump between multiple WASM modules or recompiling everything There's no jump instruction in WASM, so arbitrary goto has to be converted into loop-and-switch. The Befunge VM I linked breaks that down to only relooping between basic blocks. Browsers optimize that pattern. There's room to play around & see if they can optimize something like a CPS VM. Instead of dispatching based on the value of a memory cell, encode an instruction as a 'store-next-instruction to local, break to instruction implementation (if not short bytecode), have that instruction end by looping back, where we switch to next instruction which repeats the store-next-instruction to local'. Where next-instruction encodes this dance repeatedly. Hot areas of the VM may then be inlined by the browser's JIT To summarize the above paragraph: instead of compiling to bytecode, compile to threaded gotos
- 6nf 10y agoLua compiles to C which compiles to WASM, and the Lua forums already has some people demonstrating Lua code compiled to WASM like this. So you can do this already to some extent.
- magicbuzz 10y agoWorks on Chrome 58 out of the box. Very cool!
- CapacitorSet 10y agoLua in the browser? Truly, we live in the future.
- adamnemecek 10y agoif you can do lua, you can prolly do any language.
- kachnuv_ocasek 10y agoCan't wait for GHC.
- adamnemecek 10y agoyou can already kinda get that with purescript
- deathtrader666 10y agoCan't wait for BEAM -- the Erlang VM in the browser!
- sitkack 10y agohttp://www.erlang-factory.com/upload/presentations/643/browserlatEUC2012.pdf http://www.erlang-factory.com/upload/presentations/643/brows... https://github.com/svahne/browserl https://github.com/svahne/browserl https://github.com/baryluk/erljs https://github.com/baryluk/erljs
- magicbuzz 10y agoNever say never but Lua is pretty unique because of the vm size and language design.
- fiddlerwoaroof 10y agoIt seems to me that Clojure is similar insofar as it was designed to be a hosted language. Although, it sounds like wasm might be too low level for now.
- skybrian 10y agoThe WASM file seems to be 88K compressed, 241K uncompressed. Not bad!
- daurnimator 10y agoOther interesting projects: - https://github.com/giann/fengari https://github.com/giann/fengari - new project, most exciting IMO - https://github.com/daurnimator/lua.vm.js https://github.com/daurnimator/lua.vm.js - emscripten based, has best interactions with DOM (but is a dead end) - http://www.moonshinejs.org/ http://www.moonshinejs.org/ - no longer maintained, interesting model though - https://github.com/paulcuth/starlight https://github.com/paulcuth/starlight - transpiler: you loose ability to use proper coroutines which are IMO most interesting feature for lua in browser - https://github.com/creationix/brozula/ https://github.com/creationix/brozula/ - unmaintained - https://github.com/logiceditor-com/lua5.1.js https://github.com/logiceditor-com/lua5.1.js - https://github.com/mherkender/lua.js https://github.com/mherkender/lua.js
- merlish 10y agoTo add some anecdotes to the above (plural of anecdote is of course data): - fengari: Dunno, nice logo & name though :) Not done yet? - lua.vm.js: Pretty good, but as you say in your README: "Next step is to iterate on the Lua <=> JS interoperability. Clever solutions to the lack of finalisers in Javascript are being searched for." (-> leak mem if passing stuff to JS in certain situations) - Moonshinejs: paulcuth/gamesys' previous effort. It's a Lua VM written in JS, that accepts just Lua 5.1 bytecode. Works in IE6+. Very small. Nice 'DOMAPI' plugin; nice in the sense it mostly just works, and when it doesn't, the plugin is so small & simple you can hack it yourself. One thing to note is when getting strings back from the DOM using DOMAPI, I've run into situations where the strings when accessed Lua-side are in fact 0-indexed not 1-indexed. (the_string .. "") is a working normalization technique. Coroutines work very well here. Also, do not overlook the in-browser debugger addon. It's a seriously nice piece of work, that more than makes up for the lack of source map support. It deals with the lack of finaliers in Javascript by providing explicit .retain() and .release() mechanisms. - Paulcuth/Starlight: As you say, transpiler, no coroutine support though. How to get coroutines: ... I was looking into this, and you need something like using kripken's Relooper algorithm or a more general version of Facebook's Regenerator. Scary stuff. Note about both moonshinejs & starlight, with respect to the string library: It implements Lua patterns by turning them into JS RegExp. The implementation isn't good enough as it stands; it's easy to get the wrong results, as the escaping logic is wrong. Damned if I know where though. I tried to fix it and just broke a different class of patterns... - Brozula: Dunno - Lua5.1.js: Dunno. Would be nice to have a better API for interaction than the Lua C API. No commits since 2013, like Brozula. - Lua.js (lua2js): Dunno. Several open issues about e.g. '<' operator not working. No commits since 2013. And: _lua_coroutine["resume"] = _lua_coroutine["running"] = _lua_coroutine["status"] = _lua_coroutine["wrap"] = _lua_coroutine["yield"] = _lua_coroutine["create"] = function () { not_supported(); };
- simcop2387 10y agoSweet, I've thought about doing this with emscripten in the past for a an LED panel i've been building/working on. It runs LUA on a microcontroller to drive the display and I wanted a way to simulate the whole thing on the fly.
- sillysaurus3 10y agoSo, here's a fun example: a self-hosted Lisp. Copy this: https://gist.github.com/anonymous/af755d7cf0f71a574f39f547d3357a39 https://gist.github.com/anonymous/af755d7cf0f71a574f39f547d3... And paste it into the VM: https://cdn.rawgit.com/vvanders/wasm_lua/d68f46a8/main.html https://cdn.rawgit.com/vvanders/wasm_lua/d68f46a8/main.html It's a modified version of Lumen (https://github.com/sctb/lumen https://github.com/sctb/lumen) made to run on this VM. It defines a runtime, a reader, a compiler, then compiles the runtime from Lisp to Lua and prints out its own source code. Lumen is also capable of compiling to JS, and I wanted to show it printing out its own source code as JavaScript instead of Lua. But unfortunately I was getting some strange WASM-related memory errors when compiling as JS, so I decided to settle for a neat demo that everybody can run. (The demo could be a little less cryptic, and I could do a better job of explaining it, but it's late.)
- vvanders 10y agoThat's really cool(and kinda meta!). I love how multi-paradigm Lua is, we used to do component based composition with metatables but I've seen OO inheritance and a slew of other approaches as well.
- magicbuzz 10y agoIf I can get cqueues running, then I can run lapis on that and get a webserver happening.. in my browser!
- green7ea 10y agoI really look forward to being able to compile WASM to native machine code. With a default link to an SDL canvas library, it would become something like a universal runtime for most media applications. You run that in a sandbox and you pretty much have a native version of the modern browser minus the DOM.
- dleslie 10y agoWASM apps will still have access to the browser; you'll need more than SDL to replace that. More likely, native apps will port to WASM.
- swah 10y agoAnyone else getting " Assertion failed: Cannot call unknown function run_lua (perhaps LLVM optimizations or closure removed it?)" ?
- vvanders 10y agoThis was just a little demo that I threw together. I didn't expect so much interest but I'm glad people like it. Lua is a unique language and it's ease of embedding made it a perfect fit for WASM.
- int_19h 10y agoAt last. (Lua is everything JS should have been.)
- lifthrasiir 10y agoProbably true 5 years ago. I believe now it isn't, mainly because JS is moving much faster (not always good, but many goodies in JS simply do not exist in Lua).
- goatlover 10y agoJS's core language remains the same. If you're of the opinion that Lua was designed better from the start, then adding features to JS doesn't change that, as nice as some of those features might be.
- lifthrasiir 10y agoOne, keep in mind that Lua has the version 5.x. It is an accumulation of early user experience just like JS. I haven't said Lua was designed better from the start. I have merely stated that Lua in 2012 is probably better than JavaScript in 2012 (and I was careful enough to add a word "probably" :-). Two, core languages don't matter here because they are fundamentally similar to each other at the core level (dynamic and considerably weak typing, unified object-array, first-class value from missing indexing, semi-working lexical scopes and much more). The pain points of Lua tended to be same to those of JavaScript in my professional experience. Three, the language is not a mere combination of syntax and semantics. Any evaluation should also account for user bases and ecosystem, and in my very humble opinion Lua spectacularly fails at both. I'm not going to assume the alternative reality---Lua has a sizable user base and its ecosystem is worse even for that user base.
- vvanders 10y ago> ... user bases and ecosystem, and in my very humble opinion Lua spectacularly fails at both. I think that call depends on your use case. If you've ever tried embedding v8 or spidermonkey you might have a different opinion. For instance we use to run the entire game state for multiple game titles I worked on in Lua. This was on the PSP where we only had a 400kb block of execution space and a 333MHz MIPS processor(system memory was 8mb w/ 24mb for video + audio). Those types of environments are where Lua shines which lets you use a scripting language that scales from nothing up to full-blown systems.
- solidr53 10y agoIts faster for sure... I benchmarked a dummy pi calculation code and got this results: > JS: 0.11499999999068677ms > Lua: 0.0019999999999527ms BUT, they don't print the same results.