In my Mac Pro review I lamented the state of 4K display support under OS X 10.9.0. In my conclusion I wrote: “4K display compatibility under OS X is still a bit like the wild west at this point”. Compatibility was pretty much only guaranteed with the ASUS/Sharp 4K displays if you cared about having a refresh rate higher than 30Hz. Even if you had the right monitor, the only really usable resolution was 3840 x 2160 – which ends up making text and UI elements a bit too small for some users. Absent were the wonderful scaling resolutions that Apple introduced with its MacBook Pro with Retina Display. Well it looks like that won’t be the case for long, last night I got reports (thanks Mike!) that the latest developer build of OS X 10.9.3 includes expanded support for 4K displays, 4K/60Hz support for rMBPs and scaled resolutions below 4K.
So, OS X is essentially the only desktop operating system with proper HiDPI support, right?
I’m using KDE on my MBPr, and it works just fine.
All graphics are vectors, so it all scales very nicely.
I *do* run at native resolution, but changing icon and text sizes makes it work nicely.
Firefox’s pixelsperpixel option is important for nice default zoom levels, too.
The only thing missing is per-display DPI, which is coming with Wayland. KWin5 will soon be able to support that, too.
Slightly related: I always thought that people were stupid for not doing everything with vectors in svg.
Then I read this:
http://www.pushing-pixels.org/2011/11/04/about-those-vector-icons.h…
But the upshot is, we can use vectors and everything will be magical automatically, just as soon as everyone is on high dpi displays.
It is actually the same aliasing effects that makes “dynamic DPI” problematic in practice as well.
Half the secret of the Hi-DPI feature of OS X is that it exactly doubles the resolution. Legacy apps can then be unaware of it while all images scale cleanly.
A 130% scale on the other hand requires far more complexity because you cannot anymore just upscale all images and coordinates by 30%. Aliasing effects start appearing left and right unless you happen to have a 130% sized image you can use instead. Which is also the reason .ico files pack icons at 16×16, 32×32, 48×48, 64×64, etc.
I wonder how bad it really would be if the resoluytion wasn’t exactly double on a screen with as many pixels as the Mac Book Pro Retina. Theoretically, with a high enough pixel count, it shouldn’t matter.
OS X still looks really good at all the “resolution” settings greater than their ‘best for retina’, which is 0.5x native.
My OS X partition is running at ‘looks like 1920×1200’, which I think is about 0.66x native.
I think the trick is that modern applications and web documents all scale quite responsively anyway.
I’m using KDE on a HP Spectre 13, and it’s still far from perfect. But to be fair, KDE itself is mostly fine. Non-KDE apps like Dropbox (tiny system tray icon) and Chrome (tiny UI) are worse. Then again, Chrome’s HiDPI support is crap under the Windows 8 desktop as well, with broken font rendering and ugly, pixelated up-scaled UI elements.
Indeed, things like keepassx’s systray icon are so out of place.
The Visual Design Group are redoing the system tray for plasma desktop 2, so as to remove the existing size limitation (I think 48×48 is the maximum due to legacy protocols)
They said that there’ll be an option to add a separate ‘legacy systray’ plasmoid for viewing the apps that don’t update, which I agree is a nice way of ensuring everyone is happy.
All I can say is I’m surprised it’s finally happening! Microsoft built DPI awareness into VB6. Hi-DPI screens were particularly expected ‘any time now’ since 2004.
What about Gnome?
https://wiki.archlinux.org/index.php/HiDPI#GNOME_3
3.10+ supports it well.
Even Windows 8.1 supports it now.
Windows 8.1 still is mostly broken for non-Metro apps. Gnome is fine if all you use is Gnome and Firefox, I suppose. I’m not sure which I dislike most: The Linux way of keeping it small in unsupported apps, or the Windows way of making things pixelated and ugly.
Having bought a Dell UP2418Q a couple of weeks ago I learned two things:
1) Windows 7’s Hi-DPI support is a sad joke. And Office 365’s Hi-DPI is also a sad joke. Pretty amazing how everything rolls a dice when selecting font sizes and how the uxtheme.dll engine doesn’t support Hi-DPI, making all your buttons and windows look square and awful.
2) OS X does it flawlessly, except that you have to enable the feature with the Quartz debug development tool, which you can download from Apple if you have a developer account.
I wouldn’t say that’s flawless.
Okay, if you want to be really pedantic about it, yes, it isn’t officially supported. But it actually works once enabled, unlike the officially supported things by the other platforms.
And from what I understand on the article, this thing is already fixed at Apple and will be automatically enabled in one of the next updates.
I call it flawless because it works 100% the same way as if you’ve ever seen a Mac laptop with retina display. I am personally yet to see any font or anything else get mangled on it. Contrast this with Microsoft bragging left and right on MSDN about their DPI awareness and then the OS itself (all the way down to the title bar of windows) can’t even get it right.
You are using the word ‘flawless’ where you mean ‘pretty easy’
…but it actually works, unlike Microsoft’s.
Essentially, all it is is turning 1 pixel into 4, and then using raster scaling to non-native modes, and taking advantage of the fact that the display is higher resolution than most people can see. The “1920×1200″ mode on a 15” MBP Retina is actually 3840×2400 DOWNSCALED to 2880×1800.
That said, there were ways to get higher refresh rates on big displays with older versions of OS X, although they were… convoluted (and usually involved buying SwitchResX). On OS X 10.8.5, I’ve run my T221 (3840×2400) as high as 33.839 Hz.
It would work on Windows, if developers weren’t lazy and used logical points instead of pixels in their components.
Finally we are inching toward resolution independence. Something we can thank the mobile market for.
I did some calculations, at my normal usage distance 1440P on a 24″ could be ‘retina’, ie pixel free. Really not a big ask in this day and age.
We just need the OSs to catch up. It would be a killer app for me if a Linux distro were to marry with Steam OS and provide me with the kind of game support Windows has right now.
The problem is Joe and Jane Average, the ones buying the vast majority of screens…really doesn’t care. Being in retail I have seen this time and time again where folks will take a “bigger” 720p screen over a smaller 1080p. This is why most laptops are at 720p, why DVDs still outsell BluRay by a pretty large margin, Joe and Jane just does not care.
And please don’t bring up Retina because Apple is unique in that they are a tech brand that the public treats as a fashion item. there is a reason why the only thing you see having lines on release besides Apple are sneakers, its because having the latest iStuff is considered a status symbol and a way to show others that you have more wealth than they do.
Honestly Apple can do anything they want at this point as long as they set the price high enough to still be considered an “upscale” brand, because at least here in the state Hollywood has made apple “the” brand all the heroes and cool characters in TV and movies use so if you want to be “cool and trendy” that is what you have.
It gets better with “HD” (or worse, depending on your outlook): http://www.bbc.co.uk/blogs/blogbbctv/posts/how-to-get-the-best-out-… (too bad the BVA link is dead, it quoted percentages)
…so, people just don’t notice much of a difference between SD and HD – so much that they mistakenly believe they have HD, while in fact watching SD.
edit: http://www.bva.org.uk/news-press-releases/choose-right-kit-world-cu… works through archive.org! Relevant parts:
Edited 2014-03-19 23:19 UTC
1. scalable UI
1.1 scalable fonts
1.2 scalable icons
1.3 scalable menu decorations and controls
1.4 scalable window decorations and controls
2. legacy application scaling
I think that is all.
Is anything missing?
Greetings,
pica
It is a little bit more complicated than this. Mostly because developers are unable to properly test their UI on other devices than their own. Therefore the first step is ensuring that the application uses a sane and well defined coordinate system for placement. The following article shows a table at the top with different ways of doing this:
https://blog.qt.digia.com/blog/2013/04/25/retina-display-support-for…
The key is that you need device independent pixels, because then the UI will always have the same physical size regardless of what DPI the monitor may happen to have.
This is the truly hard part. There are roughly three reasons why Windows 7 fails so badly at scaling:
1) If an app is not declaring itself as DPI-aware the OS renders the app client area into a texture at 96 DPI and then upscales it.
The idea here is not bad, but Windows 7 does not upscale properly. A 24″ 4K monitor is exactly twice the resolution of a 96 DPI display, and therefore 1 pixel should be upscaled to 4 pixels. In practice Windows creates a blurry upscale for some reason.
If the scale works correctly then such apps would look visually identical to how it looks like on a non-retina 24″ monitor.
2) Most applications declare themselves DPI aware, but then fail to live up to the promise! For example, Calc.exe says it is DPI aware and then renders its buttons incorrectly. Explorer.exe messes up the location bar. Outlook messes up its ribbon bar and side bars. The DWM messes up the title bar and Firefox its tabs. Qt fails to pass on the actual DPI to its WebKit backend, causing QtWebKit areas to be half size of what they should be!
3) Uxtheme.dll, the component that draws the theme in Windows, has bugs in its DPI scaling. All buttons end up looking really square because the border radius is not properly upscaled, and seems to roll a dice when it comes to what point size it uses for text.
The only applications that got reasonably away with scaling was Visual Studio and then HTML pages in Firefox. Probably because the XAML backend uses physical pixels for placement, and with HTML because 1px is defined to be 1 pixel at 96 DPI. Strangely enough Internet Explorer seemed to have problems scaling the HTML properly.
You’re right there also can be “new” applications that use a non scalable, fixed layout. But, these can be treated as legacy applications.
And the items
* scalable fonts
* scalabe icons
* scalable menu decorations and controls
also apply for (Hi)DPI-aware applications.
Greetings,
pica
OSX doesn’t actually do proper DPI scaling – it is either normal or double size, and nothing in between.
Windows has supported arbitrary DPI scaling since at least Windows XP, but has always required a fair amount of work by developers to support it. Up until recently, there hasn’t been much of a need for it, so developers didn’t support it. Windows 8.1 has much better support than Windows 7 (and even better than 8), but since it’s fairly new, it’ll take time for apps to use it.
Microsoft also doesn’t have a means to force developers to use new features on the desktop, nor should they. Apple has two methods: Willingness to break compatibility, and the Apple app store, where they can (and have) forced developers to adopt new standards or else…
The thing is, by the end of the day as an end user, I don’t care whose fault it is that my entire desktop looks like a mess. It is just like with Windows Vista where virtually no correctly written apps would get into trouble with UAC. Yet so many applications out there failed the test. Who did they blame? Microsoft and Windows Vista.
What Apple realized is that if they could find a way to have OS X render correctly at 2x the standard DPI, then they could get legacy apps work visually correctly and then slowly introduce DPI awareness. Once developers gets used to knowing that 1 unit doesn’t always mean 1 physical pixel, we can get to a world of better behaving apps.
Microsoft sort of been trying to do the same, but their problem is that everyone and their dog went ahead and declared “uuhh yep! I’m DPI aware! *giggle*”. So now every application says they are aware of the DPI while virtually nothing is – not even Windows and its basic components itself.
Lastly Microsoft has the problem that GDI works in integers, while Quartz is a bit more modern and uses floating points. Integers and variable scaling is a really bad combo.
That it’s taken this long for other operating systems to catch up to Windows 3.0 in terms of interface scaling.
The only thing that’s lacking in windows is icon scaling, apart from that ALL UI elements (fonts, window chrome, window controls) and 95%+ of well written programs (Word, Excel, browsers) SINCE WINDOWS 3.0 have had scaling support built in … originally it was the 8514 fonts, then they were called “large” — then some complete dumbass decided to call them 120dpi out of utter ignorance… Scaling to any size was introduced in Windows 98 and while unreliable, works just GREAT in Windows 7/higher, as evidenced by my turning the normal windows UI into a “ten foot display” by just setting it to 200%.
… and yet this is some new and amazing thing? Hell, if you could get the right DRIVERS for Win98 to set the giant display mode, out of box it would do a better job of it than anything Apple or *nix folks have done the past decade and a half.
… as evidenced by my trio of 27″ 2560×1440 being useless in OSX and buggy as sin in Linsux if you even think about bumping the font size, but glorious at the ‘8514/large/120dpi/medium/whateverTheyCallItThisYear’ setting in Windows.
The only time it’s an issue is with poorly written crap that ignores the system metric — and that’s a pretty short list. Websites made by ignorant fools who declare all their fonts in PX, Java Crapplets made using toolkits like SWING or bypass/ignore the interface guidelines, and people who don’t realize the interface scales and try to mix fixed size backgrounds and window sizes with the dynamic fonts. (usually game installers)
You get a DRIVER on windows to set the video mode, it should be good to go… as of 1998 in terms of true scaleability, as of 1990 if you can get a matching raster font.