I've never been able to get a sufficiently thorough explanation of this to enable me to really understand the difference between how Windows and MacOS handle UI scaling,
Windows, since 98 or so, has supported a notion of changing the DPI from 96 to something else. Windows 8.1 added the ability for different displays to have different DPIs (which became critical when laptops started shipping much higher DPIs and external displays did not). The DPI can be basically any fractional value, and recent versions display it as a percentage, so "200%" is 192 dpi, 125% is 120 dpi, and so on.
macOS briefly offered a developer preview of roughly the same thing. This was discarded in favor of only allowing
integer values. macOS starts at 72 dpi, and supports 144 dpi, which it calls "Retina 2x". Some iPhones also do 216 dpi ("3x").
In Windows, you pick a screen resolution (on LCDs, generally the "native" resolution) and then apply a DPI to it. The application knows what the DPI is, and also gets notified when it changes (though I find this to be extremely unreliable). Thus, it can take a button that's supposed to be 100 pixels wide at 96 dpi, and make it 125 pixels wide at 120 dpi, or 200 pixels wide at 192 dpi. Or it can choose not to do that, and leave the button a fixed size. For example, it might make sense to scale a bitmap image to 96 dpi, and to 192 dpi, but not to anything in between, because that would look blurry. Depending on a litany of compatibility modes, if applications
don't do that explicitly, the system may instead perform the scaling
itself, which most of the time results in blurry rendering.
In macOS, the DPI is a property of the screen resolution. It'll try to guess for you "that resolution looks high enough that you probably want to render everything at 2x", or "that resolution is fairly low, let's stick to 72 dpi". The simplicity of integer values means that you don't run into layout problems: if only a bitmap is available, you can simply scale it up to a 2x2 grid of the same pixels, or use a better upscaling algorithm, but either way, it'll look normal. Thus, for the most part, application developers don't have much to do other than to supply higher-resolution bitmap images (or avoid them altogether). Similarly, when moving between screens that are or aren't Retina, the OS will simply either double the size or not. But that does of course mean that "I'd like it to be a
little bigger" like on Windows won't work with this approach. There's no 125% or 150% or 250%, unlike on Windows. Instead, what Apple proposes for this is to change your screen resolution. The entire screen gets rendered to a virtual display of a different size, and then the result is scaled back by the GPU. This approach does introduce blur, whereas on Windows, an application that handles higher DPIs properly will look perfectly sharp at any of those scale factors.
This is all, by the way, separate from scaling the
font size, which adds even more complexity. macOS doesn't currently have a global notion of a scalable font size, but Windows does have one. As does iOS.
2) Thus the issue is MacOS. And adjusting the UI so it can scale perfectly to any display resolution would require a major rework of the OS, which would be highly non-trivial.
Yeah, that ain't happening.
One Apple engineer reportedly said it was hard to maintain, but the fact is it was already in place, and they were able to maintain it, such that it worked well on the overwhelming majority of displays. Thus they already had a working solution in place, and they gave that up. If they're not even going to do the effort to maintain a working solution that allows sub-Retina monitors to display text nicely, then they're certainly not going to rework the entire OS to do so.
I'll note that Windows, too, has essentially deprecated subpixel rendering. The short answer is that it is hard to implement that on the GPU level, and if you don't, then you eschew GPU acceleration. So it only really worked for pieces of text that didn't need it, and as UIs move more and more to a view hierarchy where underlying portions
are GPU-rendered, that became less and less feasible.