iced VS yew

Have you seen iced-rs? It's inspired by Elm and compiles to the web as well.

Another thing to note is that Iced.rs is very much in early and active development. While it’s absolutely possible to build basic apps with it, the ecosystem isn’t particularly mature yet. Besides the docs and examples, at this early stage, it’s a bit rocky to get started, especially if you’re trying to build something complex.

I originally had this idea to learn rust a little better by making a cross-platform pokedex with [iced](https://github.com/iced-rs/iced). I'm not sure if I will end up making that, but now I'm focused on making a wrapper for the API that can use different HTTP clients like [ureq](https://lib.rs/crates/ureq) for sync, and [reqwest](https://lib.rs/crates/reqwest) for async.

Iced https://github.com/iced-rs/iced

Or do you prefer Rust-only toolkits ? Those are not so advanced yet, but egui and iced look promising. Also have a look at "are we gui yet"

Hmm I'm not seeing similar memory usage on my Mac. I believe this could be related to iced.

Not too difficult, essentially you will need to implement two traits from iced, one to handle the rendering of the component and one to handle events i.e mouse events/keyboard events. You can use an existing component as a template and modify it to your needs.

2- I used iced and it's nice and generally easy but the GUI ecology in rust is still in development.

What's written in this article isn't the development of a GTK fork, but some reasoning for exploring alternatives to GTK. There aren't very many suitable candidates in this space, but Rust GUI toolkits like Iced have potential. Personally, I would add that OrbTk is also a suitable candidate.

Hi all! Here is the latest Rust side project I’ve been working on for the past couple of weeks: Lifeee, an implementation of John Conway’s Game of Life.

It was the opportunity for me to continue my Rust learning journey, and I think I’m finally starting to feel a bit comfortable with the language, especially ownership :). I also wanted to discover what was possible when using Rust for frontend development, and I must say I was so impressed by Yew! I didn’t think it would be so nice to use, especially since I have quite some experience with React.

A big difference compared to the various implementations you can find (often in Rust and Yew tutorials) is that the grid is infinite. This means that you can drag it to move in all directions, but also zoom in and out. This was probably the most challenging part of my project and involved a lot of calculus and doodles in my notebook! Also, since I used a canvas to draw the grid (and not DOM elements), the simulation is pretty fast even when a lot of cells are displayed :D

What I learned during this project:

- Use Yew [1] for frontend development: not very different from writing React components, with the advantages of Rust as a plus!

- Serialize/deserialize data: the available Game of Life patterns are extracted from the official Lexicon [2]; I parsed the text version to generate a serialized version (separate library: [3]) that I then import and deserialize in the app.

- Build the web app using GitHub actions and deploy it using Netlify: pretty straightforward using Trunk [4] as a bundler (also used for development).

You can find the source code of the app on GitHub [5]. Please tell me what you think of it! ;)

[1] https://yew.rs/

It was the opportunity for me to continue my Rust learning journey, and I think I’m finally starting to feel a bit comfortable with the language, especially ownership 😅. I also wanted to discover what was possible when using Rust for frontend development, and I must say I was so impressed by Yew! I didn’t think it would be so nice to use, especially since I have quite some experience with React.

I've seen some pretty interesting things like the use of Rust for front end development, like yew[1] and Seed[2].

There aren't many languages that are practical for WASM output. Scripting and managed languages need to ship their interpreters and runtimes with their WASM blobs, and can end up relatively large. JavaScript's interpreter and runtime are baked into every browser already.

That leaves only compiled and unmanaged languages for potentially good WASM targets. As mentioned before, Rust is seeing a lot development in that space. If LLVM can compile it, then Emscripten can output it to WASM.

[1] https://github.com/yewstack/yew

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

The biggest difference between Iced.rs and Yew is that while Yew is purely for building web apps, Iced’s focus is actually on cross-platform applications; the web is only one of several platforms you can build an application for.

Yew and Gloo

Game of Life: https://github.com/yewstack/yew/tree/master/examples/game_of_life (I was surprised how fast this was)

Yew https://yew.rs/

I initially meant to use Rails as a way to learn it, but missed Rust too much and switched to Yew for the frontend and Diesel and Tide for the backend. I'm trying to force myself to care more about finishing the project (and quickly getting it into production!) than making everything perfect, which is difficult for me.

We’re using Yew to build the Wasm-based frontend. We add some more utility libraries for routing and error and JSON handling, as well as an internal dependency to our common library, which will hold the code shared between the frontend and backend.