WAYLAND SHILLS BTFO

Did you even read the article? Sorry that your low-IQ nigger monkey brain can't process all this writing.

I wish wayland had a more traditional event loop too. This one isn't as big of a deal in the long run, but it's kind of annoying not being able to deal with ordering at all from the client side. In xcb, you can wait for specific things if you need them.

Which article? Post one and I'll read it. None were posted. The link in OP is incoherent rambling from a mentally damaged person

wayland.app/protocols/wayland#wl_display:request:sync

That's specifically for frame callback.

Wrong

>The big and obvious mistake to point out is fractional scaling. For some reason unknown to me, the Wayland protocol only supports integer scale values. To be frank, this is asinine and everyone pays the price for it. As higher resolution displays became common, users naturally wanted to scale the display to fractional values (1.5 and so on). Because telling users "you can't do this" to something as basic as this was a non-starter, all compositors implement a hack with this. They tell clients to scale up to the next integer and then the compositor downscales it to the correct one. So in the case of 1.5x scaling, clients are sent a scale value of 3 so they paint at 3x the resolution. Then, the compositor scales that down by 2. This is just, to be frank, incredibly stupid and wasteful. Clients (such as mpv under heavier settings) unnecessarily tax the GPU and then the end result is worse anyway. With text rendering in particular, it's noticeably more blurry.

>So how does Xorg handle this? Well you can just set DPI globally or use DPI values per monitor via RANDR so actually it works just fine (gtk is notably broken on purpose). Clients can calculate exactly what the physical pixels are and can make the correct decisions while rendering.

I don't know much about Wayland to dispute him, but that sounds wrong.

Yeah my bad I misunderstood. The documentation is kind of wrong though because people normally use a wl_display_roundtrip for this not sync.

It's because it is wrong, the whole article is wrong

Wayland really does work that stupidly. I know it's hard to believe but buffer scale is an integer.

Why shouldn't it be an integer?
How do you render 1.5x of a pixel?

If you don't allow for a fixed value or something along those lines, how on earth do you expect to handle fractional scale values sanely? It's something people actually do.
gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/47

How do you handle fractional scale values sanely?
How do you tell your LED monitor with a fixed resolution to render 1.5x of a pixel?

I wish Wayland was good but the truth is staring me in the face. It's sunk cost fallacy at this point.

>Compare Wayland adoption to some other FOSS projects like Systemd or Pipewire. Regardless of your opinion of their quality, both of those offered full compatibility with the legacy, old way while adding lots of new features and functionalities.

Based.

Likely true, but what you don't realize is that X11 is much much worse of a sunk cost fallacy

Wayland did add lots of new features and functionalities

This sounds more like you're arguing against the concept of fractional scaling to begin with. Of course there are tradeoffs and rounding decisions to make. If you don't like those, you can always just integer scale. However, fractional scale values is something people do in the real world on all OSes. It's common. In wayland, this is handled is the worst possible way. Clients have no way of knowing that they are being fractionally scaled because of the design so they end up scaling over the actual resolution and then the compositor scales it down. It's both wasteful and looks worse than the alternatives.

>This sounds more like you're arguing against the concept of fractional scaling to begin with
You still haven't explained how I make use of 1.5 of a pixel
>Of course there are tradeoffs
Like... scaling?
>fractional scale values is something people do in the real world on all OSes
Wrong. MacOS uses integer scaling
>they end up scaling over the actual resolution and then the compositor scales it down
Then scale them up instead?
>looks worse than the alternatives
The alternatives which are also scaling?