Are you using Rust to build UI? 🤔 Let us know!

Get ready for a Primeagen reaction

Isn't this a click bait? You didn't explain why we shouldn't use Rust and started explaining all Rust features.

"Imagine having a button that doesn't do anything when you click on it". This is how my apps work now

I really don't understand why you compare Rust and React. Rust is low level programming language, React is a js library. How do you compare these two ? I have never seen comparison between C and React or C++ and React. Maybe your next video title will be comparison between HTML and Java 🤣

Lack of inheritance puts no restrictions on how UIs are built. If anything, there's more and more trend towards getting rid of inheritance and OOP in general (take react hooks for example). What's challenging in Rust is sharing of mutable data. If 2 components can modify the same view / same data (e.g. clicking menu icon can open a menu, and clicking close button or overlay can close the menu), that means both components need mutable references to the same data, which is disallowed in Rust. This is solved, usually through RefCell or something like it, but it's not as easy as in other languages, though I'd say every UI framework has already come up with good solutions for this and many have decent DX. I don't think the argument about inheritance makes any sense, and criticizing one example of trait implementation doesn't lead to a general conclusion that Rust is too limited for building UIs in any way. Rust doesn't have less capabilities than other languages, but Rust has less magic and fewer ways of shooting yourself in the foot. If you want to understand and fully control the memory and speed of your application, I'd say Rust is actually preferable.

This is ironically a common Trend I see in more complex rust programs. Using owning relations gets prevented by the borrow checker, so people invent this "index into an array" method, to circumvent the borrow checker. Issue is, then you kinda reinvented pointers, only that the rust system does not "know" about them and thus cannot check them. This also means there is no mechanism preventing you from accidentally using the wrong index into the array. This is similar to the memory bugs rust tries to avoid, just one level higher.

Personally i like the "egui" crate the most. You create UI elements not by creating objects, but by calling functions. Your code sits inside a big closure that is called each frame, therefore your UI is rendered every frame - no need for component management, if you don't want to draw something based on a condition, you just put the drawing call into an `if`.

Anything OOP can do, traits can do better. The mutability thing is not really a problem in Rust. Problems with references and the borrow checker? Use smart pointers. Accessing smart pointers is very performant, like accessing references (without optimizations). Iced is amazing, but still lacks many features.

Rust does not "lack" object oriented programming. It supports it in almost the same way that C++ does, even with multiple inheiritance. Instead of "extending" a class, you just have another struct as a member. To make the "derived" class act like one of it's members, impl the Deref trait to allow it to be borrowed. This use is what the Fyrox game engine uses. Please don't make it more difficult to find Rust programmers for hire buy discourraging its use. We need more Rust programmers.

In the AMIGA days there also was no object oriented Model for doing GUIs, but AMIGA had GUIs, Windows a long time before Microsoft Windows was a thing. There are C-libs for graphics out there like raylib or OpenGL that also need to update alot of events and have to organize that. With C you need to build your own structures and data organization, because C is a very primitive language. So the big picture could yield from the question: How did they do this with those minimal resources, and how can we transfer this to the Rust-world? Another good sort of information would come from game programmers like for instance Casey Muratori. With the object oriented approach you miss the cache alot. So I think a Module based approach is better, like you are already following. A Module that handles all the drawing in the GUI framework can utilize the CPU cache well better, reducing performance-headaches. There are, frankly better, solutions out there that do not need object orientation at all. So it is definitively doable.

More content like this please, getting fireship vibes here nice balance of educational and fun

Sorry for nit pick. ReactJS isn’t a programming language -> 3:19

Fantastic video. I’m not sure I fully followed everything, but I think that’s mostly on me. Do you think the issues you raise are those that UI developers have to contend with or just framework developers? I feel like procedural macros fill in some of the gap left by the lack of inheritance

I've not run into these "big headaches" writing GUIs in Rust. Event handling and message passing is so easy in Rust. My GUIs typically use a tree structure and the root component has an event loop where it receives events and dispatches them to sub-components that handle the events that they can handle in their event loops. No need for interior-mutability.

Can you elaborate more on the Entity Component Structure method? What sort of GUI library for Rust does this? Did you have to write up your own? If so does this mean other people writing Rust GUI should stick to the Elm-inspired libraries like Iced?

Both pleasant to watch and listen, and most of all it's spot on topic

Wanted to ask, what do you use to create your videos? (this one looks very cool, congratz)

I subscribed because the thumbs up button went all sparkly, not because it's the best sales pitch for rust I've heard to date.

Currently I am starting to create a VST3 (or maybe Clap) DAW plugin featuring a GUI in Rust. Hence the HUI framework needs to get the Window context from the DAW via the plugin API. Once I am able to a non-GUI plugin I will start evaluating GUI frameworks, supposedly starting with ICED.

