[Correction repost - minor wording/grammar errors and confusing explanations in previous version also sent to [email protected]]
Hello everyone, I go by the username SuperStarHD725, I was a long time Windows user until I got to try Arch Linux, at first as merely a hobby and a way to learn Linux rather than even considering to commit to a full switch (reason it was Arch Linux out of other distros is because I figured that using a user friendly distro wouldn't lead me to learn anything), and by the end of setting everything up I realized Linux is as fully functional a desktop system as Windows is, with the important exception of actually being able to control and openly observe my environment and the code that helps it run. Naturally this urged me to make a permanent switch to Linux and start learning its fundamentals and the way it functions. Along the way of learning about Linux, I saw something that caught my attention. Display server protocols. Reason it caught my attention is, not only because I realized all of my fancy GUI, screen rendering and input detection ran through it, but also me finding out about a seemingly never ending debate between two major display server protocols that has lasted over a decade now, what I am referring to is the X11 (X Window System) versus Wayland debate. Upon inspection of both I have come to the conclusion both have some advantages over the other, but also problems, and each one has those advantages and problems in such a way that they are essentially polar opposites: On one side we have X11, unrestrictive, standardized, easy to interact with, but with a fatal flaw of equal trust of all of its clients leaving it prone to malicious attacks such as privilege escalation via macros, forced screen overlays that can't be taken off without a clean reinstall, keylogging and capturing of screen and individual apps. On the other side we have Wayland, secure and sandboxed, with new technologies and modern rendering solutions, but it has excessive sandboxing with no way to disable it in order to allow for communication between clients (apps), a lack of standardization and also an inability to use any direct injection tools when needed (like hardware level emulated macros for specific needs like gaming), almost like it decides the user is inherently incompetent with no chance of appeal. To that I say, there is no need to reinvent the wheel, merely upgrade it, we didn't remake the wooden wheel, we made it into a durable metal frame and put a tire on for traction. Cue my potential proposition, X12, the direct successor to X11, which brings X Window System to a modern era of computers, solving both problems of X11 and Wayland. X12 has 2 major problems to solve, lack of modern rendering features and insecure and unrestricted access of server to clients, and also the solutions to them: 1. Modern rendering implementation: - VSync, compositing, fractional scaling and HiDPI — all need to be native, not bolted on as hacks - Per monitor scaling — so a high res laptop screen can be at 150% while an external monitor is at 100% - HDR and proper color profile support - Better touch and gesture support — built in from the start rather than through extensions - Client side rendering — apps manage their own render buffer, compositor combines them, lower latency than X11's central server model - Direct rendering pipeline — apps talk straight to the compositor cutting out unnecessary layers (Side note: albeit I am embarrassed to say this, I have less knowledge and focus on the rendering side of fixes, but even then I still encourage and request help from others to help find a way to implement these fixes and more) 2. Hierarchical client permission: Instead of giving every client equal permission, split them into three levels: - Full (root) access: allow full access to the client by skipping any checks and running as root, used for only programs you trust and that need it (eg. hardware level macro emulation/auto clickers) - User (non-root) level access: allow as much access as the user has permissions (eg. probably should use the user>group>other (aka RWX) hierarchy as an automatic reference) - Sandboxed (restricted) access: client only gets access to itself (meaning can only see its own windows, logs, and can only modify itself) Notes: - Because the system is hierarchical, so are permissions: sandbox only interacts with itself, including log reading, user can read logs, see and interact with sandboxed and user level apps in their own userspace, root can read, see and interact with anything (note: if a sandbox permission level client is running under root you still need to be root or sudo for direct access) - For full (root access): because it can be allowed to run as root, when the request is sent to run it as root (either by app or by user), the user will be prompted for their own password (if in group "wheel"), or the root password itself. Extra side notes may include just being able to modularly add and remove (at least some of) the solutions mentioned in 1. (my reason for this is to avoid the whole "systemd is bloated" type of debate by allowing the proposed X12 to optionally install these features, as to allow users who wish to not use the features listed in 1., for one reason or another, keeping it relatively modular and lightweight, just like its predecessor), other than that this is my suggestion for an upgrade that may revolutionize Linux GUI environments entirely, with the obvious help of the X.Org foundation of course. I hope with my suggestion that we will be able to bring Linux even closer to a new age.
