steel

Actually steel¹ is quite capable, R5RS compliant, aiming for R7Rs and it's embedable like Lua. Probably easier to use in a rust project. https://github.com/mattwparas/steel

I searched a bit to find the extension language. Basically an embeddable Scheme similar to Racket in Rust. https://github.com/mattwparas/steel

It’s not even an obscure Lisp flavor. It’s Scheme. You’re getting thrown off by the fact that they need their own embeddable interpreter for it written in Rust. https://github.com/mattwparas/steel

>I doubt that would be compatible with a WASM build target. In principle, I don't see why not. In practice, yeah I can see it. In both cases, can't know without checking, and I haven't. Bevy is pretty cool though! My drive-by suggestions would be more along the lines of https://github.com/mattwparas/steel, or the very ad-hoc embedded language of https://github.com/elkowar/eww, or perhaps most pertinently https://kdl.dev/ Maybe one of those would be minimal enough for the rest of the engine to not manage to get your way, as frameworks are known to do. As always, happy hacking!

How close are you to getting a "full" implementation of R6RS? I've been thinking of picking either your project or Steel[0] for a Rust Scheme thing [0] https://github.com/mattwparas/steel

I don't know if this is still the case but they were leaning towards Steel. Relevant Github comment: https://github.com/helix-editor/helix/issues/10389 Steel: https://github.com/mattwparas/steel

Also a shout out to Steel (https://github.com/mattwparas/steel), another Scheme-on-Rust which is more active. The Rust community has given us at least two Scheme runtimes, several JS runtimes, but no Clojure interpreter yet that I'm aware of. There are a few zombie projects squatting on the name (seems common in Rust) but no viable releases.

For one, I don't like the Lua language. This is just my opinion but I dislike the syntax and semantics. It's better than vimscript for configuring neovim but that's a pretty low bar. And if the argument is "pick a long-supported standard as an embedded language" then I'd rather go with Lisp (e.g. https://github.com/mattwparas/steel). Historically, Lua is the fun hobby project newcomer.

Other embedded scripting language is Steel [1]. It’s being considered to be used in Helix [2]. [1] https://github.com/mattwparas/steel [2] https://github.com/helix-editor/helix/pull/8675

I haven't tried Rhai and I wouldn't call myself anything more than a casual Lua user, but from a glance, these could be some reasons I see others using Rhai instead of Lua: - Closer to Rust syntax/data structures, so easier if you already know Rust but don't know Lua - Built-in serde (popular Rust de/serializer) support, if you need that - Not sure if existing Rust<>Lua crates have it, but the debugging interface looks like the beginning of something useful (https://rhai.rs/book/engine/debugging/) - Made in Rust, so again, if you already use Rust (which you do, if this crate is an option) it'll most likely to be easier to change for your needs, than modifying a Lua runtime Personally, I'd probably still go for Lua rather than something like Rhai, if I had to choose something for algol-like scripting support. Otherwise I think Steel (https

How does this compare to steel? https://github.com/mattwparas/steel

Steel seems alright: https://github.com/mattwparas/steel There are other Lisps too (https://github.com/alilleybrinker/langs-in-rust) though I think they’re less actively maintained.

I absolutely don't mind the plugin system being a Scheme. It's a plugin for a text editor, and Steel(https://github.com/mattwparas/steel) seems to be a lot less of a maintenance burden than WASM plugins(besides that I find the WASM tooling to be extremely complex). But besides all that, Helix learned be that I don't need fancy plugins or endless finicking with config files and toolchains. Using a combination of other tools, like yazi and lazygit, helps me not only inside my editor but outside of it as well. And Kakoune does this even better. In that regard it has been a real eye-opener and refreshing. The downside is, it's hard to go back to other editors!

It doesn't yet have a plugin system but they're thinking of adding one for the Steel programming language (a lisp). https://github.com/mattwparas/steel

Basically the differences are in the concepts you'll use to write code. Lisps themselves are very different from each other, but just like the languages you're used to, many lisp distributions have standard libraries that can be called, and those building blocks can be used to build applications or whatever else. In this case specifically, Steel provides the facility to call Rust functions within a Steel program: https://github.com/mattwparas/steel. So, although I haven't used Steel, it looks like the advantage you'd get from using it is the opportunity to take advantage of features it provides like transducers and contracts, which are feature common to some other Lisps as well. So, just like choosing any other language, it boils down to a series of tradeoffs.