I love your channel and look forward to warp, hope it can have cute background imgs like Windows terminal 🙏

I didn't quite catch the relationship between hierarchy in OOP, the component tree (a.k.a. tree data structure), and the lack of inheritance in Rust. It's completely possible to build a tree structure in Rust, just like your example for React or how it's done in Angular. If the lack of a common type is the problem, you can use "dyn Component" which should work as a common trait for all components. I'd appreciate if you could elaborate a bit on this, because the way it's explained in the video might misinform people.

You can do a lot more in rust than is apparent right out of the box. I bet you could theoretically do classes with inheritance using macros and you can use data structure with interior mutability as mentioned in the video or if you really want to you could “unsafe{}” it all and build your own model on top of that. You could even implement a garbage collector if you really wanted to. It’s just that rust can give you some nice guarantees if you figure out how to do things according to the safe borrow rules, and to be honest, you might have to do a lot of work to get some of those other things going, on par with designing your own programming language. To be fair, gui libraries are almost that anyway, with how much terminology is required to reason about them. There is a lot of experimentation going on in the gui space currently and it’s very fun to follow. Even if it might be worth while to wait a bit before betting on rust gui if you want to do anything really serious, I don’t think things will stay that way for long.

This is why Tom is a genius and you should build your app on JSDL

I am a C++ programmer, but I am looking for ways to implement GUI with an ECS as well. I believe it can be done in a way that code is fast, and API is easy for the user.

Traits are interfaces. Rc, Arc, and RefCell exist. If you can't figure out how to make a UI with those tools, you suck at Rust. There are tons of Rust UI libs. The way you hide the complexity is by just keeping it inside the library.

I agree on everything in this video. Building GUI with Rust frameworks/tools is over ambitious. Perhaps it's too early for that. I separate FE from BE. I use Go/Rust for BE and React/Flutter for FE - the best so far IMO.

Found your channel from coding with Lewis and I subscribed 🙌 The quality of video is 🔥 The knowledge given is 🔥 Thanks and bring more content like this

What about Druid framework for Rust GUIs? Are they any good?

As a mathematician I come from c++, python (ML and DL) . Love rust just because ML and DL will need to be productionised at some point.

probably a stupid question but why not use something else to build the ui and use rust for everything else ?

The video is much better than the catchy title suggest

I love your content, thank you so much for sharing it,

We could also build the UI with Raylib. Doesn't mean we should

Omg someone mentioned Elm! I work with Elm quite a headache tbh.

I would very much want to hug wichu for a better understanding of this lang u seem so cool like knowing so much about neural formation of this lang 🎉

Like the explanation of OOP in UI rendering

How is writing GUI libraries in Rust more difficult than writing them in plain C? Most GUI libraries were written originally in C, not even in C++, and in C you don't have any OOP.

Linus Trovald in a recent interview said that, Rust is not used in Linux Kernel as stated at the beginning of this video. There’s no need actually to replace C by Rust. Since C is a better language when it comes to interact with hardware

Thanks for explaining Rust

Very well informed video!

Excellent video!

SwiftUI is all built with structs. I imagine you could do something similar in rust.

Rust probably has more object-oriented features than your average Java clone. There are traits (powerful interfaces) instead of abstract classes, and "inheritance" is achieved through them; that is, every struct that implements a trait X de facto "inherits" it so it can be dynamically dispatched to a trait X object. It's really just a more recent and flexible approach.

Am already learning Rust . It’s hard but worth it . Am already intermediate

Honestly I'm not building UI myself. Using Bevy's ui for ui and egui for debug ui tools.

Yeah, during the whole video I was just thinking: ".... we can just do it like elm does" I wasn't expecting ecs tho, even though I got interested in rust because of bevy

ID is the short form of identity. It's ironic that identity ID is used in warp at 8:10 that literally means Identity Identity 😅

Interesting take. I'm new to rust and really enjoy it. Now that I've thouroughly indoctrinated in the crustacean ways. I'm in the mood for some criticism and learning about the pitfalls of rust. Most videos I found were just masked rust propaganda or people that didn't seem to get the point of rust. Glad to have bumped into this video. This was a breath of fresh air with a well explained and pretty unbiased. That gets you a like! And the policeman crab with the moustache earned you a sub.🦀

5:28 What safety issues are you talking about?

I agree overall, most of the time and energy is spent on making Rust a good backend or systems programming language instead of a good front end language. Rust feels underdeveloped in this regard

ECS outside of gamedev. Is this a dream?

I've seen people write an assembly or another language block inside rust code, maybe GUI is best done that way. Like letting rust do what it does the best, run core code really fast and safe, but separating the GUI to something evil rust shouldn't touch. After all, isn't multiple languages in a project a very common thing already? Like most of the time for web stuff you just have to step into the javascript world to save yourself from more pain.

