I’ve been wondering about the V and its resolution. I would like to find out if it will be usable at integer UI scaling factors, or at lower resolutions divided by an integer. That is because I find it really annoying when you have to choose a custom scale or resolution and everything looks blurry.
The question is: Will the V be usable with integer scaling or integer resolutions?
We’ll see that very soon, but I thought it would be good to know in advance, and fun (er… kind of) to calculate.
Let’s dive into the numbers, using this DPI calculator and a spreadsheet.
So, as far as I know the V’s Sharp screen is:
12’’ physical size
You will say “287 ppi is a lot, you won’t even notice the interpolation blur”. Well, the screen is already very Sharp (already an old joke here, I now ) but I would want the content to be as sharp as it should be in such a great screen. Otherwise is like getting a Ferrari and using second hand cheap tyres on it.
First assumption: almost no one will be using 1x UI scaling with native resolution. Everything will be TINY. We’ll see how tiny later on.
Let’s take the height of the Windows taskbar at a non-HiDPI screen as a reference, so you can take a ruler and compare all the measures with your current screens. This are the values in my laptop’s screen:
40 px high Windows 10 taskbar = 1 cm (0,39’’) high
That UI size is perfect for me, but it could be a bit smaller or bigger. If you take a ruler and measure your taskbar, it will probably be closer to 1,2 cm (0,47’’).
In the V, the physical screen pixels are around 2,54x smaller. So our 40px sidebar will also be 2,54x smaller, taking only 0,39 cm (0,15’’) of screen height. That’s TINY for most people. Agree?
First scenario: Changing screen resolution + not using UI scaling
This scenario will make sense sometimes. You may be using software that doesn’t scale well, or you will be playing some games. The V won’t handle many games at 2880x1920, so you will want to lower the “digital” resolution… but you will still have a 2880x1920 physical resolution.
In that scenario, you don’t want to use a resolution that is the physical resolution divided by a non-integer. Take this example:
2880x1920 divided by, let’s say, 1920x1280 = 1,5. That means each digital pixel will be using 1,5 physical pixels. So a 1px black line on a website will be 1,5 physical pixels wide in your screen. As you can’t get a pixel to show half white, half black, at least one pixel will probably be shown as grey. And the line will look less sharp, like blurred.
To avoid that, we want to divide by integers:
- 1 digital pixel --> 1,5x1,5 physical pixels = 1920x1280 = 154 PPI = 0,73 cm (0,29’’) sidebar
- 1 digital pixel --> 2x2 physical pixels = 1440x960 = 154 PPI = 0,78 cm (0,31’’) sidebar
- 1 digital pixel --> 3x3 physical pixels = 960x640 = 96 PPI = 1,17 cm (0,46’’) sidebar
- 1 digital pixel --> 4x4 physical pixels = 720x480 = 72 PPI = 1,6 cm (0,63’’) sidebar
Notes on the warnings: 96 DPI is around your average screen’s DPI. 72 would mean very big and visible pixels, and the interface would be too bulky, so you’d better not use 720x480. So…
- 1440x960 = Nice, on the smaller side for the interface
- 960x640 = Also OK, on the bigger side for the interface
Will the OS and the usual games support those resolutions? I hope so!
Second scenario: Keeping screen resolution + using UI scaling
In this scenario (which will be the usual one), we will want to keep the super-sharp 2880x1920 resolution to amaze our non-HiDPI-device-owning friends and see every little detail. But we will also want to tell the system to make the elements of the interface bigger, in order to, well, see them.
So we want our 0,39 cm Windows 10 sidebar to look closer to 1 cm. Again, using integers:
0,39mm x 1 = 0,39 cm (0,15’’) = Not usable, unless you love tiny little cute unclickable icons
0,39 mm x 2 = 0,78 cm (0,31’’) = Quite OK, on the smaller side
0,39 mm x 3 = 1,18 cm (0,46’’) = Also OK, on the bigger side
0,39mm x 4 = 1,56 cm (0,61’’) = That’s usually too big for UI elements
OK, I’m not that worried anymore. Now we know we can use integer scaling and lower “integer” resolutions while keeping the UI at decent sizes. Phew!
That’s good news for everyone, but also especially for Linux users, as most Linux desktop environments are not fully supporting fractional scaling nowadays.