Blender: Wayland Support on Linux
code.blender.org
code.blender.org
See the discussion here: https://discuss.pixls.us/t/wayland-color-management/10804
> The only thing is that color management for Wayland is progressing and far from being completely done. Even if work is quite slow, things seems to go in good direction. For correct and complete Wayland color management, we just have to wait again.
Blender itself seems to be color-profile aware: https://docs.blender.org/manual/en/latest/render/color_manag....
Here is an issue tracking work on Wayland: https://gitlab.freedesktop.org/wayland/wayland-protocols/-/m....
There's a nice site which is parallel to this work which summarizes issues/goals: https://gitlab.freedesktop.org/pq/color-and-hdr
Here is parallel work on this in Sway: https://github.com/swaywm/sway/issues/1486 And parallel work in KDE: https://bugs.kde.org/show_bug.cgi?id=439135
I can't find any reference to color management in the Blender meta-issue at https://developer.blender.org/T76428. For X11, I believe applications would have to manually determine the color profile of the display holding the current window, then query colord or and X atom to determine the profile. The application would then manually do the colorspace conversion. Does querying colord and making an in-application conversion works for Wayland until Wayland becomes colorspace-aware? Or if there are more wrinkles?
That certainly wasn't my impression from the mailing list. There are certainly some challenges with incorporating colour management into Wayland's model, but they also seem quite solvable (and the mailing list discussion seemed to end up with a solution).
Meanwhile the discussion on pixls seems to be a bunch of people complaining either that it's not solved yet, or if it is solved it won't work the same way it does on X.
The only remaining point of contention on the mailing list came down to colour calibration: one party wanted an API that allowed setting a temporary display-wide colour profile for the purpose of calibration, as this is how it has worked before. The response from a Wayland developer was that there should be a dedicated calibration extension that would allow setting a linear colour space for a specific region (eg. one matching the display). One of the reasons given for this is so that if the calibration application crashes, it doesn't leave the display in a bad state.
My understanding of the full solution is that applications would be able to specify a colour space for each buffer, and the compositor would do the appropriate transformation if that colour space does not match the actual display. Furthermore, there would be events given to the application when a window leaves/enters a display so that it can (if it wishes) choose to handle the colour space transformation itself by setting the buffer to use the same colour space as the display it is currently on. This means you get approximately correct colours when moving a window between displays, even before the application has had time to repaint itself, whilst also allowing the compositor flexibility like reusing the same output on multiple displays, displaying a preview of a window, etc.
Like, according to the linked article, the standard is out there since 2008 - so the adoption period is already 14 years! And people are still haggling about basic stuff like color management, mouse cursors and window decorations?
What exactly is the envisioned timeframe for Wayland to replace X11 as the dominant windowing system?
If the standard has been promoted as the obvious next step for linux desktop environments for 14 years but still hasn't actually caught on, are we sure it really is the right direction to go?
I tend to believe it because I've seen news reports as of 3 years ago saying that Xserver is no longer being maintained.
The change from Xserver to an arrangement using Wayland is transparent to the Linux user (and Linux admin) and I heard that most of the major distros made the transition a few years ago. A corollary of that, if it is true, is that some of the many Linux users appearing on this site to attack Wayland are in fact (unknown to themselves) using Wayland.
Specifically, the "display server" (terminology? I mean the software that talks to the graphics driver and the graphics hardware) on most distros these days uses the Wayland protocol to talk to apps. An app that have not been modified to use the Wayland protocol to talk to the display server is automatically given a "connection" (terminology?) to XWayland, whose job is to translate the X protocol to the Wayland protocol.
I think `printenv XDG_SESSION_TYPE` will tell you whether you are running Wayland or the deprecated Xserver.
The OP begins, "Recently we have been working on native Wayland support on Linux." What that means is that the blender app no longer needs XWayland: it can talk directly to the display server (using the Wayland protocol). There are certain advantages to that: one advantage is that you can configure all the UI elements on your screen to be scaled by an arbitrary factor without everything getting blurry.
I'm using the latest MacOS to make this comment, but for over a year until a few weeks ago, I was using Linux for all my computing needs, and I went out of my way to run only apps that used the Wayland protocol to talk to the display server (because of the aforementioned ability to scale the UI without blurriness). Chrome had to be started with certain flags for it to use the Wayland protocol. To induce Emacs to speak Wayland, I had to use a special branch of the git source repo, called feature/pgtk.
https://gitlab.freedesktop.org/xorg/xserver/-/tree/master/hw...
In particular that I noticed in the last year or so: Screensharing specific windows with zoom does not work correctly on Wayland. It only works on xorg. https://support.zoom.us/hc/en-us/articles/6634039380877-Shar...
I agree a ton of people are using it without knowing, ever since it became the default option on most distros. But sharing windows in zoom is a must-have for me, so I'm still running good old xorg (and without any trouble, I might add)
I'm not primarily a graphics guy so I can't assign fault -- all I know is that it's the single issue that has kept me from adopting Wayland back when the defaults switched over.
2008 is when the project started. In 2012 it was sorta-usable as a new weird experimental thing, but it was absolutely not even trying for adoption yet.
The first distro to make Wayland the default was Fedora 25 in 2016.
So the adoption period is 6 years, not 14.
Four years to get out an experimental sorta usable thing seems a huge amount of time to me. Even more so if you think that many basic things (drag and drop, screenshots, ...) came years later.
And to be clear: A big part of only being "sorta" usable isn't anything to do with itself, it's that so little other software had been ported to it.
I'm looking forward to Java/Swing hopefully gaining support too via Project Wakefield.
In general I'm not having a lot of issues with Wayland. At least not more than usual amount of "just tweak this file over there and it's fine" stuff you have with Linux in general. There's just an endless amount of libraries that need to be aligned with each other. It's one of the reasons I use an arch based distribution so that at least I'm not dealing with stuff that was fixed months/years ago.
Works perfectly fine on 1080p, which was the majority of where I spend my time on Linux, until recently.
There is a quickfix for most of the problems, just set one ENV variable:
> export _JAVA_AWT_WM_NONREPARENTING=1
https://superuser.com/a/664236
Regardless, JetBrains products works fine on my 4k monitors, so it is possible. There is something different between our systems.
Output DP-3 'Goldstar Company Ltd LG HDR 4K' (focused)
Current mode: 3840x2160 @ 59.997 Hz
Position: 0,0
Scale factor: 1.000000
Scale filter: nearest
Subpixel hinting: unknown
Transform: 270
Workspace: 5
Max render time: off
Adaptive sync: disabled
Available modes:Maybe that is the secret weapon…
"Høgsberg had the inspiration for Wayland while driving through the town of Wayland in Massachusetts, which gave the display server its name. Weston, the Wayland compositor, is named after a neighbouring town in the same state"
http://www.h-online.com/open/features/Wayland-Beyond-X-14320...
(As someone who lived in one of those towns it's always amused me when it comes up.)
I still can’t understand this at all. It’s such obvious and complete folly. And it’s not an isolated decision; there are quite a few related places where it is very apparent that GNOME has co-opted GTK and been actively sabotaging it for anyone that’s not GNOME, and it’s been heavily poisoning the Linux desktop space.
(Note that I’m not railing against client-side decorations, though the current free-for-all with no way of signalling even the simplest of conventions like the expected location of window controls (even apart from their appearance) is quite insane; I’m complaining about not supporting server-side decorations, since they are fundamental to some window managers (e.g. Sway) and completely sensible for many apps. The existence of “fallback client-side decorations” and the loose requirement that every app implement this thing that it often has no need of and can’t do as well as the window manager is at least moderately absurd.)
Both win32 and macos draw decorations client-side. Even if you don't handle the respective messages in your event loop, the libraries that you linked to, do.
Server-side decorations are hard. You cannot properly synchronize two processes to draw perfect frame. When a single process is responsible, it is easy.
Not taking sides, but why do you need to synchronize two processes when one should only draw a frame and the other should only draw the contents?
(X11 and its server-side decorations appear to be able to handle this as-is - decoration redrawing is delayed until either the application redraws, or some timeout (iirc around a second or two?), at which point you get the ugly black bars)
On Xorg with Window Maker and no (desktop) compositor running, my own toolkit (example app[0]) resizes instantly.
On Xorg with KDE5 (not sure which exactly version, whatever openSUSE has) and a (desktop) compositor enabled, same toolkit also resizes without gaps (though there is a small delay, probably due to the compositor, i didn't try without it). Same with native apps.
On Wayland/KDE5 the same toolkit resizes without gaps but there is a visible "lag" for the titlebar to be updated that didn't exist with Xorg/KDE5. Since the toolkit only supports X11 i'm not sure if it is due to XWayland or KDE5 though.
TBH in none of the above configurations that'd be something i'd notice unless i was looking for it - or it was very laggy. Even on Wayland, it is something i noticed because i was resizing the window constantly back and forth to see if there is any lag.
However i didn't link to it intentionally since this site contains a three year old code dump and my current version has a lot of things changed in an incompatible way, so i wouldn't like people using it just yet. I still need to do a bunch of other changes to the API as well as fix some stuff and rethink how some other things work that can be hard to change later if i decide to make a proper release that people can depend on (e.g. i'd like to change how fonts work to allow for arbitrary font styles). I don't have much time for it right now though, but perhaps in a few months i'll be able to allocate some time for it.
That's technically true but misleading. Yes, they have client-side decorations, but also a single and unified UI toolkit all applications use. So effectively _you_, the application writer, do not have to care about decorations.
Whereas, on Linux Wayland, if you want to support GNOME, _you_ have to care about decorations, or you have no titlebar nor X button. Which means you need to link against libdecor yourself to get that functionality and in theory wouldn't be that bad if that library was maintained and functional, but it isn't. The one stable tag is 0.1.0 from one year ago, and it still causes massive lag when trying to resize a window if you have more than 1x scaling: https://gitlab.gnome.org/jadahl/libdecor/-/issues/37 — Don't be mislead by the title, affects AMD as well.
libdecor is the _only_ way to have decorations on Wayland on all major DEs, unless you actually want to write the entire decoration code yourself. And it's buggy and unmaintained. And, cherry on top, libdecor does not match the desktop environment's look and feel, so your app has decorations that look completely out of place.
I'm a GNOME and Wayland apologist, but libdecor is terrible, unavoidable, and exists only because GNOME couldn't pull their head out of their arse and created this situation.
Not supporting server-side decorations is only a good idea in a vacuum, not in the real world. Applications should be able to choose whether they care about it (i.e. Firefox for their UI), or not at all (i.e. a video game window), as it's possible to do in Windows or macOS.
If you want to support GNOME, you use GTK or use a library that interfaces with GTK.
The binary compatibility with other desktops is just a "nice thing" to have, but GNOME really doesn't care for apps not made for GNOME.
There was a project where Qt would interface with GTK and let GTK handle its window management (similar to macOS/Windows), rather than dealing directly to the display server, but I think its dead.
And this is the sabotage of GTK and the Linux desktop that I’m speaking of.
Not caring is passive neglect, maybe not nice, yes. But sabotage is activly disturbing something with evil intentions. So this is a strong accusation, for which I like to see some more solid evidence, to believe it.
’Tis said: never attribute to malice what can be adequately explained by incompetence.
But malice learns to wear incompetence as a mask, and organisations weaponsise incompetence.
I doubt that individual GNOME developers mean any malice. There may be no malice intended from any of the GNOME project leaders. But over the last few years I have steadily become convinced that cumulatively their actions and policies are active sabotage towards every last bit of the Linux desktop that isn’t GNOME.
I'm pretty sure GTK supports server-side decorations.. GNOME does not however.
The Xorg Server has been deprecated in RHEL, but exists in both RHEL 8 and RHEL 9 and will be maintained in those distributions for the entirety of their lifespans. It will be removed in some future version of RHEL. X11 support is provided by XWayland.
GTK will use SSD so long as you don’t customise the title bar. I think you can even query it, with effort (gdk_wayland_display_prefers_ssd, c.f. https://gitlab.gnome.org/GNOME/gtk/-/commit/f2adaba237519642...), and thus behave differently depending on compositor preference. (But even that is mildly nerfed from the org_kde_kwin_server_decoration_manager interface, since it only exposes “prefers SSD” and not “supports SSD”—though in practice I suspect there’s no difference in any compositor.)
But guess what? GTK 4 has regressed matters in this space. Fancy that. If I run gtk3-demo, as a tiled window it gets Sway SSD and an app header bar which duplicates the title (fine), but it doesn’t have the window border or shadow (good). When I float the window, it gets border (including top radii) and shadow. This is well-behaved software, not acting quite how I’d prefer it to (I want SSD even floating, even double-title-barring), but still reasonably. But gtk4-demo? It gets border and shadow (drawing outside its designated area even in tiling mode, and I’m not sure why it’s possible for it to do that) regardless of whether it’s floating or not. Progress. They’re forging ahead with ignoring the existence of SSD as far as possible even in GTK.
It’s possible it’s related to more recent changes in Sway. I haven’t updated Sway since March (since I’ve been using the high-DPI XWayland patches and updating is comparatively bothersome). I dunno.
Incidentally, I mostly use tabbed layout, and you’re always going to get server-side decorations out of that, since you’re breaking out of the rectangles mould.
They acknowledge that these are serious bugs but no one is willing to take on gtkfilechooserwidget.c anymore to fix it. So all filechoosers in gtk have been frozen broken since that time.
But GNOME/Redhat employees don't care. They switched to Gtk4 (where these bugs are fixed). All the programs depending on gtk3 can just rot according to them.
It’s funny to hear positive speech of GTK 4, though, because apart from the accessibility stuff (once it’s all finally hooked up) I don’t think I’ve heard a single positive thing about it, but only more discussion of things they’ve gutted and broken for non-GNOME environments (… including font rendering especially in Flatpak or whatever), and my experience from trying out rnote and gtk4-demo under Sway has not impressed me either—just more badly-forced CSD, new slow and poorly-designed animations (most notably focus, but also things like caret blink fading), and traditional menus are super ugly and apparently completely broken by keyboard (gtk4-demo; run the Builder demo; press Alt+F to open the File menu; marvel first at how access keys are no longer underlined until you further press Up/Down, clearly a bug; leave the menu by keyboard, either by activating an item or by pressing Escape; observe that now the keyboard does absolutely nothing of any sort until you click in the window again).
(And it’s easy finding more super obvious usability bugs. Compare the keyboard usability of the colour picker in the Pickers demo between gtk3-demo and gtk4-demo: they both get initial focus wrong, by keeping the Cancel/Select button focused if you clicked them and are reopening, but beyond that gtk3-demo is fine, while the gtk4-demo one has the wrong button as the default action when you press Space or Enter on an already-selected colour: it should obviously activate Select, but actually activates the Custom “+” button and then focuses the Cancel button. That suggests they’re modelling form controls in a somewhat weird way and made a fundamental change to the handling which will be responsible for bugs in a variety of similar places. And I can’t even be bothered filing any of this, but if anyone else wants to, feel free.)
How?
I use XFCE and I do not develope native linux apps, so I lack detail knowledge here - but as far as I understands it, GTK is developed for GNOME. It has even Gnome in the name. So of course they mainly care about - well, GNOME.
So knowing this, I simply would never choose GTk as a plattform for my software, if I would not intend to have it mainly in the GNOME universe.
(I would probably use something like Qt, which is explicitely not advertised as bound to one Desktop, but right now I rather stay with the WEB and avoid all of that).)
I mean, did GTK advertise itself as a universal linux toolkit and promised eternal support at some point? Then there might be a point of them being assholes, but even then it would not be sabotage, if they simply focus on their priorities.
It would be entirely something else, if the company Redhat would do all the changes by purpose to break other stuff to make people switch to Gnome. This would warrant the term sabotage - but the evidence I have seen so far is not convincing.
So maybe it rather was people using GTK because it worked "fairly platform-neutral" and then expected it stays that way? And then got mad, when developement direction changed?
So making demands of something they got for free?
Like I said, it might be free, but I do not intend to be bound to gnome(and I do not like GTK too much) so I will never use it for my apps. And people who did, probably have to switch - or fork it and adopt it to their needs.
Isn't this, what open source is about?
https://web.archive.org/web/20200207101350/https://www.gtk.o...
> Whereas, on Linux Wayland, if you want to support GNOME, _you_ have to care about decorations, or you have no titlebar nor X button
And you have basically two UI toolkits for linux that also does everything for you without caring about it, how is that different? Also, if you do decide against using said frameworks, you also have to care about accessibility and a million other things that you weren’t going to do either way let’s be honest, so I don’t know, it seems to be a non-issue to me.
Use libraries instead of reimplementing everything from scratch.
That isn't the case. There are several UI toolkits on Linux, they may not be as widespread as Qt and Gtk are, but they are used by many applications.
And even with Qt/Gtk, their developers (especially Gtk) regard each major version as a separate library.
GTK 2 was EOL'ed many years ago, and hence will never have Wayland support nor CSD. But there are dozens of existing applications in Debian's repos that still use it.
Wayland is going to have an X server for the foreseeable future, because otherwise the overwhelming majority of GUI applications for Linux will not run there.
MacOS has Carbon and Cocoa (and WebKit). QuartzCore lets you make windows, but doesn't give you decorations. Pretty similar to libwayland.
Windows has Win32 and while it does provide window decorations new UWP apps and thus the rather long list of various UI toolkits made by microsoft provide their own decorations. This is why dark mode doesn't work on some apps. So the situation is again pretty similar to libwayland.
Window decorations aren't even the same for different versions of Windows/macOS, so if you want to implement your own you'll end up providing multiple implementations for each platform.
The real difference is that there's a single entity with the will to go through each and every UI toolkit and update them all to look the same ahead of a new major version. That's not to say that server-side decorations are therefore bad; it's just that Microsoft and Apple put the resources behind client-side decorations to make them work as well as they do.
Carbon was deprecated well over a decade ago, and has not been available for several iterations of macOS.
> The real difference is that there's a single entity with the will to go through each and every UI toolkit
No, the real difference is that it is absolutely clear on macOS and Windows what the obvious/preferred/blessed UI toolkit is, and anyone who chooses to use something else is extremely aware of the consequences of that (and if they weren't before making that choice, they will be very soon afterwards).
On Linux, the situation is more or less the opposite. Not only do you have the choice of actual UI toolkit libraries, with none being more or less "blessed" than any other, but with Wayland's adoption, the fundamental windowing technology that sits on top of the video drivers is also not a single thing either.
Microsoft has widgets in WinAPI, and then there's WinForms, WPF, WinUI, WinJS and don't forget Electron which Microsoft themselves also ship apps with. There's also the whole win32 & UWP distinction. If you dig deep enough into the system settings you'll even find Dialogs that use the wrong window decorations.
I never even had to think about making the window controls appear, they were just there by default when I created a window.
If I eventually want to extend support to Wayland / Gnome I need to figure out how to pull in complex UI framework dependencies. Or I could write my own code to render window controls but it won't be a perfect match to the platform's aesthetic. Compared to Windows / MacOS it's a mess.
With Gnome it seems unclear how to do something equally simple to get decorations that match the OS look and feel. The most popular Rust windowing library ended up implementing their own client-side decorations rendering that imitates GTK: https://github.com/rust-windowing/winit/pull/2263.
And if every framework / app is doing this in their own subtly different way then the result is an OS where many apps have slightly different UX, buttons, text rendering, shadows, etc. A horribly unpolished experience.
output eDP-1 scale 1.5
seat seat0 xcursor_theme Adwaita 96
Other than MacOS, kinda sorta, this just isn’t true and hasn’t been so for years.
It takes large engineering work to write all the software, and needs discipline and people working on very boring areas and aspects of the UI. I find it unlikely any OSS community will ever pull it off, unless there is a clear monetary incentive to fund it and work hard.
The Linux desktop needs a leader figure. A Steve Jobs, or a Linus Torvalds.
Leave it to the community, and everybody wants to reinvent the wheel and paint it their favourite colour. Directed innovation can only be achieved from a single vantage point, not by a committee, let alone a ragtag of independent actors.
And regular for profit companies aren't incompatible with Linux. Canonical, Red Hat, etc. make billions from open source.
Let me stress this again: the only reason the Linux desktop sucks is organizational. Not monetary, not technological. Linux would be a niche project today if Linus had been replaced by a committee or other loose organization. The Linux kernel is successful because there is a person at the top saying "No."
The Linux desktop has no such thing. None of the singular desktop environment have such a thing. GNOME has no BDFL, nor does KDE. So its endless bikeshedding and churning and going nowhere.
Right confluence of factors to a large extent. GNU needed a kernel, and BSD was mired in legal trouble. Linux was there at the right time to provide a GNU-friendly kernel made from scratch.
I think the GPL was also a fortunate choice. It ensured large companies couldn't easily have a closed in-house version and had incentives to contribute to the common good.
I think you mean https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin...
Point is, it's Linus that merges what he wants in his tree. The kernel development isn't a democratic process, not everything has to be. Everybody can fork it and be the big boss themselves, the fact that nobody and no company has succeeded in doing so is worth thinking about.
You will find -- unsurprisingly -- that most of them are not contributing for free.
That's not to say there aren't people contributing code written in their spare time. I'm one of them (but not completely: there's stuff I wrote on my own, and submitted in my own name, and also a bunch of stuff I wrote on the job). But the vast majority of people contributing critical code are not doing it for free, and haven't been doing it for free for a very, very long time. Unpaid contributions are the exception, rather than the norm.
How does that invalidate my point? GP asked why people would contribute to leader-directed open source without coercion. I just pointed out no coercion is needed. Free or paid is irrelevant.
> How do you propose that people work *for free* at the behest of a leader directing such unpaid contributors how to o their work?
(Emphasis mine)
No coercion is involved, but they don't work for free, either. Free vs. paid is extremely relevant. If you were to strip out the paid contributions from the driver tree, for example, you'd be left with a handful of drivers, virtually none of which cover non-trivial devices released in the last fifteen years or so with anything near full functionality.
Is that a meaningful distinction? I don't think the point was that the people actually writing the code aren't paid, but rather it still holds when you consider that the people paying them choose to allocate those efforts to a dictatorial organization rather than addressing their goals in some other way.
Lamentably I think you are right. Although to be fair I'm using linux as my daily driver and it works great (PopOS X11 still...) Though I fear adding extra confusion to writing desktop linux apps isn't going to help things get better.
I would like to write some applications for linux when my work life ends, but there seems to be a dozen different ways to do it. A ton of choices to make I don't fully understand, but I really don't want to have to know the nuances of the windowing system to be able to write something that works well with KDE and Gnome, Qt, GTK and whatever else one needs to know about compositors... A lot of stuff is web based now and linux handles that great, but desktop apps still have a place.
I feel like sometimes being the "best" platform doesn't matter so much as being able to target most distros with less work would help the ecosystem a ton. Using Linux as my daily driver so hope springs eternal.
Developers! developers! developers!
FWIW, if you use Qt, your app will look and work good pretty much everywhere, excepting if you want to integrate deeply with the shell. But for most apps it's not an issue.
I'm optimistic and hopeful regarding newer GTK. It seems to be modernizing nicely, though I haven't actually written an app in it yet.
If I could wish for one thing for Linux though, it would be a great toolkit to target it that also makes distribution a breeze. That it is still an unsolved problem causes me pain.
It affects anything which put any sort of strain on the compositor. A hi poll-rate mouse also trigger the issue simply because there will be more resize events. Why gnome-shell doesn't apply some sort of back-pressure or opportunistic skipping of events when it is behind is beyond my understanding.
Does GTK not manage the decorations for you?
Are you sure about this? How would things like appending "Not responding" to title bar work?
Win32 has always defaulted to server-side decorations, by which we mean that the window manager controls the rendering, appearance and functionality of the title bar. Maybe this is actually run in client space via user32.dll or whatever as part of the OS-managed event loop, but functionally your app gets told “here, have a client area” (and isn’t that name telling!) and works inside that and completely ignores the remainder of the window area, and the window decorations implementation is provided by the window manager, so that theme changes (ancient Classic, XP Luna, recent Classic, Aero Glass, Modern, colours within each, &c. &c.) immediately apply globally.
This is what people mean by server-side decorations. They mean what is still the default under Win32 and I presume macOS, even if on both platforms it’s not the recommended style any more for most apps.
But it’s also worth noting that the recommended client-side decorations style on Win32 at least (don’t know much about macOS) is still guided by window manager stylistic conventions, including theme colours where possible.
In the Wayland/Xorg world, server-side decorations means its drawn by the compositor or display server, neither macOS or Windows do this.
Windows is a lot more complicated, the decorations are drawn by the client... but that client is part of the userspace dll from the system you link to in your app and gives you a handle to draw on.
macOS the only documented method to draw afaik is through Cocoa which can give you a space to draw on, but the linked Cocoa library will still draw your apps window.
To the user, I guess SSD achieve the same thing as Windows/macOS do, but with very different methods because unlike macOS and Windows, there's no central toolkit/library.
> Both win32 and macos draw decorations client-side
Which is why on linux if a process freezes I can kill it by pressing the normal X on the window, while on other operating systems I need to open the process manager.
Server-side decoration made things more modular because it allowed the window decorator to be an entirely independent process. It could allow to use Beryl or kwin or any other window decorator with compiz, for example. Even considering these advantages, the price one paid for it was too expensive to justify. X11 did it, basically nobody else did; certainly for a good reason.
Server-side decoration is one thing I'm glad we are finally getting rid of.
In this case: they’ve taken something that used to work across the board under X, and which is still used extensively, and for which there have been a number of well-reasoned pleas, and actively removed it by refusing to implement it under Wayland, although it should be fairly straightforward to do and is required for a parity that a great many apps and users desire and some apps need, and although not doing it forces apps that don’t (perhaps can’t) use GTK and don’t need client-side decorations to produce worse results. (And requiring GTK is nasty for non-GNOME apps anyway.)
It's not surprising they're in no rush to throw that out.
GNOME has the unenviable position where everybody wants to use it —cite: we are— but we all still love to bitch about it. If it were so bad, we'd have jumped ship, or stayed with Mate or Cinnamon or whatever the 2.x branch was called.
I guess from our point of view, we feel a little like hostages and just because we don't like these changes, doesn't mean we want to migrate to another desktop; still, I cannot ignore that I'm paying nothing for the maintenance and development of this system and I'm not investing my time in its development or governance, so frankly who am I to say what should be what?
So far cinnamon has mostly been able to roll back the worst of the changes, and I haven't had many complaints. But the push to do things like encourage every piece of software to draw its UI into the window decorations isn't something cinnamon can fix... they'd have to fork the world.
As a user I find this frustrating because I actually wouldn't mind some consolidation in Linux, especially in the GUI layers, but tend to hate RedHat's taste in these matters.
And how exactly was any of it an embrace? Redhat was a Linux distribution provider from the start, they didn't take something over in order to destroy it. They just created systemd and provided help to distributions if they were willing to use it.
The distributions were fully aware what they were doing when they abandoned Sysvinit, it wasn't a backhanded tactic by redhat.
A recent example of something close to EEE is vscode, which is now getting "refactored" to utilize non-open source plug-ins for everything, effectively extinguishing it from a free perspective.
1. Embrace: Development of software substantially compatible with a competing product, or implementing a public standard.
2. Extend: Addition and promotion of features not supported by the competing product or part of the standard, creating interoperability problems for customers who try to use the "simple" standard.
3. Extinguish: When extensions become a de facto standard because of their dominant market share, they marginalize competitors that do not or cannot support the new extensions.
Systemd is part of "Extend", and what they're extending is the linux ecosystem. Sure, those extensions might make things better in the short term and for some uses cases, but they're now owned by IBM so good luck!
Redhat didn't embrace a competing product, redhat has been a Linux distribution from the start.
They extended it by adding systemd, yes. I said as much before too.
They didn't extinguish Linux as their extension continues to be open source and ready to fork.
If you're going to argue from the perspective of sysvinit instead then neither embrace nor extend happened. Whatever redhats goal were, it wasn't EEE
Yes, and I think it's pretty obvious to anyone who is familiar with the history. EEE is about a set of anti-competitive practices, ones that are definitely and obviously being used here. Whether they do that with malice aforethought is unknown, and nothing there is illegal by itself, but it is a pretty clear thing they're doing.
Microsoft didn't embrace office document editing software, microsoft word was one of the first document editing suites. And yet that is one of the examples in the wikipedia article: https://en.wikipedia.org/wiki/Embrace,_extend,_and_extinguis...
Did microsoft extinguish document editing software? No, they just used their market position to make sure that their implementation was the most dominant.
Another key example is "Breaking Java's portability". Do you want to talk about how the move to systemd has effected the various BSDs? Here's a talk about it: https://papers.freebsd.org/2018/bsdcan/rice-the_tragedy_of_s...
But the one qualifying bit for the EEE strategy to work is to remove the open source option, replacing it with something that can only be provided by them. And systemd is open source as far as I know, So the extinguish phase isn't possible in that sense.
Well if that's the definition you're using, why are we even talking? 6 comments deep and you're only now bringing up that by the definition you're using only proprietary software can use EEE? That's a pretty big point, and probably should have been brought up in comment number 1.
Like what are you even talking about if you're just bringing that up now?
And I mean sure, define EEE in a way so that it can only apply to proprietary software. However in my first comment I said this: "The fact that the underlying code is open source apparently doesn't matter too much."
Personally, I think you can use the techniques of EEE to get control of an open source project, and whether your alternative is open source or not doesn't really matter since what it's actually about is control. Making sure the open source community treats your solution as the de-facto standard, making sure that your solution with all it's eccentric little commands is the one taught in schools, selling ad-on projects like log-collections daemons and making it harder for your competitors to do the same.
https://slatestarcodex.com/2014/11/21/the-categories-were-ma...
EEE is descriptive of what's happening, it's not prescriptive. If you'd like I can say that "redhat is doing stuff that looks a lot like EEE except for this list of caveats which make it slightly different from these other cases, but not different from these cases". But if we're done debating definitions we can talk about the actual behavior I find objectionable, but that's all pretty well documented in other places.
And no, it's not descriptive of what is happening. Systemd was disruptive, yes. But not all disruptive things are EEE.
I'd agree with that, there are no rock solid definitions we're going to agree on. Still, there are a number of places where a small concession from Redhat would have made other people's lives a lot easier. See also, this very thread and support for server-side-decorators. A decision made by someone directly employed by Redhat.
Innovation without compromise that significantly impacts downstream software, and where patches aren't accepted. That looks a lot like using a market position to unduly influence other projects to me, and they'd get a lot more sympathy if they at least said "pull requests welcome" or if Redhat paid an engineer to make libdecor less awful. (Note that redhat is also paying developers for libdecor development work)
There are a lot more examples like that floating around.
And I completely agree with that. I just took an issue with the EEE reference
And systemd is controversial in that a vocal minority says it was a disaster. I don't think it is, definitely not compared to Wayland.
> And systemd is controversial in that a vocal minority says it was a disaster.
Not a minority, and some of the loudest voices are the experts whos opinions matter most.
I am one such expert. Most technical people I speak with about systemd are largely ignorant as to the design considerations.
The only people who have problem with systemd is “old-timers” that just refuse to learn anything new, and just blindly believe that the old status quo was better.
Engineering reliable systems often means reducing complexity. A major unaddressed complaint regarding systemd is that there actually isn't a need for dependency resolution during startup, at all. Dependency resolution is very complex and introducing it makes testing changes far more difficult. It is not a desirable feature for most server applications where reducing complexity and increasing operational visibility take precedence.
> The only people who have problem with systemd is “old-timers”
You may be confusing experience with age. The two are related but they are not the same.
> that just refuse to learn anything new, and just blindly believe that the old status quo was better.
This is just silly. There are all sorts of wonderful features related to containerization, cgroups for job control, structured invocation for processes, etc.
The primary issue with systemd isn't that any of these features are bad. The issue is that they have been conflated in a mostly unspecified, monolithic system which discourages composition, inspection, and simplified operation.
It's a big ball of mud architecture. You can't use the service invocation components standalone. You can't use the RC components standalone. You can't use the init components standalone. All of these things should be possible, but aren't, and that is the core issue.
What I compare systemd to is the previous iterations of linux init systems, and compared to them it is a huge positive change in my, and most of the linux world’s opinion (it was voted on multiple times in probably the most democratic process at debian, was decided independently at several other distro). It solves real problems (e.g. pre-disk mount logging) in a relatively modular way, and I think we should cut some slack here, because often times in complex problem domains a monolith is the correct choice. Multiple different tools will actually result in more complexity due to coordination, and I would go as far as that was part of the problem with previous init systems.
May I ask you what would be your preferred solution in place of dependency resolution at runtime then? I do agree that it is “one more moving part”, I just fail to see how else could it work.
* It ensures changes can be audited, observed and tracked (or caught and prohibited). Explicit change control points are key.
* It provides an interface and an option, divorcing the dependency tool from the system which invokes the ordering
* Ordered sequential steps takes longer, but adds determinism. It enormously simplifies the startup process, including auditing where things go wrong in logs after the fact. For servers, this is far more important than lower start times.
Most systems end up with a distro/systemd controlled base and a custom application on top. Often there's all kinds of special harness around the application, far beyond what can be fit into systemd. So there's always necessary duplication and struggles around interfacing different kinds of systems.
For custom applications, I tend to advise that the development team first come up with the success criteria for their app. What conditions would they page on, and what runtime dependencies does their app need? (Databases, up to date feeds, kill switches/feature flags, etc). I suggest that they re-use their monitoring code to also control orchestration of service startup. For example, not starting a front-end app unless a connection check to a backend SQL server passes. In these cases, the orchestration may be significantly more complex than what can be performed inside of systemd -- and this is part of why a clean and extensible interface is so important.
Talk is easy, building something that works for the majority is hard. And one thing for sure is that not everyone will be pleased
X11 was very much a "everything is a work-in-progress" culture. Experiments were fine, clients and servers could support whatever they wanted, etc, etc.
Wayland is an "opinionated" culture. Everything the core devs don't like is not allowed.
Everything HAS to fit into the "every frame is perfect" mantra. Which is ridiculous over-engineering and disallows a large number of perfectly acceptable (to end users) use-cases.
When it comes to wide appeal, linux suffers from paradox of choice on multiple levels. But there are a huge number of people who want the stability of windows/mac/etc without the violation of privacy, as long as they don't have to spend ANY time configuring their system to keep it working. To them, just like fixing their car, that's someone else' job/hobby that they don't have time for or get any enjoyment from.
I don't see any reason why Linux can't offer that experience, but only if we have a windowing stack that is very opinionated about the user experience. Maybe it's time for an X12, but the Valves out there trying to make a competitive experience on linux for consumers will be dumping their money into Wayland.
False.
If your use case is so important nothing prevents you from making your own protocol and implementing client and compositor support for it. It's exactly the same as X.
(Note for those unfamiliar: I'm not saying "make a replacement for Wayland". Wayland is a collection of protocols that define one or more objects and the formats of their requests / responses / events. Showing windows is part of the xdg-shell protocol, etc.)
But if you actually want to __use__ your extension/protocol with someone else, it needs to get accepted into various core libs and repositories.
....And then the gatekeepers step up and your problems start.
>>and implementing client and compositor support for it. It's exactly the same as X.
And if you think the GNOME and KDE and wlroots maintainers are all in some grand conspiracy, you are either very naively mistaken or just being toxic. Given you discarded a whole body of work as "ridiculously over-engineered" while contributing nothing except whinging, I'm inclined towards the latter.
Feel free to fork even one compositor and one client program to implement your amazing protocol.
Not quite the same. X11 (notably the xfree86 project which maintained things for the last decade or so), was always quite free-wheeling about allowing things. They subscribed to something similar to the linux kernels approach of "mechanism, not policy".
No, I don't think there is any conspiracy. Nor do I think they are bad people.
Nor do I think the whole thing is over-engineered. It's mostly pretty impressive.
Wayland was literally made with the explicit intent of providing extensions and they are a core part of the protocol — a client app is free to query the available protocols with versions, while there was nothing similar to that under X.
And really, “every frame is perfect” of a display manager managing.. frames is somehow strange? Would it be strange for a video player as well?
Every frame is perfect requires extreme amounts of coordination. Frequently multiple buffering, which increases latency and increases latency. All these are costs which most use-cases don't care about.
Under normal conditions, with display managers that don't care, frames are extremely rarely "not perfect". And when they aren't perfect they are seldom "not perfect" for more than a single frame.
This is a fine example of "the perfect is the enemy of the good"
Did you try viewing a full screen video on X without a compositor? Even though today’s video hardware is indeed fast enough to mask it more often than not, display technology also requires more and more resources — I am sure you will find plenty of tearing at larger than 1080p resolution and higher framerate.
And come on, how is it extreme amounts of coordination? That’s like the most basic coordination there is. Especially that it can be circumvented in the rare case it is not needed — e.g. game windows in full screen can render at their heart’s content.
Wat. https://www.x.org/releases/X11R7.5/doc/man/man3/XQueryExtens...
X is full of extensions. Even extensions that the server does not need to worry about, e.g. EWMH [0] because the protocol is flexible enough to support that.
[0] https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.h...
Specifically that the client code is allowed to customize _most_ of the headerbar, with the exception of an area reserved for the window controls (minimize, maximize, close, etc).
It seems like this approach would still support alternate or tiling window managers as they could omit or provide custom window controls.
[1] https://blogs.windows.com/msedgedev/2022/09/27/closing-pixel...
I’ve thought of trying to design something like this for Wayland server-side decorations or at least making a better replacement for libdecor, but it wouldn’t help me personally and it’s clear that GNOME isn’t having a bar of the entire approach, so I sadly just don’t think it’s worth the effort.
python3 seems to have finally pulled through via deprecation.
I'm pretty convinced at this point IPv6 is going to be de facto replaced with SNI routing. You pretty much have to use TLS anyway.
Platform-level software updates are fascinating.
Maybe server side, but client side addition is up to 40% now. IoT is only going to drive it higher.
Nobody is going to depreciate x11. It's been 3 years since Red Hat said x11 is going into "hard maintenance mode" but here we are.
I'd love to be optimistic about the adoption of Wayland (I'm now using it myself on my gaming rig), but I have zero reason to believe that everyone will eventually use Wayland. x11 is simply more finished and robust.
It is in hard maintenance mode though (and 3 years is not that long). Although X11-the-protocol isn't going anywhere, X11-the-server has no real future. Mind you, "maintenance mode" does not mean "abandoned", but it also means that it's not really going to evolve and improve - it will effectively just stay where it is for people who may still have to rely on it. Changes in Xorg codebases are very rare these days and most of them are related to XWayland.
Of course in practice there will be differences, but they shouldn't be large.
I’m sure the little fiddly bits are still done how they always were because it has to work across all the different windowing libs.