🎯 Key Takeaways for quick navigation: 00:31 🧐 Building a graphical user interface (GUI) in Rust is challenging due to Rust's unique features like ownership and mutability rules. 03:44 🔄 Rust's lack of object-oriented programming makes it difficult to create a top-level component that controls a GUI tree, unlike languages like React. 06:51 🧠 One solution for Rust GUI development is adopting the ELM architecture, which consists of model, view, and update, or using an entity component system (ECS) architecture. 08:20 🌐 In Warp, they implement an ECS-style approach with a system that owns components and maps their relationships, providing a way to create a GUI tree without relying on inheritance. Made with HARPA AI

Why is Warp, a terminal, proprietary!?

Are we gui yet? Close enough...

Would be great to compare it to something modern in web development not something like React that has so many essential issues, where the main one is the whole render model...

I'm learning Dioxus at the moment

I guess I'm just missing the point. If you want to build a user-mode app with a GUI, you use C# or . Why would you even consider Rust or C or C++? I mean, I guess if you're writing code for a super resource-constrained system, but that's a pretty specialized niche. Microsoft is using Rust for what it's best at: system level programming. They're doing Azure development in Rust, as well as re-writing some of the Windows system binaries in Rust. And if a developer doesn't want to worry about memory management, they have no business writing a device driver or a kernel binary. This just seems like a moot point. It's addressing a straw-man scenario. Or, I guess I should allow for the possibility that the world is a weird place, and there are strange people who do inexplicable things. Are there really people that voluntarily choose to write GUI apps in Rust? What's their motivation? The extra performance simply doesn't matter, at all. On the other hand, is there anyone seriously arguing that Rust isn't a very valid, and perhaps even objectively correct, choice for systems level programming? I mean, I did my share of kernel development in C 25+ years ago, and to this day it's the language that I am most comfortable in, but surely even the most die-hard C or C++ developer would allow that Rust is at least a nice option?

Js is for the Dom and it should stay that way. Each language has its strengths and rusts' is in threading and memory management, along with a few others from what I know now

i like warp, but why go the route of accounts? just curious

What about Zig language?

The command line is a tool that is ripe for change.

Great video.

So, instead of inheritance you make composition... I think?

It hearkens to a reductive existential contradiction of rust's very safety. Does it mean that one of these methods simply has to "admit" and "embrace" the inevitable? It seems important to choose tools that embrace the inevitable - if it's the inevitable.

I wouldn't want to create a ui in rust, just a backend that returns json data, and I would delegate the front-end to any framework of your choice, React, Vue, Astro, Svelte, Flutter, you name it

Then I guess we need to wait for Iced

Why you did not went with Electron? I launched Hyper and on startup it takes same amount of memory as Warp

What I got from this video, is that if you try to do things the way you did them in React, you'll have a bad time. If you do them the way Rust wants you to, you'll have a good time.

Why did you build warp with rust?

I think Rust object composition clearly works. You good pointed to some potentially problems, but there are no such problems in a reality.

I was thinking how you could look into the camera while talking so people feel like you are talking to them... How about you create a dead zone in the middle of the monitor. Set up your camera in the dead zone. 😊

We're evaluating Rust as a possibility in modernizing a huge CLI system written in C and TCL. (It is very very old). So far I've found it to be unfamiliar and difficult. It is not really OO and not really functional. It has no garbage collection. It has very high interest among developers for some reason and is the reason we are considering it because we could more easily attract top software engineers. (Our team is entirely made up of 60ish year olds)

So rust is basically golang without garbage collector?

Thanks teacher🇮🇳

Tauri isnt to bad for Devs, coming from JS background. I have focus to Tauri with Svelte, as it seems to me quite all in one thing to me. If you do perhaps know like QT for C++. I bet, Rust does have something similar. However, I would not blame Rust for being not good for UI, as it probably offers to many confusing ways to do stuff, if you think in a monolith. Even your MVC approach is unsure to me, as it might lead to blowing up the code.

I only have Web UI experience, mostly in angular 7-15. Flexibility is the main thing to get from a frame work. Ive worked with symfony/ twig, laravel/ blade, alpineJS, and xamarin. I like a framework to handle routing, navigation, etc. But in the end vanilla JS with JSDocs is just best for DOM manipulation. As much as Javascript drives me insane, I always get to a point to where I need plain 'ol Javascript to accomplish something special. If you want a custom ckeditor, then you still have use vanilla JS. Angular 15 compiling to JS still isn't perfect. I'm eyeing Phoenix + AlpineJS for my next project.

Why don’t you guys open source your GUI

