Skip Navigation
126 comments

  • Back in the day X was a great protocol that reflected the needs of the time.

    1. Applications asked it to draw some lines and text.
    2. It sent input events to applications.

    People also wanted to customize how their windows were laid out more flexibly. So the window manager appeared. This would move all of your windows around for you and provide some global shortcuts for things.

    Then graphics got more complicated. All of a sudden the simple drawing primitives of X weren't sufficient. Other than lines, text and rectangles applications wanted gradients, rounded corners and to display rich graphics. So now instead of using all of these fancy drawing APIs they were just uploading big bitmaps to the X server. At this point 1/3 of what the X server was previously doing became obsolete.

    Next people wanted fancy effects and transparency (like drop shadows). So window managers started compositing the display. This is great but now they need more control than just moving windows around on the display in case they are warped, rendered somewhere slightly differently or on a different workspace. So now all input events go first from X to the window manager, then back to X, then to the application. Also output needs to be processed by the window manager, so it is sent from the client to X, then to the window manager, then the composited output is sent to X. So another 1/3 of what X was doing became obsolete.

    So now what is the X server doing:

    1. Outputting the composited image to the display.
    2. Receiving input from input devices.
    3. Shuffling messages and graphics between the window manager and applications.

    It turns out that 1 and 2 have got vastly simpler over the years, and can now basically be solved by a few libraries. 3 is just overhead (especially if you are trying to use X over a network because input and output need to make multiple round-trips each).

    So 1 and 2 turned into libraries and 3 was just removed. Basically this made the X server disappear. Now the window manager just directly read input and displayed output usually using some common libraries.

    Now removing the X server is a breaking change, so it was a great time to rethink a lot of decisions. Some of the highlights are:

    1. Accessing other applications information (output and input capture) requires explicit permission. This is a key piece to sandboxing applications.
    2. Organize the system around frames to avoid tearing except for when desired (X doesn't really have the concept of a frame).
    3. Remove lots of basically unused APIs like fonts, drawing and many others.

    So the future is great. Simpler, faster, more secure and more extensible. However getting there takes time.

    This was also slowed down by some people trying to resist some features that X had (such as applications being able to position themselves). And with a few examples like that it can be impossible to make a nice port of an application to Wayland. However over time these features are being added and these days most applications have good Wayland support.

    • Saving this for later -- what a fantastic breakdown. Thanks for this!

    • Wow this is such a good comment. Very helpful. I wish Lemmy had a "super upvote" where I could upvote it several times.

  • There's a very nice (albeit somewhat outdated) talk here.

    In a nutshell, both X11 and Wayland are protocols that define how software should communicate to (hopefully) display stuff on your screen.
    Protocols as in there's a bunch of documentation somewhere that says which function a program must call to create a window, without specifying how either program or function should be implemented.
    This is great because it allows for independently written software to be magically compatible.

    X11 is the older protocol, and was working fine good enough for many years, but has issues handling a bunch of modern in-deman technologies - issues which can't be fixed without changing the protocol in a way that would make it incompatible with existing software (which is the entire point).
    Plus its most used implementation - Xorg, consists of a huge and complex codebase that fewer and fewer people are willing to deal with.

    Wayland is the newer protocol, that mostly does the exact same thing, but better, in a way that allows for newer tech, and completely breaks compatibility in order to do so.

    The trouble with the whole situation was that in order to replace X with Wayland basically the entire Linux graphics stack had to be rewritten - and it was, with raging debates and flame wars and Nvidia being lame.
    They also wrote a compatibility layer called Xwayland that lets you keep using older X-only apps which somehow manages to outperform Xorg.

    Now we're at the point where major distributions are not only switching to Wayland by default, but also dropping support for Xorg completely, and announcing that they'll no longer maintain it, which is why posts about it keep popping up.

    • Here is an alternative Piped link(s):

      here

      Piped is a privacy-respecting open-source alternative frontend to YouTube.

      I'm open-source; check me out at GitHub.

  • unless you are a developer, there’s not a whole lot to worry about – you’ll switch from one to the other when your distro switches and, chances are, you’ll never notice

    the drama comes from the fact that the Linux community loves choices (and arguing over those choices) and, as @skullgiver points out, most of the choices have fallen by the wayside over the years

  • x is slow and dumb but the standard, wayland is fast and based but still being worked on

  • X is old and works for the most part but fixing stuff or adding features is hard.

    Wayland is new and is supposed to be a successor to X, do what it couldn't do and don't repeat the mistakes from it. It should be a drop-in replacement like pipewire but isn't. Features take long time to develop as devs are engrossed thinking of the best solution to make it happen. A lot of proposed solutions are dismissed as well.

    • I think the drama around Wayland can be explained by the sentence “it should be a drop-in replacement like pipewire but isn’t”.

      Without taking a side on that issue, I will point out that this was not a goal for the Wayland designers ( in their own words - I do not have time to go find a quote but have read this sentiment many times ). Wayland detractors agree with your sentence and, given that expectation, are legitimately upset and even confused that Wayland continues to gain mind and market share against X11.

      If you feel that Wayland needs to be a drop-in replacement for X11, it is not ready and may never be. By that metric, some people see Wayland as a failed technology and perceive Wayland users as shills and zealots.

      If you are interested in a display server that addresses some of the core design problems in X11 and do not mind moving to something new, Wayland is starting to look ready for prime-time.

      If you are non-technical and / or unopinionated the debate is probably irrelevant. Wayland will most likely become the default on whatever Linux distribution you use sometime in 2024 or 2025. You will be a Wayland user. Maybe you already are.

      If you are willing to step outside the mainstream, using X11 without Wayland is going to be possible for at least another decade. That said, I am saying “outside the mainstream” because not only will popular Linux distributions and desktop environments start to become Wayland only but the innovation is all going to move to Wayland. There will be many Wayland-only compositors, apps, and features. 5 years from now, not using Wayland is going to really limit the desktop experience. I expect some toolkits ( GTK, Qt, and maybe even WINE ) to drop X11 support at some point ( maybe not soon but sooner than 10 years maybe ). 5 - 10 years may seem like a long time but it will likely come faster than X11 stalwarts expect.

  • X/X11 is a client-server protocol from the age of 10Mbps networks, intended for a bunch of "dumb terminals" connected to a mainframe that runs the apps, with several "optimizations" that over time have become useless cruft.

    Wayland is a local machine display system, intended for computers capable of running apps on the same machine as the display (aka: about everything for the past 30 years).

    Nowadays, it makes more sense to have a Wayland system (with some RDP app if needed), than an X11 system with a bunch of hacks and cruft that only makes everything slower and harder to maintain. An X11 server app acting as a "dumb terminal", can still be run on a Wayland system to display X11 client apps if needed.

    • RDP is not a replacement for individual remote apps, btw, just saying. RDP is a full remote desktop, like VNC.

  • X is old and very hard to maintain. A lot of rules about how displays work have changed drastically since X became a thing. X went along with most of those changes, which meant the introduction of more and more hacks to keep it running.

    Over time X became worse and worse to work on and people realized that it's easier to write something new from scratch instead of trying to fix the decade-old technical debt in X.

    That new thing was Wayland and over time most if not all people that where interested in working on desktop compositing pivoted away from X.

    Wayland (as it is always the case with new software of that size) didn't hit the ground running. It had various issues at the beginning and also follows a different desig philosophy than X.

    Despite a lot of issues being fixed some people are still very vocal about not wanting to use wayland for one reason or another. While some of those reasons are valid, most come from ignorance or laziness to adapt.

  • I don’t see a real „versus“ here. Wayland will definitely become the standard display server for Linux distributions. This is not sysV init vs systemd or something else. As pointed out by lots of ppl here X11 is old and insecure because it is from another time and does not fit into modern systems and requirements, thus it is way easier to start new and fresh instead of working around for any feature needed and maintain such a old code base. The only downside for me personally is that Wayland does not support always on top windows automatically. So either right click the window or use plugins for videos from Firefox for example. AFAIK this is also for security reasons. I run Wayland on my main machine for years now, no problems at all. If I got the choice I would always go for Wayland. Even Cinnamon has experimental Wayland support now and hopefully will make the switch soon.

126 comments