Where It All Falls Apart

As with many things in Windows, the operating system is too trusting of developers. Of course not all developers fall into this trap, but many applications in Windows (including many written by Microsoft) don’t follow the best practices on how to deal with High DPI displays. Let’s take a look at one example – VLC player.

VLC 1.0 is what is referred to as a DPI-unaware application. The application was created to render at 96 DPI and it just expects the display to match. This makes the application undersized on a High DPI display, but thanks to DPI Virtualization Windows can automatically scale the application up to match the DPI settings of the display. This does introduce some blurriness to the appearance, but all menu controls and fonts are the correct size for the screen as seen here:

Looking at that image, it’s clearly upscaled but it’s also completely usable. So what’s the issue? VLC is a media player. With DPI Virtualization, media being played back through the application is also rendered at 96 DPI, and then scaled up off screen. This produces a video that appears blurry to the end user, which is not what VLC wants. To correct this issue, the VLC developers changed the application to declare it as System DPI-aware. This disables Windows’ scaling of the application, and Windows expects the application to scale itself. However, in the case of VLC player it doesn’t actually do any scaling at all as you can see in these screen shots of VLC 1.1.1 and the most current version 2.1.3:

 

Here, any of the UI elements that are handled by the operating system are scaled to the correct DPI settings, but the rest of the application is not scaled at all, which results in an application with unequal proportions. I’m not picking on VLC player here – it is just one of many applications that do exactly the same thing. It’s a great example to show the progression of when a coding choice was made to enable the flag and view the results of the change, as older versions of the software are still readily available. Also in VLC’s favor is the fact that their UI elements are somewhat oversized to start with. This could easily have been a design decision that their application was already usable at High DPI, so it’s not worth scaling the UI at this time.

Let’s look at another application which has long been called out for having issues when Windows is run on a High DPI system – Google Chrome. The oddest thing about Chrome not scaling well is that Chrome does actually support High DPI. Chrome OS, Mac OS X, and obviously the Android versions of Chrome all scale well. But on Windows? There are issues. Here’s a screenshot of Google Chrome taken on my Lenovo Yoga 2 Pro at 3200x1800 with Windows scaling set at 200% (the default setting from the factory):

To see the issues, you’ll likely have to open the full resolution version of that screenshot. At first glance all seems pretty nicely scaled with Chrome – the “chrome” of the browser is not tiny, tabs appear to be the correct size – but look at the actual text on the webpage.

With the cropped image, you can instantly see that the font that Chrome is using is not scaling very well. Text in Chrome on a High DPI system is very poor, and defeats the purpose of using a high resolution screen since you actually lose fidelity rather than gain it.

Chrome, unlike many other apps, does have some workarounds to this issue; unfortunately it’s not something the average computer user would ever be able to figure out. First, you have to open chrome://flags setting page and then enable HiDPI Support Windows. Next, you have to right click the Chrome icon on your desktop, choose properties, and then the configuration tab. Here you need to check the box that says “Disable display scaling on High DPI settings” and apply.

What this checkbox does is actually disable the DPI Virtualization on a per-application basis. Chrome will now use XP style scaling. If you don’t check this box, Chrome will disregard the flag in its own settings, and continue to render text very poorly. The only reason I can think of for Chrome to not use the newer DPI awareness API and instead use the old XP style DPI setting request would be because Chrome is still supported on XP. It’s a strange decision though because running a High DPI system on Windows XP is not a great experience. It’s unfortunate for Chrome users because most of them will never know just how poor of an experience they are getting on newer systems. However, with these changes in place, Chrome now renders correctly.

Next, let’s compare Chrome to an application which does follow best practices – Internet Explorer 11. IE11 correctly queries the operating system for the current DPI setting. When it receives the response, it rescales the UI elements as necessary, and then uses its Zoom feature to enlarge the actual web page. The result is a web page that looks exactly as it should.

IE11 also uses the queried DPI level of the operating system to set the default zoom level, so if you are a heavy keyboard user and you like to use Ctrl+0 to get back to 100% zoom, fear not. This still works, but the default zoom will be a higher number than 100% depending on the scaling factor chosen. Here’s another screenshot of IE11 with the resolution set to 3200x1800 and the DPI set at 96 DPI.

At first glance, it looks hilariously bad, but in fact it is doing exactly what it is supposed to. IE has queried the operating system for the DPI level (now set at 96) and scaled correctly to that level. Not all of Microsoft’s applications do this, but most are not as high profile as Internet Explorer.

History of Windows DPI Scaling When It All Goes Really Wrong
Comments Locked

