The protocol is round-trip heavy. Even with xcb, X clients need to make a tremendous number of round-trips, especially early on. There have been mitigations for X for low bandwidth links, but X networking has never been usable on high latency links. Ever forward X on an airplane? I pity you.
The drawing model of X is an antiquated relic. Server side rendering is pretty much useless, such that X has basically become a sort of bastardized inefficient VNC.
There's a reason no widely used screen remoting or thin-client system uses the X design. It was a poor idea then, and it is still deficient today.
The people who created X thought multi user graphical computing all the way through.
We may decide that should not be a thing.
I think we will struggle, some time will pass, and then it will be a thing, meaning X will just get reinvented.
What I really mean by "reinvent" is the multi-user graphical computing model itself.
We've done a stellar job pushing a desktop out to someone. I've used a variety of these things, from the basic VNC on up, and they are pretty great. The better ones are damn tough to differentiate from local UX. People are running CAD on stuff like Citrix and it works. Better than one might expect too.
That's more like plucking out the killer use case and optimizing it. Great move, worth it, not bad, etc...
There are a lot of ways to use computers, and applications though.
X, warts and all, did offer up pretty fantastic flexibility and usability (when apps were well realized).
A few things:
Today we've got cloud computing, local computing, mobile computing, wearables. Lots of displays, more coming.
Thinking about it from the X POV, sort of how they thought about it back then, that looks an awful lot like:
Application server, desktop computer, other computer. They envisioned more than one person using a single computer. Multiple people using multiple computers, multiple people using modest computers to do UX with one or more powerful ones.
And on that point, I used to use multiple powerful computers with a single modest one all the time.
Maybe rethinking it again, like they did with X back in the day, would push the boundaries some. Who knows what people would do?
Someone walks into a room, has presentation on their wearable, and pushes it's display to a nearby machine, or both display and UX. They keep their data where it lives, on their device, but can benefit from the more robust UX.
Mobile computing devices are getting really powerful. Run an app on one from a laptop, easily, again, perhaps keeping data local to the mobile, for whatever reasons.
Just spitballing here, but the general thought I was trying to convey, without realizing it earlier, is maybe rethinking things from the basics forward, allowing for a lot of options, possible options, just might shake out other ways to do things, use all these crazy devices.
Or not, just musing.
It blows away x11 forwarding.
https://xpra.org/ is a vastly superior solution for linux servers.
Don't miss remote X a single minute.
I like X. Took me a while to understand it, but once I did, I used it hard and appreciated what it allowed me to do.
Doing stuff like dual or multi head computers. Multi users each with their own keyboard and mouse can happen with X. And if one needs another user, doing it via network just works.
X is a powerful thing.
This should be possible with virtio-wayland:
https://alyssa.is/using-virtio-wl/
It's pretty new and not used outside of Chrome OS (to run Linux apps) at the moment though.
Today, it is a game of which pieces make the most sense, and whether multi user graphical computing should be a thing.
We know it can. X did all that.
Should it?
I can't speak for all the original X developers but TFA seems to suggest that they didn't think it all through.
Currently, it's not. That does not make current efforts bad. I think they are quite nice.
They just do not yet actualize the vision X did and does today.
Whether that is wanted / needed is also an open discussion at this time.
As far as I can tell, the original vision of X was to unify all the proprietary Unix vendors with a standard windowing protocol. The network capabilities happened because they wanted to support dumb terminals connected to mainframes. Most of those proprietary Unix vendors are now gone. Currently it's not clear to me what role X is supposed to have, if any.
We may find or choose for that to not be a thing.
Ok, fine.
The X window people did make that a thing and the end result is powerful and flexible.
None of that makes efforts like Wayland bad. They aren't.
But they, by your own definition, are a subset of what X is too. They aren't thinking it through, by design. That is OK.
My own personal take is that most compositors won't because X does not represent multi user graphical computing in the way that most people use it today. That role is fulfilled by web applications.
The next best alternative currently is looking glass[0]. Linux host with GPU1, Windows guest with GPU2 via pass-through and then copy the framebuffer from the guest to the host.
I would have loved to profile that little system. It's crazy how lean those older systems really were.
A 30Mhz R4K could play MP3 files streamed via NFS. (90 percent CPU utilization, not headless, with local desktop logged in and active) I had one, at that clock useless by the time I got it, doing just that, because why not? After reading your comment, I realize I had a machine just playing a compressed audio file with the resources needed to serve 20 of you a useful computing environment!
What kind of network were you on? Was it even ethernet? 10T?
My first multi-user experience was horrible! It was on a 386/25, running Xenix and it had capacity for 16 users via either 19200 or 9600 baud SERIAL and VT100 terminals... I had 12 users at peak on that one, and most of them ran multi-user WordPerfect and some MRP thing, Symix, I think.
I got the job because I read all the manuals. First sysadmin post and it was a pig. Learned a ton though! Enough to realize I could have a lot of fun on the better UNIXes, and scored a position working with SGI computers.
(in that timeframe those computers with all the spiffy software so well engineered were like computing from the future, so much fun)
Another time, while doing sysadmin on an SGI Irix multi-cpu Origin system serving some 30 users doing high end cad, I did some data logging.
That system had 16GB Ram, 4 R12K CPU's with super fat caches, dual homed 1000T ethernet, BTW. I forget the clock. Probably 400Mhz
I logged user activity every few seconds for roughly a week. This was an effort to see whether overall system speed was impacting productivity. I had a few users grumble during a peak time, so...
Learned a few things:
The system itself could perform near max capability when there were 4 concurrent user CAD demands. OS overhead was a few percent tops, in almost all circumstances. This was not in of itself any kind of issue. Irix ran pretty damn lean.
Once in a blue moon, the system would page, but the Irix file caches are gold. This never really was an issue either. Maybe for a few minutes at a time during a serious push tops.
A few times per week, usually on a Friday, they would max it out, and more than 4 concurrent, high demand sessions would be present. Deffo slowdown.
Among the users, the average full compute demand was roughly 2 minutes. Some instances of this were longer for power users working on more substantial models. 5 to 10 minutes. These were sporadic, during the day. The reason was simple, and it was a model recompute. Happens as users roll up all their changes.
Interestingly, light duty users, doing detail drawings, or minor model updates, sustaining engineering type stuff, they used the system heavy, perhaps 60 percent of their workday, but rarely hit peak single core compute for more than a few seconds at a time. Was hard to even see these. They did not really do big recomputes, but they did do the occasional big drawing render, and those were as bad as the power users. But not even daily.
Most users hit the system both harder and less frequently. 20 to 30 percent of their day, but did post up regular ~2minute single core max compute demands. These people were working on sub systems, and would often copy one, modify, update, check it in, done, next.
The power users hit the ~5 to 10 minute peak compute and used the system half the day. They were working at the entire product level. Big demands on RAM, CPU, Network. Multiple times daily.
What I did was put local compute resources in front of the power users and restructure the network to give them a quieter, higher throughput subnet.
There were a few of these users. They did became network bound, as the data transfer was significant compared to everyone else running on the main server, with high throughput disks. (15K RPM Cheetah drives) This impacted their get going times, but they only did that occasionally. Once things got cached locally, non issue overall. They adjusted how they work and marginalized it. The biggest saving was honestly to just keep it logged in, screen locked, etc...
The rest of the users reported a significant speed up after these things were done.
Now, here's the thing!
A second data logging actually did show the power users improve. And they responded by burying those boxes, opening up a second session on the main one to continue. LOL, fine. It was good enough before, so I said nothing. They were power users and working at the product level and gains there paid off nicely in terms of total project capacity per year. No worries. There to help, blah, blah. But I did chuckle about them very rapidly figuring out how things worked.
(They used the excellent virtual desktop feature in the 4dwm window manager common to SGI computers. One click and they were viewing their local session, one more click and they were viewing their remote one, next.)
But everyone else demonstrated no real change!
The data just was not there to support a big gain, and it totally was not there after the power users did their thing by running two sessions anyway.
So, what was it?
Turned out to be network. When I put the local compute where it needed to be, we moved some switches and had inadvertently improved load balancing at the physical layer. Some users, prior to this, were basically blocking others.
Latency went down for everyone, and average throughput went up, and that proved to be the single most gratifying improvement for them, and it was just faster interactive response. No effective change in actual compute / time unit available, nor demanded from them.
The parallels today are obvious. Get that page response time down. Effective throughput, what users can get done may bump up a little, but the vast majority won't do it.
But, their feel, perception will ramp right up to the positive.
This is true even when it comes at the expense of other things maybe being slower, taking longer. Just get them feedback NOW, and they will feel better about it all anyway.
We were on Ethernet - old fashioned 10Mbs Ethernet (I think) with physical "taps" into a shared medium and terminators on the end. This is easy to remember as I recall the class doofus one day sitting there absently chucking an object up and down in his hand, while people angrily wondered why a whole string of Xterms weren't working. Duty programmer storms into the room and confiscates the item and plugs it in again.
This same guy, a couple years later, manages to helpfully try to remove "." files from someone's directory while logged in as root, and manages to remove all of the honours students' home directories.
What a doofus! I made a few rookie mistakes, but none that basic and painful.
Yeah, some things don't change. I have come to realize that is because people pretty much work the same way. Context changes, but the core doesn't.
Once, just for fun, I had an SGI do window management, another one serve up fonts, a linux box serving apps via NFS, and yet another headless SGI running a shared app displayed on yet another Linux machines X window server session.
It was surreal. Launch that app, and all those machines contributed to the interaction of it.
Plus, it made that instance of RH Linux look like an SGI. 4dwm has a distinct look and feel.
For the most part, running over a 100T network, one could not tell all that was happening. (Was a high end CAD app.)
Later, I did run that same app remotely, using its Windows NT build and the Exceed X server for Win NT. Cool.