awesome-wlroots VS wayland-protocols

If you are scripting-heavy user, I recommend trying out one of WMs based on wlroots (or implementing its custom protocols). Core Wayland protocols are designed with security in mind, which doesn't necessarily let you have all the automation fun. wlroots protocols bring back most of X11 capabilities at the cost of having similar security model.

https://github.com/solarkraft/awesome-wlroots is a pretty nice list of various CLI utils you can use. Sadly I don't think anyone aimed to 1:1 replicate APIs of xdotool etc, so you will need to change the syntax in your scripts a bit.

An incomplete list of compositors (they forgot hyprland):

https://github.com/solarkraft/awesome-wlroots#compositors

Among non-tiling ones are: hopalong, labwc, laikawm, tinybox, waybox, wayfire.

This appears to be an attempt at trolling or bait (“Drew Default”) but I’ll bite.

> Wayland ostensibly supports several dozen extensions, but only the GNOME-blessed extensions can be reasonably expected to work.

Instead of actual protocol extensions it seems like the author is talking about desktop tools. “only the GNOME-blessed extensions can be reasonably expected to work” oh GNOME and nowhere else, because GNOME has a “loose relationship” with standards. Meanwhile the rest of the ecosystem is unifying behind wlroots, which coincidentally I have made a small list of tools for that cover most needs: https://github.com/solarkraft/awesome-wlroots

> I can assure you that it’s a nightmare. Creating a new compositor would be a hellish experience. Ask any distribution packager who works with Wayland to share their horror stories — they have many.

Distribution packagers try to make compositors? Maybe they should take a look at wlroots.

> Even on the supported platforms it comes with a substantial burden on build requirements, calling for 10× to 100× or more RAM, CPU time, and power usage.

Obviously not. Some sessions on GPU acceleration being available nowadays, but that’s not a new development. The GNOME Wayland session has been demonstrated to be faster than the X session (many years ago on a Raspberry Pi).

> Novel hardware which addresses issues like microcode and open hardware, like POWER9 and RISC-V, are also suffering under Wayland’s mainstream-or-bust regime.

Why? What does “mainstream-or-bust”? Probably not the protocol maintainers’ tendency to compromise on things to make Wayland not appealing to average users (ha).

> Anyone left behind is forced to use the legacy Xorg codebase you’ve abandoned, which is much worse for their security than the hypothetical bugs you’re trying to save them from.

Xorg, by design and historical growth, is insecure. That said security fixes will of course continue to be shipped (I don’t say this with any internal knowledge of Xorg maintainable, only trust in the FOSS ecosystem). Of course, the user base is still huge.

> Rewriting your code in Wayland is always going to introduce new bugs, including security bugs, that wouldn’t be there if you just maintained the Xorg code. Maybe there are undiscovered bugs lurking in your Xorg codebase, but as your codebase ages under continuous maintenance, that number will only shrink.

Xorg is insecure. Not because of bugs, but because of features people rely on.

> Those of us who work with such systems, we feel like the Wayland community has put its thumbs into its collective ears, sung “la la la” to our problems, and proceeded to stomp all over the software ecosystem like a toddler playing “Godzilla” with their Lego, all the while yelling at us old fogies for being old and fogey.

I agree. I consider ”Out of scope” to be the unofficial Wayland motto.

The summary at the end is a beautiful soup of contradictions.

> Slow down the protocol

It’s already fairly slow.

> write a specification

That’s what a protocol is, isn’t it?

> focus on improving your protocol extensions

By that do you mean adding more? I thought the protocol was developing too quickly?

> support more Xorg programs

The charitable interpretation is that it means “support more Xorg use cases”, which is completely valid. The way it’s said would also allow for the interpretation that the author hasn’t understood what Wayland is and wants X APIs added.

> work on performance, stability, and accessibility

The protocol allows for very high performance. If individual compositors are inefficient, please talk to their maintainers. This isn’t an issue with Wayland in general. Same deal with stability. The compositor I use (wayfire) is super stable. Unfortunately I can’t comment much on accessibility other than that I know that Linux has historically been pretty bad in this area.

> Invest more in third-party implementations like wlroots.

With it defining the third compositor type besides KDE and GNOME I think wlroots is seeing an healthy amount of investment. What’s going too slowly for my taste is the standardization and adoption of wlroots protocols by other compositors (will GNOME ever care about what other people are doing? Will they stay incompatible forever?).

> Your ecosystem has real problems that affect real people. It’s time to stop ignoring them.

