
Windows 8.1 DPI Scaling Enhancements - barista
http://blogs.windows.com/windows/b/extremewindows/archive/2013/07/15/windows-8-1-dpi-scaling-enhancements.aspx?utm_source=twitterfeed&utm_medium=twitter
======
MichaelGG
I didn't see anything in there about the real problems with DPI scaling: Most
third party apps break in odd ways. It seems that whatever layout system a lot
of program use, it somehow combines absolute pixel sizes with auto-scaled
fonts and buttons, so you end up with dialogs getting clipped up. It's not
always noticeable or problematic at "125%" (I think some popular laptops
shipped with this setting), but at 150%+, many apps break.

If Windows had an option to somehow detect this and let the app render
unscaled, then apply interpolation, it'd be better than the current state of
affairs.

~~~
Negitivefrags
It does, and that is the default way that windows scales applications unless
they specifically add to their application manifest that they support High
DPI.

Using High DPI myself I have never experienced what everyone else seems to be
talking about with applications breaking. (Unless you are talking about
Windows XP)

~~~
JosephHatfield
One example app that misbehaves for me on a high-DPI monitor is Camtasia
Recorder 7 Specifically, it records an area of the screen that is offset up
and to the left of the area indicated by the displayed boundary rectangle.
Ableton Live 9 for example has trouble tracking the mouse correctly after
clicking and dragging on some controls.

~~~
cbhl
I've actually found that there's a setting (in Mouse, I think?) about
projectors and pixels that seems to alleviate this.

------
jmuguy
Probably one of the biggest complaints we get from our IT clients. Really
frustrating for someone that isn't familiar with the issue because all they
can articulate is that either they can't fit anything on the screen (low
resolution) or can't read anything. I always assumed it wouldn't matter what
MS did because x, y, z 3rd party application wouldn't implement it but its
always been irritating that MS' own applications don't work correctly with the
current options.

------
edandersen
I've tried this out and it is a disappointment. 8.1 doesn't actually switch
the rendering of the app to a different percentage scale when switching
displays, it just scales the app rendered at the previous scale.

What happens is a "target" scaling percentage is set - any monitors that
roughly match that percentage/DPI get a 1-1 pixel mapping of how apps
currently render at 125%/150% etc. Monitors that have a greatly different DPI
(for example, a Surface Pro internal screen) then have a _scaled_ app. For
instance, the app renders at 125% (the "target" percentage) and is then scaled
down or up by the graphics card to the scale percentage for displays that
don't match the target percentage. This is never a nice pixel double or
halving that OSX carries out, but always a blurry mess, scaling up or down.
The taskbar is not scaled at the moment either, rendering at the target
percentage scale on _all_ displays, so you get a mini or a large taskbar on
the mismatched display.

They would be much better off rendering everything at 200% and scaling down,
like OSX.

~~~
hetman
Could you explain what you mean? In Windows The GUI itself is scaled but it is
still rendered at the native resolution of the display. Resampling virtual
resolution pixels to physical pixels is the OS X approach.

Edit: It appears that Windows applications that don't support the High DPI
interface are rendered then resampled as you say. So it's up to the app
developer to support scaling, although you can disable the app resampling
behaviour on a per app basis too.

------
Osmium
I don't find Windows 8 too bad as is -- I have it set to the true display
resolution on my MBPr, but with font scaling (150%?). Works for most apps
while some have tiny text but it isn't too bad. Everything's crisp at least,
and all the Metro UI is fine.

That said, I don't use it too much, so I can't say how irritating it would be
on a regular basis.

------
gnoway
So it looks like they've done what they can without completely overhauling how
they scale things. You can have different scaling values for different parts
of your application.

What is the right way to solve this issue, keeping performance in mind, if you
get to build everything? I'm pretty graphics-ignorant so I'm mentally stuck at
'do something with vector graphics'.

