
Living a High-DPI desktop lifestyle can be painful on Windows - henrik_w
http://www.hanselman.com/blog/LivingAHighDPIDesktopLifestyleCanBePainful.aspx
======
latitude
Just to be clear - supporting High-DPI on Windows is not as simple as adding
scaled up resources. Instead, it is an absolutely royal pain.

For one, you can't just throw hires bitmaps into a resource section of .exe
and expect them to magically work. There needs to be code that looks at
current DPI and picks matching bitmap.

For two, standard DPI levels are 96, 120, 144 and 192, but guess what? All
other values in between and above 192 are game too. In fact, there's a nice
little slider in the Control Panel that _encourages_ you to put it somewhere
in between. This means that your code either needs to rescale bitmaps to match
these odd DPIs or use the largest one that fits. In either case the result
will look like butt.

For three - the dialog layout. If your dialogs have text that's longer than
3-4 words, the chances are that it will either overflow, underflow or wrap
differently under different DPIs. This in turn means that you need to test
dialog appearance with at least 4 different font sizes _and_ Tahoma 8px for
Windows XP. Do you know how hard it is to word a longish sentence so that it
would fill about the same space with all 5 combinations? Really damn hard and
very time consuming.

But wait! There's more.

Every app _icon_ needs to exist in _at least_ 9 sizes, like so -
[http://imgur.com/5Pe2ZV0](http://imgur.com/5Pe2ZV0) \- and this would still
miss some cases where Windows will scale an arbitrary chosen icon image and
use it.

It really is a mess. However this is not something unexpected if you've been
writing for Windows for a while. This mess is a routine.

~~~
FollowSteph3
The other thing to remember is that most likely less than 1-2% of your whole
customer base is currently using high DPI monitors, so all these very high and
very real costs are sometimes not possible in ROI, especially for more niche
markets. It much like supporting IE6, or maybe IE5 for the 1% that still use
it? Would you in a niche market compared to a mainstream app? This will change
with time as these monitors become more common but right now the threshold is
still very low compared to the costs.

~~~
dangrossman
That seems like a lowball estimate even today. If you go shopping for a new
Windows computer or tablet in Best Buy or Staples or some other american
store, maybe 1/3rd to 1/2 of what's on shelves is high DPI now, from the $400
tablets up to $1200 ultrabooks. Lenovo, Samsung, Asus, HP, all the big
manufacturers have 2560x1440 or 3200x1800 ultrabooks and hybrids out, and even
1920x1080 tablets are set to 1.5x or 2x DPI scaling because those pixels are
packed into 10" or smaller screens.

~~~
nly
Tablets yes. Notebooks no. 'Ultrabooks', whatever they are, maybe. The
majority of laptops up to 15" and ~$1200 are still 1366x768. Source: I
recently went shopping for a laptop with roughly that budget. In fact, I don't
think you can buy anything 15" beyond 1080p on that budget.

------
interpol_p
One area where Apple has been incredibly aggressive — and Microsoft has been
sorely lacking — is in actually producing and preparing high resolution
content _well in advance_ of the display technology.

Apple new this was coming and for years have demanded icons, images, and
artwork to be provided in high resolution. They developed assets for their own
software in high resolution before retina displays ever hit the market.

Contrast to this article where Microsoft's own Visual Studio (one of the "best
cases" mentioned by this article) _doesn 't even have Hi-DPI icons._
Microsoft's own software displays blurry icons and it's listed as a "best
case."

Apple also pushed Intel very hard on driver support for their integrated
graphics. Rewriting the driver-level image scaling to ensure that discrete and
integrated GPUs produced identical images, again before retina displays ever
came on market, to allow for seamless switching between GPUs on their
hardware.

This sort of foresight was necessary to pull off the high density display
introduction as smoothly as they did.

Same goes for multiple monitors, which "just worked" when Apple introduced
their high density displays. You could connect a regular monitor to your
laptop and drag windows across. The DPI and art assets adjusted dynamically.
This is something Windows is only just now getting around to fixing in version
8.1.

~~~
Trufa
And my completely understaffed KDE does it beautifully.

------
pdkl95
[http://www.antigrain.com/research/font_rasterization/index.h...](http://www.antigrain.com/research/font_rasterization/index.html)

This is a few years old now, but is still one of the better explanations of
the issues involved in modern font rasterization, with emphasis on how
Microsoft's likely held back the entire industry by only realistically
supporting widget fonts at the standard 96ppi. Really, anything other than the
stock Arial 10pt/96ppi is going to cause layout issues.

In an effort to very-aggressively hint that font so it looks consistent, they
throw out horizontal accuracy by rounding to pixel boundaries. Per-letter.
Ouch.

The best part of the paper, though, is this image that moves the sentence to
the right exactly _1 /10 pixel_ each line:

[http://www.antigrain.com/research/font_rasterization/sample_...](http://www.antigrain.com/research/font_rasterization/sample_arial_1tenth_shift.png)

------
modeless
The Windows DPI scaling control panel has DPI scaling bugs:
[http://i.imgur.com/zi80IhG.png](http://i.imgur.com/zi80IhG.png)

That's all you need to know about high DPI support in Windows, in a nutshell.

------
Aardwolf
Why are names like "High-DPI" used?

There was a time when 320x200 graphics with 256 colors was amazing. Would
800x600 have been considered "high DPI" back then?

Or in the time were people were playing Duke Nukem 3D at 640x480 pixels, would
they have considered 1920x1280 to be "high DPI"?

Windows has transitioned all the way from 640x480 in Windows 3.11 to the
resolutions of today, why would there be a problem with just another step up?

What is "high" DPI today? What will it be tomorrow?

~~~
thornjm
Perhaps because we reaching a point where our eyes can longer perceive the
individual pixels that we really have reached maximum resolution. Is there any
benefit from higher resolution displays?

~~~
snogglethorpe
One advantage of high-density displays you sometimes see mentioned is that "we
won't need to use anti-aliasing / sub-pixel rendering!"

However at the common "high" density used in cellphones these days, 320+ DPI
or so, artifacts in non-AA fonts are still visible (not always, or to
everybody, but sometimes anyway).

So, at least, there are _some_ cases where higher-density than today could
yield some benefit.

~~~
jbverschoor
I've turned off subpixel anti aliasing on my macbook pro retina.

Net step would indeed be disabling anti aliasing

------
pilif
you can say what you want about Apple in general, but they way they "fixed"
this issue with the retina macs is so much better than what windows is doing.

Windows has had the DPI selector ever since 3.1 (or even 3.0), but because
nobody traditionally tweaked the settings, nobody bothered to make their apps
look right and because nobody bothered to make the apps look right, nobody
tweaked the settings because running higher DPI modes was breaking apps all
over the place.

Mac OS did this too - I think in the 10.4 timeframe there was an option to
actually switch into a higher DPI mode and many of the OS-internal UI assets
were vector images. They probably noticed that it will never work out, so they
opted to go for a hack:

With the exact quadrupling of the resolution, we got a solution that works
mostly transparently for the applications. They still think they are drawing
with a one-pixel resolution, so the burden of getting this right moved from
the app makers to the OS maker.

Even if an application has no modifications for retina displays, it will look
mostly right (minus some blurring issues for pixel art). There will be no
scaling issues, no texts will be cropped and everything will be scaled by the
same factor.

If you want to 'optimize' your app for retina, all you do is provide higher
resolution bitmaps and you're mostly fine.

The exception is some text-editors (sublime) and browsers (chrome) that were
doing some manual text rendering, not relying on the OS API. These had to be
fixed manually, but there really weren't that many applications like that.

Yes, the way Windows does it is probably more "purist". Yes, the way Windows
does it allows for arbitrary scaling factors (also sub 200%).

But it _doesn 't work_ in practice.

Yes. The Apple solution is a hack. Yes, it doesn't allow scaling to arbitrary
factors. Yes, providing 2x bitmaps instead of one vector image is annoying.

But it works in practice.

On a retina mac, you'd never see the issues the OP complained about seeing on
their Windows machine. What you get there might be superior from a technical
standpoint, but it all boils down to an ugly half-working mess because
developers just _don 't bother_ to get it right.

I'm not excluding myself here. I've done a few windows apps and I f'ed up high
dpi modes as many times as everybody else - also because my development
environment (Delphi) made some assumptions that just didn't work well with
high-dpi modes.

Getting HDPI right on Windows (Desktop): Really hard and thus not worth it for
most developers. Getting HDPI right on the Mac: Trivially easy.

~~~
zokier
> Even if an application has no modifications for retina displays, it will
> look mostly right (minus some blurring issues for pixel art). There will be
> no scaling issues, no texts will be cropped and everything will be scaled to
> the same factor.

That is how it (should) work in Windows too. All applications that do not
explicitly claim to be DPI aware get just bitmap scaled, just like on OSX.

The real problem is that tons of applications claim to be DPI aware, but in
reality are not. The reason Apple does not have these kind of issues is that
their Retina thing is more recent and thus there are no legacy apps that claim
to be DPI aware.

~~~
eropple
_> The reason Apple does not have these kind of issues is that their Retina
thing is more recent and thus there are no legacy apps that claim to be DPI
aware_

Not actually true. Many games are fairly messed up in either windowed, full-
screen, or both noises. Usually it's because of a bad middleware toolkit that
either enables the Retina backbuffer our not but the OpenGL scaling doesn't
match the window scale. Especially prominent in games that use the older,
Carbon method of exclusive full screen mode.

Aside: full screen games manage to be even worse on OS X than on Windows. That
takes effort. (Games as full screen spaces is a really nice, usable concept,
but the performance hit is so nasty nobody wants to support it instead of the
invasive and messy Core Video tour.)

~~~
eropple
(aside: This post was doubly a victim of autocorrect. s/noises/modes/ and
s/tour/route/. My bad.)

------
js2
_Adobe everything._

Well at least Adobe is consistent. The Flash Installer is awful on OS X as
well. For example, say you've disabled the translucent menu bar - you'll
notice it's drawn translucent when the Flash Installer is the foreground app.
(Nevermind the fact that the installer is a just an annoying wrapper around
the OS X installer that seems to do nothing more than force you to quit your
open browsers before it will continue. With some digging you can actually find
where it's downloaded the real installer pkg, double-click that pkg to install
it, then quit the wrapper.)

~~~
jasomill
Is the Flash installer running as a different user? Menu bar translucency can
be set per-user and translucent is the default, so if, e.g., you run an OS X
GUI app as root using sudo, and haven't disabled translucency _for root_ ,
you'll see this behavior.

------
msy
Can we get 'on windows' added to the title? None of this is about high-
DPI/Retina displays in general, it's just Windows and Windows ecosystem issues

~~~
panacea
It's humorous that at the end of his article he asks:

> "Do you have any examples of high-DPI frustration on the Desktop? Upload
> them to ImgUr.com and link to them in the comments!"

Yeah... your blog post looks like shit on my MacBook Pro... all your
screenshots are blurry messes.

~~~
Filligree
Huh, they look fine on my MBPr.

Because I'm using Chrome? It has a very good sharpening filter.

~~~
panacea
Wow... night and day compared with Safari. Can't for the life of me find
details about the different approaches via search. Any links to why the
browsers differ?

~~~
Filligree
Google implemented a sharpening filter in Chrome(ium), Apple didn't for
Safari. That's it.

------
ZoFreX
One of the most depressing areas of Windows to look at is the various control
panel screens. Some of them, I kid you not, will show different bits of text
in up to three different sizes. If Windows itself doesn't deal with different
DPIs correctly, what kind of example does that set for application developers?

Another application that definitely deserves mentioning is Chrome. It looks
_absolutely terrible_. It's really blurry and browsing the web for even a
couple of minutes really strains my eyes. If you run high DPI Windows, you're
going to need a different browser than Chrome (Firefox looks fine but
unsurprisingly does not perform so well at such a high resolution. Internet
Explorer is actually not a bad choice - high res and fast)

~~~
yummysoup
In Windows 8.1 you can override the scaling for individual apps through their
properties dialogs. Set Chrome to not scale, then set the zoom within Chrome
to be > 100%.

The url bar and tabs will be a bit small but the page content will look good.

~~~
wvenable
TIL. I upgraded to Windows 8.1 but I didn't know about this. Anything Java
doesn't handle high DPI and will simply be doubled and is a blurry mess. I
actually turned off DPI scaling just because of Java but if I can control it
on a per-application basis that would be preferable.

------
0x0
It's pretty amazing that Adobe is doing particularly bad. Keepers of pdf and
postscript, you would think they knew all about fonts and dpi.

~~~
tanzam75
> _It 's pretty amazing that Adobe is doing particularly bad._

Adobe has historically been bad at playing well with Windows. They like to
reimplement large parts of the UI.

------
riquito
What's the situation on GNU/Linux?

~~~
tenfingers
Fonts specified in points are correctly rendered using the DPI setting
correctly, as it has always been. So, as far as 99% of my work is concerned
(terminals and text editors), there is no problem.

However GUI elements of most programs are still specified using pixels, so
buttons, menus and some icons might look "tight" around the text if the theme
is sized using pixels. Recent GTK/QT versions do support point units, so it
mostly depends on the theme you choose. These toolkits also always
(historically) had resizable dialogs, contrarily to window and mac, so even
with "bad" support for high DPI, the text will be readable and the interface
will be scalable.

Legacy apps, such as WindowMaker dockapps (which are historically sized as
64x64) though will be unreadable. Frankly, I can already cannot read them
anymore.

Given the configurability of most programs, I would say it's really not a
problem. Most of the other programs will be adapted very quickly.

~~~
BHSPitMonkey
Would some smart window manager additions be in order here? I could envision a
titlebar context menu option to force a window (or all of an app's windows,
probably) to render at 2x (composited by the WM) so that we have control over
all the edge cases.

~~~
tenfingers
With composition, this would be easily done (ie: upscale the target window). A
plugin for compiz would be very easy to do and control from the user
perspective, but that actually would be half resolution.

------
nettletea
I can't even use my Windows 8.0 on my 32 inch TV that is 1080 sitting a couple
of metres away, while keeping the resolution and boosting all the
accessibility settings to the max.

Even the metro Apps I can't use.

I'd need a 50ft display! It's another facet of display/accessibility issues.

I had high hopes after Media Centre, that Windows would get this right. And
bought Windows 8.0 specifically for this purpose. Disappointing. I'm forever
going over to the TV and my neck hates it.

Personally I think part of the solution is to change the menuing system,
breaking it out from the window. If I can at least use the menus/controls on
apps I have a good chance of using them.

~~~
teh_klev
Wierd, I've got my Windows 8.0 laptop hooked up to my 40" Samsung 1080p telly
(bought in 2007) and it all looks good, even from ~3m away...and that's using
just the VGA input (Dell didn't stretch to a DVI port on their cheapo Vostro
1720 range back in the day).

~~~
nettletea
Well your eye sight is way better than mine. Metro apps are almost usable, the
desktop is barely usable (I have to walk over to the set, and that's with the
text size increased. I have a very small (not titchy) living room.

~~~
math0ne
That doesn't sound right. There is a special setting that lets you change the
size of metro apps, have you tried adjusting that?

~~~
nettletea
Yes.

------
ghusbands
I've had the pleasure of using a high-DPI display on Windows 7 for a while,
now. There are some tricks that help significantly:

1\. Calibrate ClearType to use as little color as possible (use the system
magnifier to help); this way, when apps get scaled the text is just blurry
rather than blurry with odd color-fringing.

2\. For apps that are incompatible but suitably configurable, set their
compatibility mode to disable HiDPI scaling and then set their font sizes (or
default zoom) to be larger. This works well for Chrome and Skype, at least.

3\. For those times when you momentarily have trouble, remember that the
windows key and the plus key will zoom your whole desktop.

------
codeulike
Remote desktop is really annoying on high dpi screens - the client cant scale
up (although it can scale down) so you end up with a tiny view of your server.

------
bluedino
Isn't the credit due to the choice by Apple (NeXT, actually) to go with
Display Postscript?

I'm sure they figured that as amazing as the resolutions of the original NeXT
monitor was (1120×832 in 1988), in the future it would be greatly exceeded.
Not to mention they wanted to be able to use the same routines to draw to a
300 or 600dpi printed paper as a 72dpi or whatever monitors were at the time.

~~~
wmf
OS X has never used Display Postscript (partly because they probably didn't
want to pay license fees to Adobe and partly because in a composited
environment with client-side rendering there's no need to marshal drawing
commands into text that looks like Forth). The OS X UI is full of bitmaps that
had to be redrawn for retina.

~~~
bluedino
Quartz2D, but the same idea.

------
tux10
This is one of the biggest reason I just can't move away from my regular DPI
laptop. Every time I have tried a HiDPI display with Windows it is painful.
Text looks great but icons and widgets look like shit. Things get better with
every new version of Windows but Microsoft have been promising true DPI
independence since Vista yet things are still crap.

~~~
ZoFreX
Back in Windows 3.1 and Windows 95 I remember this stuff actually working
quite well, a lot of people I knew were running Windows with non-default DPI
settings. As newer versions came out, and also as people started using third
party GUI toolkits more and more, things started getting less consistent.

~~~
kolme
I think those old settings only concern fonts. Icons and other pixel-measured
things would still look ridiculously small (making it a mess of small-things-
with-big-fonts).

------
danudey
Changing your DPI settings on Windows can cause all kinds of strange issues. I
had a problem a few years back where my Windows 7 gaming theatre PC thing I
had set up and connected to my 1080p TV wouldn't work quite right;
specifically Star Wars: The Old Republic wouldn't launch, and would crash on
loading.

I couldn't figure out what the problem was, and googling was no help until I
stumbled across the dumbest advice I'd ever seen: change the text scaling.
Once I set it back to 100%, the game loaded fine. Frustrating, because at 100%
I couldn't read _any_ of the other text, which meant that if I wanted to play
the game I basically had to navigate by icon and give up on reading dialogue
boxes unless I wanted to sit on my coffee table instead of my couch.

------
forrestthewoods
I'm actually impressed that windows apps support it at all. I didn't realize
it could actually work properly if programs took the time to do it right. With
High-DPI monitors finally coming out I'd expect dramatically improved support
moving forward.

------
OrwellianChild
As someone who prefers high-DPI screens for workflow management across
programs (spreadsheets, web layout, graphic design, etc.), this scaling
problem in programs is a frequent frustration.

Particularly working with media (DSLR images or 1080p video), it is difficult
to scale GUI to a readable level while viewing the media itself at an un-
scaled 1:1 pixel level. Do any editing suites for photo/video do this well?
I'm talking about an un-scaled video window with a GUI that scales/wraps to an
arbitrary window/screen size...

------
spitfire
I always liked what SGI Irix did. From the get go the desktop was all vector
based. So you could run at 800x600 or 1280x1024 and either way things would
look normal.

Both OS-X and Windows solutions are a hack.

~~~
0x0
How did icons and stuff look, then? I thought vectors aren't the silver bullet
they are made up to be especially for small/lowres graphics. Case in point,
all the crazyness with fonts and hinting etc to make sure they look good in
12px.

~~~
mrpippy
The icons were vectors, but typically drawn at an isometric view and combined
with other components (like the "sheet of paper"/"magic carpet" underneath
apps). When you click once to select the app, the paper turns yellow. When you
double click, the paper back and up behind the icon.

A screenshot of the Icon Catalog:
[http://techpubs.sgi.com/library/dynaweb_docs/0650/SGI_Admin/...](http://techpubs.sgi.com/library/dynaweb_docs/0650/SGI_Admin/books/PCP_UAG/sgi_html/figures/a12193.gif)

And the docs for IconSmith, used to draw icons:
[http://techpubs.sgi.com/library/tpl/cgi-
bin/getdoc.cgi/0650/...](http://techpubs.sgi.com/library/tpl/cgi-
bin/getdoc.cgi/0650/bks/SGI_Developer/books/IIDsktp_IG/sgi_html/ch12.html)

And Motif was used for all the widgets, I guess that would make it vector-
based.

------
nycticorax
It's funny that, in an article describing issues with a high-DPI display, the
author never explicitly says the size of the screen (e.g. in inches), or the
DPI. He just tells us it's 3200x1800. In case you were wondering, the display
on the Lenovo Yoga 2 Pro is a 13.3", 16:9, 276 DPI display. Personally, I find
this description more immediately useful than saying that it's a 13.3",
3200x1800 display.

------
zokier
I guess the best way to solve this would be to (partially) ignore the dpi
awareness flag in applications and instead apply a series of heuristics and
white/blacklists (with user override) for determining if applications truly
are hidpi capable. That would be bit of a pita for the applications that
actually do support hidpi properly now and might get still bitmap scaled, but
that would be just a temporary issue.

~~~
rbanffy
What bothers me is that this crisis has been obvious since well before Apple
started releasing their Retina screens on mobile devices. X has 75 dpi and 100
dpi fonts for a reason and we had 2D acceleration on every decent computer for
what? 15 years?

We've been using pixels as size units for no reason other than laziness.

~~~
seanmcdirmid
Vector rendering is still not advanced enough to completely (or even mostly)
replace bitmaps. Until they are, we'll have to redline our bitmaps for each
resolution manually. It's not just a matter of laziness.

~~~
marcosdumay
> Vector rendering is still not advanced enough to completely (or even mostly)
> replace bitmaps.

Wait, what?!? Vector rendering matured before bitmaps were common place. They
are faster and use less memory, that's why programmers of the 70's and 80's
loved to use them.

Bitmaps are easier. That's the only reason people use them. And only in a
world where everybody gets images on the same size and resolution.

~~~
seanmcdirmid
Your information is just plain wrong.

My wife does a lot of pixel redlining at her job: the artifacts they produce
are all done in Illustrator, a vector program. And believe me, they would love
to leave them as vectors...less work for them! However, they must be converted
to bitmaps and manually redlined to eliminate sub-pixel alignment problems.

Bitmaps are not easier, otherwise the designers would be cranking out pixels
directly in Photoshop and not Illustrator. The fact that NO ONE has produced a
decent general purpose vector renderer that avoids pixel artifacts, even a non
real-time one, means that my wife will be redlining for quite a few more
years. Even font rendering (arguably simpler than icons) requires substantial
hinting to be effectively resolution independent.

~~~
rbanffy
The high density displays we are starting to see may end up solving the
artifact problem - we won't be able to discern individual pixels for much
longer.

The other problems: elements that vanish, such as lines and thin structural
rectangles, would require some pixel-related restrictions in their definition.
I'm not sure vector programs are able to deal with them right now, but it
would be useful.

~~~
seanmcdirmid
Right. I was replying to parent in that we don't still do bitmaps because we
are lazy. Quite the contrary: we have moved to vector-based tools for
producing application art assets and would love it if we could just output to
SVG or something similar and be done with it. However, the current reality is
that we still have to convert our vectors manually to bitmaps, even those for
high res screens. Rasterization is just still not good enough to do the job
automatically (it works fine for objects in motion where the imperfections
aren't very noticable, but not those that don't move).

------
maaarghk
I have a 166 dpi laptop at the moment and yes, windows was pretty bad. Only
recently found out about the dpi settings thanks to a commenter here.

On another note I _really_ want that laptop!!

------
CaRDiaK
I got IntelliJ running really slick and smooth in QHD+.

Set the compatability to disable scaling for hidpi. Then just set the text in
settings to be 26pt.

I know have a retina looking IDE on my Ativ Book 9 Plus.

------
blueskin_
Is this guy having a laugh?

Every time I've upgraded my monitor, I've found it easier. If you don't want a
window to be wider than a certain point, don't make it wider. Myself, whenever
I see apple users, I see them with these tiny narrow windows with nothing else
on screen, which I have never understood.

That said, I always value vertical resolution - I have never bought a
1920x1080 monitor as 1600x1200 is so much nicer, or 1920x1200 for the wider
aspect ratio.

~~~
redial
I guess you didn't read what he wrote.

He is not complaining about the windows being to wide, he is complaining about
the scaling that Windows 8 applies when it detects a High DPI screen, that
makes every element inside a window either too large or too small, or
sometimes both, breaking the original design and fluidity of the application
and rendering it unusable.

And your point about Apple users..well, I don't know what was your point about
Apple users.

~~~
pmelendez
His point about mac users is that they tend to divide their screens in tiles
while windows users tend to maximize the windows and switch between them. I
found myself doing that on a mac too (I used to have a machine of each OS on
my desktop) and was mostly because I never get used to the dock or exposé or
even the way MacOS maximize windows

~~~
redial
I don't think that is what he wrote, but anyway, what you say has to do with
how each OS works and neither is inherently bad. I do think however that the
way Windows maximizes applications is more consistent, which is always better.
Maybe that is why on a Mac one tends not to maximize a window as often as on
Windows.

------
darkr
s/ a High-DPI desktop lifestyle can//