I completely agree. The “out of scope” meme may have been holding Wayland back. We need much more standardization, akin to the XDG standards. There’s still a lot to do.

wlrobs has issues for me with 2 screens of different densities. With xdg-desktop-portal-wlr the Pipewire route will work as well.

My favorite way to record on wlroots compositors is wf-recorder, which seems to be lighter on resources than the others.

There's also a fork of SimpleScreenRecorder (with similar issues, unfortunately).

Here's an overview of screencasting tools for wlroots based compositors like Sway and Wayfire: https://github.com/solarkraft/awesome-wlroots#screencasting

It's true, it's going to drag on for years. But Wayland is creeping into the mainstream. It has been the default on Gnome for a good while and Gnome Wayland is going to be the default in Ubuntu's new release. KDE is a bit behind but also on it, promising "production level quality" until the end of this year. At the same time a new class of compositors without any X heritage is emerging around the wlroots library.

I was wondering which .so contains the symbols for https://github.com/wayland-project/wayland-protocols/blob/main/unstable/input-method/input-method-unstable-v1.xml.

I was researching the issue and noticed wlr-screencapture. I was hoping to see it at https://github.com/wayland-project/wayland-protocols too, but no luck. Thanks for the lead on xfg-desktop-portal.

It is fascinating watching the near decade-long journey as Wayland tackles screenshots.

> Nothing is thrown away -> xserver is there for exactly this reason. Adding the extension for a system with bad abstraction is not too wise, but if you wanted to understand it, you would have done so already based on the video.

I did watch the video, and while I was convinced that the X.org reference implementation was crusty, I was not convinced that there was anything inherently wrong with X11-the-protocol. Like, if there existed an X extension whose responsibility was just to get clients set up with their own video buffers that it could composite for them, then it sounds like it would address 90% of Wayland's value proposition. Is there a particular video snippet you want me to pay special attention to that clarifies this?

> Why would it be lost? There is a core protocol that absolutely specifies it.

I read through the stable interface definitions in the wayland-protocols repo [1], and did not see anything related to controlling which programs get to see which events. Is this still in development (or unstable)? If so, is there an ETA at which point I can expect every correct Wayland compositor to faithfully implement it?

> And when you had only one player in the whole game.. which is pretty contradictory to your last sentence.

That's because the X server implements the mechanisms, not policies, for multiplexing the screen and input devices. In the service of this, it provides tools to enumerate, identify, query, modify, and extend properties of windows, as well as route messages between them. There was never a compelling need for multiple competing incompatible X servers because X is the narrow waist (i.e. an unopinionated digital commons) shared by software that competed on policy.

> I didn’t address these things because basically everything has a solution under wayland nowadays. Please have a look at the wayland-protocol repo and see for yourself the state of it. Also, wayland is a display manager, just because the X server was a monolith, it had no place to eg. manage clipboard. Actually, Wayland is the one that fulfills the UNIX philosophy of do one thing (although I don’t find the UNIX philosophy a good thing in every case)

I read through the unstable interface definitions, and see that Wayland is indeed trying to implement not only the same kinds IPC facilities and input device multiplexing that X provided, but also is trying to impose stronger opinions on what types of windows exist and how they behave (e.g. Wayland has a notion of pop-ups, text inputs, and so on). So if Wayland's goal is to avoid being as "monolithic" as X, it appears to be failing.

Also, putting core functionality that everyone must implement the same way into extensions just so they can call Wayland "just a protocol" or "just a display manager" is disingenuous. They might as well just say that they're part of the core protocol.

> No, you just use wlroots that implemented the “crap-ton” of extensions for you already, and be on your way.

Does the wlroots project define what extensions are standard and required for a piece of software to call itself a Wayland compositor? No? Then "just use wlroots" isn't addressing the problem of making sure these compositors are compliant to a set of common, useful standards. Like, maybe wlroots should be the standard-definer, just as X was? What happens with window managers built with a compositor that is not wlroots?

[1] I was looking here: https://github.com/wayland-project/wayland-protocols

Virtual keyboard: https://bugs.kde.org/show_bug.cgi?id=427972 it is still a hot-topic on the protocol definition side with the current definition https://github.com/wayland-project/wayland-protocols/blob/master/unstable/text-input/text-input-unstable-v3.xml still not satisfactory, this was one of the subject of this weekend Plasma Wayland online Sprint. The Virtual keyboard is especially important for different input methods, aka chinese, japanese, koreans characters. You may want to setup http://maliit.github.io/ on your system.

The protocol XML files have remarkable, concise documentation of each request, event and interface. Core protocol. Other protocols.