~~~
georgemcbay
The default way this is done on Android is having multiple bitmaps rendered at
different pixel sizes for different DPIs (similar to the way mipmaps work in
3D texturing, if you're familiar with those) and then the OS chooses the one
closest to the display DPI and resamples it as needed to get the desired final
size based on the actual display DPI.

Eg:

You have some icon, you might provide bitmap versions of it at: 8x8, 32x32,
64x64, 128x128, 256x256 (the exact sizes depend upon the desired size of the
image when displayed combined with what DPI ranges you want to support well).

Based on your layout, the final pixel size occupied by that icon control might
be 200x200 on a high res tablet, the OS will choose the 256x256 bitmap and
downsample it slightly to fit 200x200. The same icon area might be 60x60 on a
phone, so it'll chose the 64x64 and downsample that one a bit to fit 60x60.

I haven't done much iOS programming, but from what I understand it works
pretty much the same except the sizes are more fixed at 1x/2x/4x because there
is less DPI variation across iOS devices.

This way has downsides (makes the assets larger since you have multiple copies
of each one), but generally works pretty well in practice and actually works
better than vectors for some things (though vectors can scale up and down at
will, if they aren't heavily 'hinted' you can easily lose important details
that you don't want to lose at small sizes, with pre-rendered bitmaps you can
adjust for this ahead of time).

------
otterley
I don't know a whole lot about GUI programming, but how come resolution
independence never took off? For example, "make this element some proportion
of the screen width/height", "make this element exactly N cm/mm/inches/pica
wide/high".

~~~
wmf
It means everything in your UI pretty much has to be vectors, which is
certainly possible (it's done in games) but UI designers and the tools they
use generally aren't used to working that way. Many UI elements would have
non-integer thickness and thus would either look blurry due to antialiasing or
lumpy due to pixel fitting. And you'd have to deprecate pretty much all of the
existing pixel-based APIs and then wait 10-20 years for apps to migrate off
them.

~~~
otterley
On super high-resolution displays, would it really be that bad? I can't
imagine rounding errors being that significant on a Retina-quality display. In
fact, it was never a problem on 300DPI laser rendering back when I worked in
the publishing world.

Am I mistaken?

~~~
ics
To some degree I think you're correct, but until there are _only_ retina
displays on the market we need a solution that works _well_ for both. Everyone
looks forward to the day when designing a font doesn't mean spending half your
time hinting for those pesky ~85ppi displays, but we're off to a pretty slow
start. The first real step in my opinion is to bring real vector support to
the web (now that it's reasonably well supported across browsers) but that
requires designers to adjust their workflow (and preferably own their own
retina displays to test with).

~~~
bluedino
We won't have to make fonts for Retina - we already did, they're (usually)
designed to be printed which is much higher DPI than a Retina display.. It
wasn't until Windows XP when Microsoft said "Let's make fonts that look great
on the screen, at low resolution"

~~~
ics
Yes, that was my point (except it wasn't just XP– hinting was/is a PITA on any
platform). These days we still have to make them look as good as possible on
both, but if you're also targeting printed media then you're already set when
high PPI displays are the norm.

------
xutopia
I can't see a price for the 4k screen they refer to. Anyone know how much
these cost?

~~~
ChuckMcM
ASUS's 4K screen is $3,500. The Sony one at Fry's was $4,995.

------
owenwil
This is a real crock, it's terrible. Microsoft's own applications don't even
scale properly - and fonts can't scale at all. I use a Surface Pro @ 1080p and
two external displays @ 1080p and fonts are blurry in apps like Windows
Explorer, Outlook, Word, because the font scaling is so horribly broken. I
don't understand why they can't fix this.

~~~
robododo
I don't think it's font scaling. It's a fundamental change to the font
renderer. Basically, subpixel rendering is gone and it's all grayscale.

[http://answers.microsoft.com/en-
us/ie/forum/ie10-windows_8/w...](http://answers.microsoft.com/en-
us/ie/forum/ie10-windows_8/windows-8-fonts-in-metro-ui-and-
ie-10-blurry/3c29c415-54fd-44c8-b290-1c01dd05beaf)

I've not played with 8.1 yet, but hopefully it's been addressed.

~~~
rayiner
Subpixel rendering makes no sense on a tablet where the direction of the
subpixels changes from landspace to portrait mode.

~~~
eurleif
Couldn't the subpixel hinting change too?

~~~
rayiner
You can, but the point of subpixel rendering is increasing effective
resolution, and for English text, horizontal resolution is more useful than
vertical resolution. See:
[https://www.grc.com/ctwhat.htm](https://www.grc.com/ctwhat.htm).

~~~
astrodust
It's not just English text, it's virtually every written language. There are
very few that use a vertical orientation, and fewer still that use _only_ a
vertical orientation.

Hebrew, Georgian and Arabic all benefit equally from sub-pixel resolution.
Even vertical Chinese would be improved by having more detail on each
character.

------
mung
What the hell is a "normalized 1-foot DPI value"? DPI is an absolute
measurement.

------
msoad
I like how Chrome OS handles this problem. Ctrl+Shift+Plus to zoom entire OS!

~~~
aarongolliver
<windows> \+ <+>

put in in fullscreen mode

------
zw
Heh. It works so very very badly.

------
mtgx
The Windows high resolution "support" is done in such a bad way, and I think
Windows has the worst possible type of support for higher resolutions out of
_all_ the operating systems. They're only making _some_ items "larger" to
appear "normal" under the big resolutions. But all the other stuff won't.
Plus, what are they going to do for 4k displays? Increase it to 300%?

They should've done it like Apple did it, and it would've been much more
streamlined and would make a lot more sense. Here's how they should've done
it.

With resolutions higher than 1080p you shouldn't actually get more density in
terms of content per screen real estate (what's the point of that? 1080p makes
things small enough as it is). Instead they should only support resolutions
after 1080p that are _exactly_ "double" (or 4x the pixels) of the lower
resolutions. This way, those high resolution displays, can use the "effective"
lower resolution.

So 2732x1536 -> effective 1366x768

3200x1800 -> effective 1600x900

3840x2160 ("4k") -> effective 1920x1080

This is the best way to jump to higher resolutions and easiest way to support
them at the OS level, instead of these icon scaling "hacks" that Microsoft is
implementing.

~~~
dmethvin
Apple was able to do it the way they did because there are so few choices in
Apple hardware. Sure the "double-or-nothing" approach simplifies things but
it's not a practical approach for large ecosystems like Windows or Android
where the resolutions vary a lot more.

~~~
wmf
Arguably if Windows only supported double-or-nothing, the PC vendors would
just start shipping appropriate screens.

~~~
Osiris
But that would only work on new hardware, not on the millions of existing
machines that people will upgrade, which means it would still have to support
the old resolution model to support older machines and thus the incentive for
hardware makers to put on higher resolution screens would be reduced since
they could get away with older crappy screens.

