So if there was 8K input it would look better than upscaled input despite you not being able to see the individual pixels?
Setting the scaling on software simply draws the interface larger, to compensate for the higher resolution. Suppose the dimensions of a character such as the letter o is 10 pixels by 10 at 100%. If the scaling is set to 150%, then it will draw the letter o at 15 by 15 pixels.
Isn't that what stuff like Cleartype is all about? They draw at the 15x15 virtual scale and map that to the 10x10 actual pixels.
Nope. You’re thinking of (one approach to) grayscale anti-aliasing. It’s actually usually done by other, more computationally efficient methods.
Cleartype is Microsoft’s name for subpixel rendering, which allows the text renderer to be aware of the RGB subpixels in an LCD, so that it can produce more accurate letter shapes.
ClearType's intelligence is treating the subpixels of a pixel as usable for improving font clarity. This is because the human eye has poor chrominance resolution compared to its luminance resolution
That is NOT why subpixel rendering works!
The principle isn’t that our eyes have lower chrominance resolution: the principle is that to draw a full-color pixel somewhere on a screen, you need all three subpixels — but they can be
any three adjacent subpixels, giving you triple the horizontal placement resolution, with
zero loss of chrominance resolution on all pixels except the first and last one of a line.
Where it gets trickier is attempting to use subpixel rendering not just to get triple
placement resolution, but to draw lines whose
thickness is not an integer multiple of a whole pixel. As soon as you use fractional pixel widths, you risk color shifts. So in practice, some algorithms “shade” grayscale-antialiased text with the colors to avoid extreme color shifts. Others render in full “color” and then desaturate it.
As it is, subpixel rendering is on its way out: nobody ever made a subpixel rendering implementation that supports arbitrary display rotation. Microsoft’s supports BGR subpixel order in addition to RGB, but nobody ever made a rendered that works with a display rotated 90 degrees. So between modern gadgets that support dynamically switching between landscape and portrait modes, high-resolution displays that simply have tons of resolution — and many of which use non-uniform subpixel arrangements (especially OLED, some of which is RGBW, some with different size subpixels for RGB*) — plus modern graphics pipelines that support the little animations and transforms in modern user interfaces, many modern OSes are deprecating subpixel rendering. iOS has never supported it, macOS has disabled it by default ever since the Retina (200% scaling) Macs came out, etc. The newer, iOS-derived graphics engine in macOS doesn’t even support subpixel rendering at all.
Windows has two completely different text rendering engines, the old GDI one and the later WPF one. The GDI ClearType is truly just subpixel-tweaked grayscale antialiasing, as it does not allow characters to be positioned in increments smaller than a whole pixel. WPF ClearType is extremely similar to the Mac subpixel renderer, which allows sub-pixel positioning (i.e. you can position a character anywhere, e.g. at 48.2216px), allowing more accurate overall text rendering. Both WPF and Core Graphics/Core Animation (the modern graphics APIs on iOS and macOS) fully support grayscale anti-aliasing with sub-pixel positioning, since it works well on any type of display, regardless of subpixel arrangement.
Unfortunately Windows can’t switch rendering modes on the fly, so on windows devices that can rotate the screen (like my convertible laptop), as soon as you rotate the screen away from whatever orientation ClearType is set to, ClearType text looks
awful. Apple avoided this problem by simply never using subpixel rendering on iOS (and until now, not shipping any “convertible” Macs).
*despite the wiki article on subpixel rendering having an obscenely oversized section on the PenTile series of non-uniform subpixel arrangements, claiming some were designed for subpixel rendering, I am not aware of any implementations of such renderers being in actual use in the wild.