mlua VS rune

The release notes can be found here.

I'm not a specialist about text based multiplayer game, but from what I saw on Wikipedia it seem doable to do it with Rust and Bevy. On top of that you can add a layer of LUA with https://github.com/khvzak/mlua (or write your own bindings and sandbox later).

mlua can run on emscripten target with Luau backend -> https://github.com/khvzak/mlua/issues/23

You can also look at the "dependents" section on crates.io https://crates.io/crates/mlua/reverse_dependencies and github https://github.com/khvzak/mlua/network/dependents

I know mlua does support Async. I also prefer it over rlua

Note rlua doesn't allow you to create native modules with it and has largely been superseded by https://github.com/khvzak/mlua since it's more maintained, has native module support and stuff like Luau and async/await.

I'm glad to announce first mlua version 0.8.0-beta.1 with Roblox Luau support.

I believe mlua [0] is the recommended Lua Rust binding now.

[0] https://github.com/khvzak/mlua

This is achieved through a backend/client architecture -- all core functionality (getting query results, opening selected item, search engine fallback, etc.) is implemented in a "backend" module, which is a Rust library exposed as a Lua module via mlua. The results returned by the backend then get fed into your fuzzy-finder of choice through thin clients, or "providers".

A Lisp, a weird dialect of Lisp, is not better than Lua. Why use Rune [0]?!

[0]: https://rune-rs.github.io/

This is what I based my comment on - https://github.com/rune-rs/rune/issues/444

Late start today as well. I really thought today would be the day that I'd have to abandon my goal of no heap allocations. But, luckily I had an arena allocator available that I could fairly easily adapt to store data on the stack. And with some tweaks we have today's solution:

I'd have given you bonus points for using a rust styled scripting language like rune but that's pretty neat still

As note about using rust syntax for scripting: https://rune-rs.github.io/

I know you said you don’t want to embed another language but IMO Rune is worth a consideration here. It can be a pretty thin abstraction over rust by passing native structs to scripts and calling methods on them. The syntax and semantics are very close to rust so it feels natural. https://github.com/rune-rs/rune

The biggest technical difference I'd say is that Rune uses a stack-based machine which makes adding deep C support somewhat obvious while Rhai performs AST walking to execute scripts.