wgpu-text VS rui

wgpu-text is similar to wgpu_glyph but simpler. It provides basic text rendering and is still being worked on for new features.

Inspired by Xilem, Leptos and rui, Floem aims to be a high performance declarative UI library with minimal effort from the user.

My rui library can render UIs at 120fps, uses similar SDF techniques (though uses a single shader for all rendering): https://github.com/audulus/rui

Is their GPUI library open source?

I think the jury is still out on whether rust is good or bad for UI. Once rust UI libraries are more mature we'll get a sense of it. There are some advantages of static typing, even for UI (see SwiftUI for example). I'll grant the pickiness of rust can be a challenge. Anyway give us some time to work on stuff.

Here's my effort: https://github.com/audulus/rui

rui

Depending on the scale of your project, I could suggest rui library which is cross platform though it's not related to gtk, https://github.com/audulus/rui, It's inspired by swiftUI

I've done a library for vector graphics on the GPU which works pretty well for my uses:

https://github.com/audulus/vger

and a rust version:

https://github.com/audulus/vger-rs

(which powers my rust GUI library: https://github.com/audulus/rui)

Here's the approach for rendering path fills. From the readme:

> The bezier path fill case is somewhat original. To avoid having to solve quadratic equations (which has numerical issues), the fragment function uses a sort-of reverse Loop-Blinn. To determine if a point is inside or outside, vger tests against the lines formed between the endpoints of each bezier curve, flipping inside/outside for each intersection with a +x ray from the point. Then vger tests the point against the area between the bezier segment and the line, flipping inside/outside again if inside. This avoids the pre-computation of Loop-Blinn, and the AA issues of Kokojima.

It works pretty well, and doesn't require as much preprocessing as the code in the article. Also doesn't require any GPU compute (though I do use GPU compute for some things). I think ultimately the approach in the article (essentially Piet-metal, aka tessellating and binning into tiles) will deliver better performance, and support more primitives, but at greater implementation complexity. I've tried the Piet-metal approach myself and it's tricky! I like the simpler Shadertoy/SDF inspired approach :)

You should look into rui, https://github.com/audulus/rui It is an amazing ui Library for rust

Try rui https://github.com/audulus/rui, It's a Swift Type ui