IMO, the top GUI framework crates for Rust are windows or native-windows-gui, objc2 or icrate for MacOS and gtk4-rs for Linux only. Actually for MacOS / iOS I'd use uniffi to embed the rust core in a SwiftUI app.

In 2026 IMO it's much better to use an LLM to keep 3 separate native front ends in sync than it is to try and use any sort of cross platform UI.

https://crates.io/crates/dioxus-native was released 3 months ago and does not have a link to GitHub, I do not think it can be considered as established project yet.

Yeah, have you tried to do anything in egui? I tried today a ComboBox, but I wanted one with filter input box, "X" icon to clear it, and automatic focus.

I've given up when the code reached 300 lines and was still buggy/not working.

egui is not mature. I'd prefer declarative approach, data binding, and styling. Therefore will skip egui.

Stick to Qt, none of those solutions are mature enough for actual production use.

Slint is proprietary. Given that AI makes it so easy to spec out and build even entire GUI frameworks, why would you even go with proprietary anymore? And why doesn't the article showcase a full-fledged set of UI components?

Luckily GPUI isn't vibe coded at all but a mature and well thought-out project.. /s

Brutal and based

I find this line pretty sad actually, what if someone wants to contribute code, written by hand? What if some beginner finds this project interesting and wants to invest own time into it?

Or human is completely removed from the development whatsoever..

I did the same for a vibecoded project [0] but I would never do this for a human-written project. Simply put, if most contributions are similarly vibecoded and/or they will be reviewed/treated as such, then how is a PR/review from an unaffiliated agent any better than one managed by the project curator. Of course that human curation still needs to occur.

This is a natural progression (only on these types of projects). We accepted contributions because it actually helped and they were difficult and time consuming. When that is no longer the case, contributions are a burden, the actual problem/idea is the real value, hence the request to open the issue.

0 - https://github.com/cretz/vitaslop

I had a Nix issue. Agents fixed it in 5 min.

Of course, one could conclude that another agents screwed up before, still was a good experience.

My main concern with this would be that for a library in particular I need a stable API and behavior (Hyrum's law). I do not know to what extent a fully autonomous agentic approach can ensure that. Note: I don't see a problem with preferring issues over pull requests (many of which would be poorly coded slop), just fully automating the handling.

Also a bit wild to assume that no person will just create an issue manually. This is not something I'd normally use an agent for.

It sounds like a black hat penetration tester's nirvana. All you have to do is open the right issue to trick the model into installing the right security vulnerability or backdoor, or better yet, a series of small security vulnerabilities that can be chained to create a tailor-made exploit. It's practically a hacker's choose-your-own adventure.

Makes this (not a real) job posting seem all the more funny/relevant:

https://lovro-bikic.github.io/software-line-specialist/

You can do the same thing with swiftui. The surface you render to doesn't have to be visible at all. And the tree has nice introspection available.

Headless part is neat, but agents can already drive apps and take screenshots. As a side note, I have agent driving android tv using wireless adb and hdmi capture card + mpv rpc, its fun to watch.

Dax on Twitter: "we just couldn't get gpui to look good enough"

The most common rust UI framework I’m aware of, iced, completely fails on these metrics afaik.

Well, for one, it usually is much more energy-efficient: longer battery life, cooler computers, and more responsive under heavy (CPU) load.

Other people have different hardware and different goals. A year or so ago I worked on a Linux laptop that was dog-slow. If I didn't enable GPU-rendering for the UI, it competed for the very limited CPU.

Using less power is generally the main benefit. On lower end hardware you may also notice a performance difference, depending on what the UI is trying to display.

composition with transparencies is the main one

I'd like to know this too. I'm building a egui app and it's fantastic. I have tons of custom drawing and stuff though

It's definitely possible to do sharp fonts in the Rust GUI ecosystem (although you certainly won't get it out of the box). With the native text libraries if you want to (both Servo, Zed/GPUI, and anything using Skia do this), or emulated with Skrifa + Vello.

But I agree with the reset

Yeah. Presumably "native" here just means "not Electron", which is the sales pitch for most AI-generated Rust libraries these days. ("Tell your agent to rewrite your Electron app into Rust~! :rocket emoji:")

Not to be confused with Rune, the development environment [0].

[0]: https://rune.build/

I have the same annoyance. It's continually maddening to see "native" plastered everywhere only for it to be some non-native junk. I miss when native meant something like Qt.

I've been thinking a lot about the term "native" as I come from mobile. When writing a core in Rust (which I like to do), and then layering on the operating system's UI SDK components per platform (which I also like to do), what is native and what isn't, especially when you throw in React Native to the discussion?

I like your definition quite a bit, but I need another word for, "code that doesn't need a runtime to execute."

I ended up using "experience layer" to describe the SDK components.

Changing times. Nowadays a lot of software UIs are developed by people with a web UI background. Those people won’t learn the OS-native UIs because that would mean they’d give up on their existing knowledge. Because of that native means “not running in an embedded web browser” to many nowadays.

Native often means "not a wrapper around a webview".

If you define it as "using the widgets provided by the operating system", then "native" is by definition incompatible with "cross-platform." And what does that mean on Linux, where the operating system doesn't provide widgets? Are gtk and Qt not native?

I wonder whether that results in better accessibility for disabled people in the end because agents can control UIs for them.

there are tests, no?

e.g. https://github.com/anomalyco/rune/tree/dev/crates/rune-kit/t...

Wait, zero tests? It is super cheap to write tests these days. It is how you gate agent generated code from destroying production.

What are you talking about? They definitely have tests.

Damn, this README is more of a DONTREADME. Even the root README is for agents, not people. The more I see stuff like this, the more I think about becoming a welder or a carpenter...

Why do you say 0 tests? Are the other statements similarly precise?

You're not kidding - that README is not readable.

The site is wild, but the little triangles in the bottom right corners of each window don't work properly on chrome desktop in windows 11. They aren't clickable, you can only resize the windows horizontally. Which seems weird considering how polished the rest of it looks.

it doesn’t look immediate mode to me?

It presumably powers OpenCode, the agent harness.

The website for https://www.egui.rs sort of sucks, it took around 10 seconds to load and initialize for some reason.