[sprash]

> there's nothing at the protocol level that prevents the long tail

Severe over engineering, unstable interfaces, massive boiler plate and huge development overhead is preventing the long tail "at the protocol level".

As example: Compare the Wayland "Hello World" [1] with X11 "Hello World" [2]. If you want to add the ability to take screenshots it gets exponentially worse. (Also the Wayland version is not even capable to render strings.)

1.: https://github.com/emersion/hello-wayland/blob/master/main.c

2.: https://rosettacode.org/wiki/Window_creation/X11#C

[QUrprUd1nCeicw]

>Severe over engineering, unstable interfaces, massive boiler plate and huge development overhead is preventing the long tail "at the protocol level".

No, all those can be solved with client libraries. X11 had Xlib and the other client libraries. Those X11 libraries don't make sense in Wayland, but the client libraries that stayed relevant (freetype, cairo, etc) can still be used.

>If you want to add the ability to take screenshots it gets exponentially worse.

No, in both modern X11 or Wayland, you should use the same API for screenshots: the XDG screenshot portal.

>Also the Wayland version is not even capable to render strings.

Sure it is, but you have to use client-side rendering. Client-side rendering is also the norm in X11, since decades ago when Xft was released as another one of those client libraries. That X11 hello world is short because it's using obsolete APIs.

[sprash]

> No, all those can be solved with client libraries.

There is no easy way to open a Window and render a string. Period! You either need to write it yourself completely (as OP stated) or you can use Gtk/Qt or other heavy weight "client libraries" (cairo and freetype do not create Wayland windows and therefore are not applicable here).

Look at the code again! If you really think that the code at [1] is in any way a great solution as compared to [2] we are going to disagree.

> No, in both modern X11 or Wayland, you should use the same API for screenshots: the XDG screenshot portal.

ZERO screenshot apps on X11 use XDG screenshot portal, they all use XGetImage(). Mainly because the assumption that a dbus-daemon is always running everywhere is mostly false. Also XDG screenshot portal is simply not a good solution. It is cumbersome to use, contains tons of edge-cases and pulls a dbus dependency for something that could be solved much simpler with onboard OS-functionality without the need for extra daemons and weird binary protocols

> Client-side rendering is also the norm in X11, since decades ago when Xft was released

Besides the point, but you are still wrong. Xft does server-side rendering via XRender. The cache is rendered only once on the client but that's a technicality, spline tessellation was supposed to go into the server but Keith Packard had more important things to do at the time.

[QUrprUd1nCeicw]

>There is no easy way to open a Window and render a string. Period!

Yes, there is. Use a client library. That's what they're for.

>You either need to write it yourself completely (as OP stated) or you can use Gtk/Qt or other heavy weight "client libraries"

This is exactly the same as in X11. Remember Xlib is one of those heavy weight client libraries. The X11 example you showed uses Xlib.

>Look at the code again! If you really think that the code at [1] is in any way a great solution as compared to [2] we are going to disagree.

I don't think either of them are great. I'm saying that's comparing apples to oranges.

>ZERO screenshot apps on X11 use XDG screenshot portal, they all use XGetImage().

They shouldn't. Like most parts of X11, XGetImage is an obsolete API. You don't want to use that in modern clients.

>Mainly because the assumption that a dbus-daemon is always running everywhere is mostly false.

No, dbus is used by basically all modern desktop environments on Linux. If you don't have dbus available you're going to have a lot more problems running normal Linux apps than just dealing with the differences between X11 and Wayland.

>Also XDG screenshot portal is simply not a good solution. It is cumbersome to use, contains tons of edge-cases and pulls a dbus dependency for something that could be solved much simpler with onboard OS-functionality without the need for extra daemons and weird binary protocols

X11 is also one of those weird binary protocols that isn't onboard OS-functionality and has more edge-cases, so according to this XGetImage isn't a good solution either.

>Xft does server-side rendering via XRender.

No, you've got rendering mixed up with compositing. With Xft, the rendering of font data to pixels is still done in the client. XRender, despite the name, is frequently only used to composite surfaces together. That's doing the same thing that Wayland is doing.

[forgotpwd16]

>XGetImage is an obsolete API. You don't want to use that in modern clients.

How is obsolete and what makes XDG portal a better option?

[QUrprUd1nCeicw]

X11 APIs have no security and they don't work in Wayland. Either one of those reasons is enough to avoid using them.

Aside from that, it's the slowest and worst possible option in X11 because it copies the pixels into the socket. To handle large images you want to at least use MIT-SHM. XGetImage should only be used as a fallback. Or better, just don't use X11 APIs at all.

[kaba0]

That’s just optimizing for the wrong thing. Why should it be easy to write from zero a “hello world” window? Where would you go from there, what’s useful about that? Should it also handle inputs, redraws, widgets, layouting?