wayland-protocols VS musca

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.

I used to love GOOMWWM[1] and used it for the longest time. I miss a lot of things about it, still. It doesn't quite meet your requirements, looks-wise its very minimal and it doesn't have snapping, but I really liked the idea behind it: make a keyboard-centric stacking/floating window manager that gives you enough control that it can be used as if it were a (manual[2]) tiling window manager. It really feels like a tiling window manager and its fantastic!

[1] https://github.com/seanpringle/goomwwm

[2] I personally use sway these days, but I still prefer manual tiling where I move and size windows myself, rather than having the WM try to do it for me, as long as the WM makes it very easy to do, as goomwwm did (and its predecessor, musca: https://github.com/enticeing/musca)

I came to filing window managers through musca[1] and then goomwwm[2] (Get Out Of My Way Window Manager) and then switched to i3 (and more recently, away) because both Musca and goomwwm haven’t been updated in years.

I still miss Musca and goomwwm. They didn’t require any visualisation of the hierarchy, things were just layer out next to each other without a hierarchy and just worked. It was very intuitive. Goomwwm went a step further: it’s not technically a tiling window manager at all, but rather a floating window manager (so you can have your windows overlap if you want) that happens to be usable as if it were tiling and that’s keyboard centric (but you can use mouse too if you wish). That really was the sweet spot for me and I often find annoying behaviour in i3/sway that goomwwm didn’t have (typically around movement and resizing).

[1] https://github.com/enticeing/musca (original source and all documentation seems to be gone)

[2] https://github.com/seanpringle/goomwwm

I have attempted a manual tiling WM once, which I have abandoned because stacking WM is more suited for me. Here is the unfinished project. I took the basics from DWM and Herbstluftwm (which was way simpler when I was looking into it). I also remember taking inspirations and examples from Musca WM.