leptos VS container2wasm

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.

Unfortunately cosmopolitan wouldn't work for dockerc. Cosmopolitan works as long as you only use it but container runtimes require additional features. Also containers contain arbitrary executables so not sure how that would work either...

As for WASM, this is already possible using container2wasm[0] and wasmer[1]'s ability to generate static binaries.

[0]: https://github.com/ktock/container2wasm

[1]: https://wasmer.io/

Really impressed by the depth and breadth of this project, well done!

A particularly interesting part is the socket layer inside the browser. Other people solving this problem have previously used a proxy to a server that does the real socket implementation. This means you can't have a "browser-only" solution.

The author has solved this (for HTTP/S only) by proxying HTTP requests and then re-creating them as fetch requests (details here: https://github.com/ktock/container2wasm/tree/main/examples/n...). I'm very interested in using this approach for my own project Runno (https://runno.dev).