blitz VS cosmic-text

Have you talked to the Dioxus people recently?

They're working on a project called Dioxus Blitz; from what I'm told, they're trying to implement a minimal browser target, that provides some basic DOM-like features and renders with wgpu.

It's not exactly what you're hoping for, but you might find common ground.

https://github.com/DioxusLabs/blitz

(Also, the Linebender project is working on Masonry, with FFI as a medium-term goal.)

Your proposal sounds very similar to what the Dioxus folks are doing on Blitz, which is using HTML/CSS as the languages but doing native rendering. WebF seems much further along, and I know they've been exploring other rendering engines, so it may be an interesting conversation for you to have with them.

Others have already mentioned inlyne and blitz, however given that you're interested in combining web UI with game/wgpu rendering you may be more interested in bevy_ui (and the higher level APIs like bevy_ui_dsl and belly that sit on top of this). Bevy UI is working on a HTML model and is specifically designed to integrate with Bevy's main game renderer and other infrastructure. It's worth noting that a 0.11 release of Bevy of due in next few days, and that UI is going to be a strong focus of the 0.12 release cycle: which should lead to significant development of bevy_ui, and either a doubling down on the "HTML-like UI" approach or a pivot to a new approach.

Here is an example: https://github.com/DioxusLabs/blitz/blob/master/examples/buttons.rs

> But no one is saying, "Hey I have a CSS 2.1 compliant rasterizer and compositor that you can use in your C++ or Rust environment!" are they?

There’s actually quite a lot of interesting work going on in that general space, has been in various forms for some years. A couple that immediately spring to mind:

• Azul <https://azul.rs/> builds on WebRender, as used in Firefox. I haven’t looked at it for a few years, but it looks to have grown quite interesting now.

• Blitz <https://github.com/DioxusLabs/blitz> is based on from-scratch implementations of CSS layout and rendering, and wgpu rendering. It’s not usable yet, but is a very interesting concept. If one happens to be familiar with React Native: it’s kinda like that, or React Native Web.

You may also be interested in https://github.com/DioxusLabs/blitz which aims to be a full HTML+CSS renderer on top of wgpu (but is currently not nearly as complete as inlyne).

If you are focused on performance we are working on a native renderer for Dioxus called Blitz. It is very incomplete right now, but in the future it will be much more performant than the current webview based approach.

There hasn't been too much progress on Blitz in the last few weeks (it will come), but there is now a new project Freya which is using a Dioxus frontend and rendering with Skia. That's currently using it's own layout system instead of Taffy though.

The main desktop renderer for Dioxus uses wry (the webview tauri uses internally), so the startup time will likely be similar. We are working on a native renderer called blitz which should improve this, but development is still early

> Is there any easy to use/hack HTML layouting engine where I could experiment with custom CSS attributes and bridge that gap? Would anything from Servo be suitable?

Servo could be used for this. You'd want to add support for parsing the CSS properties themselves to the style crate in https://github.com/servo/stylo and then the layout implementation to the layout2020 crate in https://github.com/servo/servo. You do effectively get a whole browser though.

I'm currently working on building a lighter weight / hackable layout engine based on a combination of https://github.com/servo/stylo (for css parsing and selector resolution), https://github.com/DioxusLabs/taffy (for box-level layout) and https://github.com/pop-os/cosmic-text (for flow/inline layout). I expect to have something decent in around 6 months

Neither of these setups currently have any support for pagination though.

I maintain a web layout library that is designed to be integrated into other software:

https://github.com/DioxusLabs/taffy

It needs to be combined with a text layout engine (such as https://github.com/pop-os/cosmic-text), and it doesn't support everything yet (notable features that are currently missing: "float", "display: inline-block", "box-sizing: content-box", "position: static"). But we have Block, Flexbox and CSS Grid support with more on the way.

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).

You might be interested in the combination of Taffy [0] which handles box-level browser layout (block, flexbox, grid, etc) and Cosmic Text [1] which handles text-level layout and basic text editing functionality.

Integrating them into browsers while retaining accessibility could be tricky. But in they're general they're relatively small standalone libraries implementing most of the layout algorithms that browsers implement (although there are currently a few key missing features like laying out "inline-block" items in line with text).

[0]: https://github.com/DioxusLabs/taffy

[1]: https://github.com/pop-os/cosmic-text

By integrating the Cosmic Text library from https://github.com/pop-os/cosmic-text, Bevy Cosmic Edit enhances Bevy's UI system with the following features:

https://github.com/pop-os/cosmic-text that does text layout and rasterisation with full support for things like CJK scripts and emojis)

Libraries for a lot of this stuff exist (albeit in many cases not very mature yet):

- https://github.com/pop-os/cosmic-text does text layout (which Taffy explicitly considers out of scope)

- https://github.com/AccessKit/accesskit does accessibility

- https://github.com/servo/rust-cssparser does value-agnostic CSS parsing (it will parse the general syntax but leaves value parsing up to the user, meaning you can easily add support for whatever properties you what). Libraries like https://github.com/parcel-bundler/lightningcss implement parsing for the standard css properties.

- There are crates like https://github.com/BurntSushi/bstr and https://docs.rs/wtf8/latest/wtf8/ for working with non-unicode text

We are planning to add a C API to Taffy, but tbh I feel like C is not very good for this kind of modularised approach. You really want to be able to expose complex APIs with enforced type safety and this isn't possible with C.

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)