lunatic

you can check out https://github.com/lunatic-solutions/lunatic for that

Has anyone experimented with any Rust framework that implements Erlang's actor model in pure Rust? How well do they scale in distributed system? I know I've seen a few libraries such as: Lunatic https://github.com/lunatic-solutions/lunatic Bastion https://github.com/bastion-rs/bastion

Elixir definitely! If you need to use Go, there is also ergo: https://github.com/ergo-services/ergo Yet another cool tool is lunatic: https://github.com/lunatic-solutions/lunatic

They don't, at least not yet. https://github.com/lunatic-solutions/lunatic/issues/150 It is WebAssembly based though, so it should be easier than trying to deal with dynamic libraries and Rust's ABI.

Looks very nice! How does it compare to lunatic https://github.com/lunatic-solutions/lunatic ? (besides wasm vs. native) Also, what's the deployment story?

I'm the author of something related https://github.com/lunatic-solutions/lunatic

Congrats to the Wasmtime team on the 1.0 release! I'm happy to see that more runtimes are maturing and getting use on production cases... I can't wait to see and show what the future entails for WebAssembly on both the server side and the browser! Keep up the good work. Also I'd like to use this message to congratulate other runtimes that I'm excited about (apart from Wasmer, of course!): Wizard Engine [1], Wazero [2] and Lunatic [3]. The future is bright in Wasm land :) [1] https://github.com/titzer/wizard-engine [2] https://github.com/tetratelabs/wazero [3] https://github.com/lunatic-solutions/lunatic

There is no C API, but it would be a great addition. I assume that it would be just a thin wrapper around the host functions and the host functions are fairly good documented (e.g. https://github.com/lunatic-solutions/lunatic/blob/main/crate...), so it shouldn't be too hard to add.

I think a lot of Rust users would argue they don’t even care much about performance. They just enjoy all of the correctness guarantees the compiler can enforce, as well as how ergonomic the language can feel. Being able to deploy a single static binary, and having an easy to use build tool and package manager are significant bonuses as well. Rust makes really hard problems easier when you know the compiler has your back. Rust gives you the tools to write very high performance code, but it doesn’t have to be about that. I’ve had to point out to people quite a few times that garbage collectors can improve performance… especially compared to naive implementations of manual memory management. GCs are not just a tool for lazy programmers. GCs can make allocation incredibly fast, and you get to defer cleanup work to another thread(s), which mea

With lunatic [0] we are trying to bring this to all languages that compile to WebAssembly. A few days ago I wrote about our journey of bringing it to Rust: https://lunatic.solutions/blog/writing-rust-the-elixir-way-1... [0]: https://github.com/lunatic-solutions/lunatic

Webassembly is also gaining steam for server workloads due to several advantages (less overhead, better capability based security, composability, ...). See Spin [1], Wasmcloud [2], Lunatic [3], etc. My system is based on a distributed Webassembly runtime. The reason for taking inspiration from Kubernetes is making deployment of distributed workloads on that runtime easy. A nice benefit for a Kubernetes alike system is that the equivalent to operators and controllers can be much more light-weight WASM actors that are easier to develop, deploy and scale. [1] https://github.com/fermyon/spin [2] https://github.com/wasmCloud/wasmCloud [3] https://github.com/lunatic-solutions/lunatic

I'm the author of a Wasm on the server side runtime[0] that focuses primarily on rust compiled to Wasm, and this question comes up quite often. Why compile to Wasm if you can compile to native code directly? To add to Radu's answer, here are some of my favourite reasons. Having an in-between bytecode layer allows you to build application architectures in rust that would not be possible when compiling directly to machine code. Hot reloading is a good example. Having the VM hold onto resources like tcp streams and file descriptors allows you to exchange the business logic without even breaking a tcp connection. Fine-grained sandboxing is another good example. Revoking filesystem access from just parts of your applications or limiting memory/cpu usage for each individual request[1] is something that is just impossible to do correctly without

A project that's kind of an implementation of this idea: https://github.com/lunatic-solutions/lunatic. I find it interesting at least, but I haven't had the time yet to play around with it.