Way Cooler

> Seriously, lisp? Sure, why not? This is a Wayland client, not the server (aka, compositor). But there's little technical reason not to make the compositor in Lisp either, other than the time commitment. If you want Rust clients and compositors, they do exist. If you don't know how to find them, here's one that turned up on Google: http://way-cooler.org/ Some more Rust/Wayland stuff: https://github.com/Smithay/wayland-rs

It is more interesting to actually read the follow up article, "Way Cooler Postmortem" http://way-cooler.org/blog/2020/01/09/way-cooler-post-mortem.html

Another interesting project which is similar to awesome: http://way-cooler.org/

There is a tiling window manager for Wayland called "Way Cooler" (a pun on the Awesome WM, I suppose). It apparently has an i3 preset. http://way-cooler.org Recent HN discussion: https://news.ycombinator.com/item?id=14676625 I haven't tested it yet, but bookmarked the HN thread because I want to try a tiling window manager, but decided to make until there's a good one for Wayland.

For starters, I do agree that the X11 model is fundamentally broken on the modern computing platform. However, sadly, I'm beginning to think that Wayland has made some fundamental architectural choices that are not fixable and are also broken on the modern computing platform. The biggest problem is that Wayland takes the "compositor" route and turns it up to 11. Unfortunately, nobody does multi-window compositor to application integration well--Apple is the best, but by no means good. Even Windows drops to software rendering on resizes and actually integrating with the compositor needs a whole host of new Windows calls that nobody ever uses. The whole "You need link a library and draw your own decorations" is, put simply, ludicrous. You don't draw them on Windows, macOS, iOS, or Android. Yes, that means you can't change your window manager, so be it. Look at the contortions and dependency chain that the winit package on Rust has to keep in order to communicate with Wayland. The fact that I need 50,000 lines of code called wlroots is nothing short of a travesty. Even if I use a language which is much better for security, that 50,000 lines of code is a shambling security disaster that will bite me in the ass. And that's before we start talking about some of the architectural design decisions made in wlroots. The design decisions are so anathema to something like Rust that people have given up and been forced back to…

Yet once the Chromium team goes down that Rust to C++ FFI route, they will encounter the same old bugs outlined in this paper. [0] They might as well fork Servo and create their own engine from that, but even that is still a prototype worked on for years with zero C++ at least. It's too early to see how the Chromium team will begin to work on this given it's only a plan, but maybe the unsafety and security issues are enough motivation to actually use Rust to C++ interop or a rewrite. But once again, this has been tried by some other projects and by just looking at the effort of a rewrite, they later concluded that it is not worth it. [1] [2] Even better, just improve Servo instead. But I guess they would rather create their own fork, just like they did with WebKit. [0] https://arxiv.org/pdf/2003.03296.pdf [1] https://blogs.dust3d.org/2019/03/13/why-i-rewrote-the-mesh-generator-o… [2] http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

I was wondering something similar. This reminds me of the time a few months ago where someone gave up on writing a pure Rust binding to Wayland because the memory model in Wayland doesn't play well with the borrow checker[0]. It seems that the problem is you can write any arbitrary way of manually managing memory in C that doesn't necessarily have a complement in entirely safe Rust. I'm not really sure this can be reconciled with any arbitrary C library. One of the benefits I see from Rust is the ability to be unable to do unsafe things without explicitly stating you know what you're doing, thus preventing various classes of errors. But it feels like if the ownership model just doesn't fit with Rust's model that allows those guarantees to be made in the first place, it won't work. You can't write just anything in safe Rust without limiting the things you can do, but C libraries don't have such limits. It might take creating new ways of representing GUI objects before the best model for that problem arises for Rust. I don't think libraries like GTK were designed with the lessons in safe memory management Rust learned from years after the fact in mind. [0] http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

Wayland compositors, maybe: https://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

> (see: http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-i... for how big it is) Disclaimer: I don't know Rust beyond println!("Hello World"); C is my preferred language for decades now. The example Rust code in that linked post is just an absolute unreadable horror show. If that's representative of what it's really like to interop C with Rust or just write real Rust code in general, I'm strongly discouraged from bothering to put more effort into the language. Can anyone skilled and experienced enough with Rust to judge what's going on there comment? Is the author just a noob making a mess of things as anyone can do in any language, or is this limited to C interop? Or is Rust normally such an inscrutably verbose disaster?

Note that Way Cooler switched from Rust to C in 2018, because the developer felt Rust didn't work for them. It's also been archived since 2019. (Also even the Rust version was built on top of wlroots, not a Rust implementation of the protocol like wayland-rs is.) https://way-cooler.org/blog/2020/01/09/way-cooler-post-mortem.html

http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html Is a really good write up, though very specific to Wayland.

Interesting, thanks. Guess they went that way because of Rust, but it would have been super cool to have another wlroots compositor on the block. EDIT: Just found this, which explains a bit: http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

Rust does not bind well with C for this reason it can not become a system level programming https://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html However, there is another programming language that does not need bindings. It is called Zig and here it explains how it solves the same problem https://youtube.com/watch?v=mwrA5IRGpfU&feature=share

Does this RFC include all the requisite “safe” interfaces to enable writing a fully featured driver in Rust? If not, is it theoretically possible to create those safe interfaces within Linux’s API driver infrastructure? Or will some unsafe API usage always be necessary in Rust? I remember there was an issue writing a rust-safe wayland compositor on top of wlroots because wlroot’s ownership model was simply not able to be cast in terms of interfaces that rust was able to prove were safe. [1] Is this not an issue in Linux? [1] http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html

If you're willing to write it yourself, `awesome` (the window manager) might be what you're looking for. It's surprisingly powerful. As an example, I once had a cobbled together WM version of emacs' `ace-window` way of jumping between windows going. It wasn't even that much code… There also supposedly is a Wayland based "successor" for it called `way-cooler`. I've never used that one, though. Edit: OTOH, I've come to find the `i3` model of just allocating 10 virtual work spaces to work better for me, since that works way better with just a keyboard than tabs. But I guess this is a matter of personal preference. Edit2: It looks like `way-cooler` was discontinued last year: http://way-cooler.org/blog/2020/01/09/way-cooler-post-mortem.html

What he mentions is wlroot-rs. If you're interested, here's the post from its author about the difficulties faced which lead to stopping development. http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html It was discussed here back then https://news.ycombinator.com/item?id=19778738

this talk is phenomenal thank you. he explains (timestamp: https://youtu.be/mwrA5IRGpfU?t=330) why he didn't go with Rust and it's quite puzzling what he says. I don't know enough about Rust if that's the case. To rephrase: "Rust was an obvious contender but it lacked good support for wlroots. there was a project which attempted to address this but they gave up after 12 months of work and 1000 commits. Rust's strong safety guarantees and memory management conflict with wlroots which assumes a longer lifetime of pointers. If you unplug your monitor with wlroots this pointer receives an event that means the output has disappeared and needs to be validated (see here https://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html)… This is strange because Rust positions itself as a system language so I'd have imagined these scenarios are all over the place and unsafe Rust would be the way most of this is solved?