zigler VS leptos

Bun is an executable as far as I understand. Would it be possible to call Bun code directly from another language with bindings?

For example Erlang (and Elixir) has Native Implemented Functions[0] (NIF) where you can call native code directly from Erlang. Elixir has the zigler[1] project where you can call Zig code directly from Elixir.

Maybe you can see where I'm going with this, but it would be super cool to have the ability to call Javascript code from within Elixir. Especially when it comes to code that should be called on the server and client. I'm the developer of LiveSvelte[2] where we use Node to do SSR but it's quite slow atm, and would be very cool to use Bun for something like this.

In any case Bun is super impressive, keep it up!

[0] https://www.erlang.org/doc/tutorial/nif.html

[1] https://github.com/E-xyza/zigler

[2] https://github.com/woutdp/live_svelte

There's also Zigler, that makes writing NIFs in Zig a breeze: https://github.com/E-xyza/zigler

I admit for a long time this was my primary motivation to learn Rust, but, sadly, I haven't come across problems in years that were CPU bound/where I needed something like Rust... Rustler still looks like a great fit if needed, but, depending on the use case, if I were CPU bound and needed to write my own code/not just use a Rust library, I'd be as or more likely to look at using Zig and Zigler[0], for much faster learning curve, and from what I've read, easier tighter integration into elixir, including I think language server integration. Some discussion here[1] though I forget if I listened to this one or not.

[0]https://github.com/ityonemo/zigler

Thing is, zigler failed in some way for me to build this with NixOs proj and it was fun to create this from scratch.

With this new functionality, we can expect to see some upcoming development of custom formatters for common types of embedded code. The Zigler project already has an issue open for a custom ~Z formatter, and I hope to see some development for a ~H soon.

That looks great, it's a pet peeve of mine that it's difficult to format languages that are encased in another language. Most (all?) editors are only expecting a single "language" in in a file. You have a js file? Must contain only JavaScript!

Unrelated to 1.13 but thanks to the release notes, I now know about Zigler; which looks really neat.

https://github.com/ityonemo/zigler

Not an antipattern for nimble_parsec: https://github.com/ityonemo/zigler/blob/fe845a9fbbfef92da8ab...

Plus think of how much easier that pipe makes it for you to understand what is going on.

Lots of new frontend frameworks have been built on top of Rust, including Leptos, which happens to be one of the most popular ones. In this guide, we'll highlight why and how to migrate your JavaScript frontend to use the Leptos Rust frontend framework.

I don't know why OP felt moved to write this weird guide, https://leptos.dev is incredible!

https://github.com/leptos-rs/leptos/blob/main/flake.nix

You want a package? Add it to buildInputs.

You want to search a package: https://search.nixos.org/packages (or use the cli)

you want to test a package before adding it? nix-shell -p or nix shell for example.

Heck, even if you want it more easy, you could write a tool in less than 100 lines that adds packages names to .json/.yaml/.toml, which allows you to parse it using the nix language and a simple cli written with bash functions to add/remove packages if you wanted.

That's why it is hard for me to understand this project as a product, it seems like a wrapper to the most basic things :\

We use the fantastic Leptos framework for building the frontend. Besides that, we use the leptos-use utilities for connecting to the WebSocket server, serde for serialization, and rand for generating random numbers.

I'd use https://leptos.dev because you can use a fully typed language (Rust) that is super fast in the backend and also in the frontend (see https://krausest.github.io/js-framework-benchmark/2024/table...)

For the web-side, if you'd like to use Rust end-to-end we've had the best experience with Leptos: https://leptos.dev/

I'd suggest https://leptos.dev/ is worth a look. I haven't used it yet, but plan to soon.

I think a lot of us reach for Jinja-style templates so it feels a little more like we're writing bare HTML. But they're of course still just templates, and they need a build step before they become valid HTML.

So it's true, if you're willing to use a DSL embedded in your server language (like JSX), then you'll have the full language tooling available to you. And this probably isn't giving up much over language-specific templates.

A JSX-equivalent for the Rust server-side rendering world would probably be maud [1] or leptops [2].

[1] https://github.com/lambda-fairy/maud

[2] https://github.com/leptos-rs/leptos

I wanted to deploy the app serverlessly, opting for Deno Deploy hosting. The JS fetch example and the leptos-deno examples were handy to get me going.