114 Comments

View All Comments

  • JDG1980 - Tuesday, April 15, 2014 - link

    Adobe is a company full of whiners. When the Surface Pro came out, the pen didn't work in Photoshop because it used the Microsoft Ink API, instead of WinTab. (WinTab was supposed to be a free standard, but is tied up by a patent troll.) When Adobe was asked to fix this, they said "Waaaah, Ink API is too hard and we don't like it, so MS will have to support the old API instead." Unfortunately, Microsoft backed down instead of forcing Adobe to do the right thing. And we're seeing this same thing again with HiDPI support for Windows: "Waaah, it's too hard, we don't like the APIs, please Microsoft fix it for us". It's been pointed out to them multiple times that many other apps manage to do it just fine, but no, Adobe is a special snowflake and it has to be their way. Everyone else has to conform to them. Can't expect them to do any real work for the thousands of dollars per unit that they're being paid by graphics professionals.
  • jhoff80 - Tuesday, April 15, 2014 - link

    That had been a problem for nearly a decade. However, Adobe has now added Ink API support to Illustrator and Photoshop in their newest updates.

    And while I definitely fault Adobe for taking so long to add the Ink API, Microsoft still needed to get a Wintab driver. Adobe is not the only company that wasn't (at the time) using the Ink API. Even now, Photoshop is covered, sure. That doesn't help with Mischief, or 3D modeling programs, or any number of other Wintab-only applications.
  • Imaginer - Tuesday, April 15, 2014 - link

    You do not need to wait for a Microsoft WinTab driver. Wacom's FeelIT drivers for Tablet PCs has been updated for the Pros since last year around May.

    And, the drivers work for any Wacom pen-enabled displays. This driver, allows me to have two side buttons to assign functions and work with on particular pens out there (most definitely not the Surface Pen).
  • jhoff80 - Tuesday, April 15, 2014 - link

    Yes, that is exactly the driver we were talking about waiting for. That issue is fixed now on both ends. Microsoft/Wacom have their Wintab driver, and Adobe now also supports the Ink API. But when the Surface Pro first came out, neither of those things were true.
  • twtech - Tuesday, April 15, 2014 - link

    In an ideal world, every huge old codebase like Photoshop's would be very clean, and adding another pen interface would be relatively straightforward.

    In reality, they probably had WinTab-specific code sprinkled in there in various places, which made fixing the problem more difficult, and includes the possibility that the WinTab stuff wouldn't work right afterward if any mistakes were made during the process of making that code generic.
  • JDG1980 - Wednesday, April 16, 2014 - link

    Well, that's why we pay them the big bucks. It's their responsibility to keep their code base clean and maintainable, not everyone else's responsibility to pander to their pile of spaghetti code.
  • kasakka - Sunday, April 20, 2014 - link

    My experience with Adobe is that while the guys working on the image manipulation algorithms are absolutely brilliant, the folks behind the UI and QA are borderline incompetent. Adobe's software has been riddled with a shitload of small UI flaws (ranging from wrong fonts to incorrectly positioned controls to more severe stuff) for years and they don't seem to bother doing anything about it. These are probably the same people we can thank for not having proper DPI scaling.
  • skiboysteve - Tuesday, April 15, 2014 - link

    Great article. Kudos on writing this up so clearly
  • r3loaded - Tuesday, April 15, 2014 - link

    The problem is that developers for the Mac are far more enthusiastic and invested in their platform, so when the rMBP was launched many of the big names rushed to add HiDPI support to their programs (either straight out of the gate or within a couple of months), giving a good user experience. There's also a general culture of following Apple's guidelines on UI design and UX best practices.

    On the Windows side, many developers can't give a crap about UX problems and blatantly ignore Microsoft's guidelines and best practices, preferring to do it their way. They still haven't got around to fixing their programs. I wonder if many ever will.

    Unless there's a big shift in culture and attitude, we're going to continue seeing scaling issues in Windows programs (issues that are in reality the fault of developers, not Windows itself).
  • jhoff80 - Tuesday, April 15, 2014 - link

    To be honest, this is exactly why I feel that Metro needed (and still needs) to continue being pushed forward, as much as most power users hate it. Sure, there are some great desktop / Win32 apps, but they haven't really been relevant for years, and most developers just don't care enough any more to update them in really essential ways for the future (High DPI being the prime example). WinRT / Metro definitely still are rough around the edges, but in forcing developers to cut ties, it also forces a lot of progress on these fronts.

Log in

Don't have an account? Sign up now