I'm using rust a lot in the backend, it's a life saver for me. To build uis for the web though... Not so much. Also if you need to build desktop apps rust is definitely a good choice to use in the place of c++.

Nice video but inheritance and OOP is NOT a cumbersome feature..... we have interfaces (traits) that makes life easy as well. and composition is easier to handle , sure, but just cause other langs offer class inheritance doesn't make it inherently evil

Egui while complex internally is incredibly simple to use and it's pure rust as far as i know.

The lack of class hierarchy doesn’t mean you can’t organize components in a tree structure, huh? You could easily define a trait with componentDidMount() and similar functions, even a children() function that returns an impl Iterator

Why'd you use it for UI?

We need more sandwiches in modern UI tbh

If I can't build my GUI, I will use a TUI.

Ok. Now Let's Get Rusty. 😊

This video was fantastic in content but visually a little bothersome. Making text hard to read (script vs plain) and then animating it (pulse) and not leaving it on screen long enough really took away from what you were trying to say imo.

After rust I am fighting significantly less with my gf, now I fight with borrow checker

cool video

The biggest issue is no inheritance. This is what happens when you adopt a fad. "Inheritance is bad because it is okay!"

sudo make me a sammich UI object

game dev and web dev is the thing that will propel rust

With traits , I don’t need abstract classes and inheritance . Other programming languages add bunch of rubbish we don’t even need

I don't think some of the characterizations stated here are true about Rust, and even the implications about programming in general are a little skewed. Rust not being "OOP" is quite far from accurate as it is about as OOP as C++ and Java meaningfully are -- which is to say that programmers who know true OOP know that even C++ and Java don't even qualify. Needing to use another paradigm that isn't "in vogue" with current frameworks shouldn't be considered a bad thing for a software engineer, it is just a different way of modeling the problem. ELM architecture pretty much seems like MVC to me, but I'm far from a real UI dev. ECS is absolutely an approach software engineers should know if they are writing applications where performance matters -- and hint: performance pretty much always matters. The only question is 1) if your company is wise enough to look at CPU/memory costs for servers and know you're leaving a ton of it on the table, or 2) if you have competing (client) software and customers will see how much slower and memory demanding your application runs versus another. ECS is very well used in game development as the way "OOP" has made a lot of engineers think about managing data (and indirectly memory) is actually very terribly inefficient when you have multiple subsystems working with the same "object" in your OOP mind, but in reality, the game's subsystems only need to see what they want to see. What I mean is, your game logic has an understand of an entity in the world in terms of gameplay logic and collision detection; the graphics rendering system only cares about the graphics data associated with the object; the sound system only cares about the sound data associated with the object; maybe the netcode doesn't give a crap about the object etc etc. Rather than have a single object "manage" all of it's own stuff as if should maintain all of those references, it's existence is actually defined through those subsystems understanding the association of an identity to the subsystem encapsulated (managed) data. In otherwords, the "Sonic" sprite doesn't reference the fact that it is drawn with "sonic.png," it exists with global ID 112233, and references texture ID 55667 which the graphics resource manager knows was loaded from file "sonic.png" and if you opened in an image editor, you would see the Sonic sprite. It's a classic newbie approach to think that a gameobject "subclass" needs to exist for Sonic, and somewhere in that source code, you'll read the fact that it uses texture "sonic.png." You can make a small game with that approach, but at some level of scale, you'll quickly run into a class explosion and realize how much you're repeating yourself. ECS is also beneficial because it's SoA rather than AoS -- that is, structure of arrays rather than array of structures. When your graphics system needs to rip through 10k objects out of 100k global objects and render those that are visibly relevant, better that it actually runs through an array of 10k relevant objects, than 100k objects through "polymorphism" and 90k objects just have a do nothing render()/draw() method. That's 90k bounces around in memory and your CPU cache is just constantly being trashed. The real reason Rust isn't a great langauge today for web GUIs is because it simply isn't mature yet. Javascript pretty much exists soley for the purpose of web UI dev and has been for decades and Rust is just arriving. Rust may not even the best use case for front end stuff, but as a general programming language people would like to prove it so projects don't have so much language + tooling mixing requiring too much knowledge spread for a dev team. Plus it has other benefits, that may pay off in the long run if the up front isn't too high.

It is almost as the person in this video doesn't know object oriented programming. It also looks like it doesn't understand how to handle memory allocation.

i think you shouldn't swap to camera if you're reading a script, just looks like you have lazy eye, but you're really interesting to listen to otherwise

I've been attempting to find compelling reasons to learn Rust, but it seems to be a challenging programming language in many practical aspects. It will likely be another unsuccessful effort to replace C and C++.

Does this mean you and the warp team regret using Rust to build your app?

👍