Lunatic: Actor based WebAssembly runtime for the backend

This has an updated website now: https://lunatic.solutions/

Similar to Lumen, but instead of Erlang compiling to WebAssembly, this is just inspired by Erlang, and written in Rust.

Hi! I’m the author of Lunatic and a huge Elixir fan .

I started working on Lunatic when I moved to Rust and missed the features from the BEAM world. Especially being able to just spawn a lightweight process that is self isolated. It’s impossible to do this in Rust using just libraries because all the code shares the same memory space.

I came up with the idea to use WebAssembly instances as process replacements. Contrary to Lumen, LAM and other implementations, Lunatic doesn’t run inside one WebAssembly instance, but runs thousands of instances as lightweight processes.

This gives Lunatic also a bit more powerful per process isolation than you get on the BEAM. E.g:

1. You can spawn a process that can only use a limited amount of memory or CPU.
2. You can use C bindings without fear. Once everything is compiled to WebAssembly, long running code will still be preempted and crashes don’t escape the process boundary.
3. You can limit syscalls on a per process level, e.g. spawn this process but don’t let any code running in it open a network connection.
4. Redirect syscallls, e.g. if this process writes to a log file redirect the stream over the network to an Elastic cluster.
5. You can use it from you favourite language if it compiles to WebAssembly. Currently we only provide libraries for Rust and AssemblyScript.

The project is still in its early stage and not all features are implemented yet, but we got initial funding from YC and are working full time on it.

Would it be feasible to use this runtime for, say, writing client side applications? So long as the target can run the executable? For example, writing the core of an app in rust, compiling to wasm and distributing it with the executable with platform specific wrappers like electron ?

At the moment we don’t provide any APIs for GUIs (or wrappers) and solely focus on backend applications, but it could be an addition in the future.

The runtime works on Windows, MacOs and Linux (x64 & arm64).

My heart is exploding with happiness to see Lunatic.

I’ve been trying to find a reason compelling enough for me to learn Rust, and this just might be it.

At my company, I’ve written a distributed framework in Python that uses MQTT as a message-passing mechanism between python nodes… we do datascience/AI stuff, but I’ve been looking for something that has the model of BEAM and speed of C, and have several times started architecting what it is you’re doing with Lunatic. My take on it would have been writing a microruntime to execute FreeRTOS code (I have a background in writing microcontroller firmware for some medical stuff). I’d recently been looking at the Cosmopolitan C library to compile to bare-metal code, then executing that inside of microVMs.

Lunatic seems like a better direction to go for easier deployment in different cloud environments.

Thanks for putting Lunatic together, and I look forward to contributing in the near future.

This seems like an interesting notion. They write code in Rust, compile it into WebAssembly, and then call on some infrastructure that emulates the Erlang/OTP environment.

Functional Futures: Lunatic with Bernard Kolobara

-r