vizia VS flutter_embedder

All of these projects have in common that they use Taffy (the project that I work on!) for box-level layout (which currently gives them block, flexbox, and grid layout) , and are either using or planning to use cosmic-text for text/inline layout. This gives you a decent first approximation of web layout, but it's not perfect and there are major features like float, display: inline-block, position: static, box-sizing: content-box missing. Not to mention that none of these implementations currently resolve CSS selectors, so you are effectively limited to inline styles (if you're interested in something in that direction then you may be interested in https://github.com/vizia/vizia).

Vizia is basically fine-grained reactivity with an Elmish twist, though I haven't used it, so I couldn't say how well it works.

There are a number of up-and-coming Rust-based frameworks in this niche:

- https://github.com/iced-rs/iced (probably the most usable today)

- https://github.com/vizia/vizia

- https://github.com/marc2332/freya

- https://github.com/linebender/xilem (currently very incomplete but exciting because it's from a team with a strong track record)

What is also exciting to me is that the Rust GUI ecosystem is in many cases building itself up with modular libraries. So while we have umpteen competing frameworks they are to a large degree all building and collaborating on the same foundations. For example, we have:

- https://github.com/rust-windowing/winit (cross-platform window creation)

- https://github.com/gfx-rs/wgpu (abstraction on top of vulkan/metal/dx12)

- https://github.com/linebender/vello (a canvas like imperative drawing API on top of wgpu)

- https://github.com/DioxusLabs/taffy (UI layout algorithms)

- https://github.com/pop-os/cosmic-text (text rendering and editing)

- https://github.com/AccessKit/accesskit (cross-platform accessibility APIs)

In many cases there a see https://blessed.rs/crates#section-graphics-subsection-gui for a more complete list of frameworks and foundational libraries)

I don't think it's actually merged into Iced yet. It is merged into https://github.com/vizia/vizia though.

Vizia

I have recently learned about https://github.com/vizia/vizia and it looks very promising to me

I'm actually working on this as a side project (here).

I personally settled on Flutter. It's a modern declarative UI framework by Google that was designed for mobile apps, but it can also do desktop and web these days. It can be used as a library using its embedder API that can render to Vulkan, Metal and OpenGL. So, it can be embedded in a wgpu context (here's my prototype for that based on wgpu/Vulkan and winit). Flutter uses Dart for UI programming, which is fine for me, since a lot of iteration is necessary for that, and Flutter allows Dart code to be hot reloaded during development (so you just have to save your file and the running application is updated automatically, keeping all of its state intact). Rust wouldn't be able to do that at the moment. Web support is trivial, because Flutter Web allows integrating HTML elements between its UI layers. I can simply insert a canvas there and link that to wgpu.

Here's the repository.

I've started writing my own Flutter shell here that runs on all desktop and mobile systems Flutter supports without any platform-specific code paths. The trick is that I'm delegating the responsibility for platform-specific code to a generic library (winit in this case) and so keep it out of my codebase.

I've started a project for using Rust for a shell using the Flutter Engine's embedder interface, so it’s trivial to integrate Rust into the system. It’s available here.

What I'm currently looking into is using Flutter for UI drawing instead of web tech. It has a built-in compositing API that allows interleaving native drawing with its surfaces and has a Vulkan renderer. The only downside is that you have to write a shell for it that maps the native platform to its APIs, which is very underdocumented and needs a lot of code, for example for handling keyboard input. Here's my progress so far. It comes with shells for all of its supported platforms, but they all use OpenGL or Metal (for iOS/macOS).

I need to check out how well this combines with my Rust-based Flutter shell.

I personally spent a significant part of my spare time in the last few months researching this topic, and came to the conclusion that for my (very similar) project, I'd like to use Flutter and Dart for the UI and Rust with wgpu (maybe bevy) for the rendering backend. I'm working on an integration for native platforms (so everything except web) right now, it's available in earliest alpha here. Web itself is trivial, because you can simply mount a separate canvas as a platformview and use that for wgpu, completely separating the two worlds.

Unfortunately, I'm really busy these days so I don't have any time for any more projects. I'm currently working on this project, which allows using the UI framework Flutter together with wgpu, so I'd say that it's adjacent to your project.