Finding the optimal UI scaling and resolutions for the V

Hi there!

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
2880x1920 resolution
287 ppi

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 :sweat_smile:) 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:

1440x900 resolution
113 ppi
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 :x: = 1920x1280 = 154 PPI :white_check_mark: = 0,73 cm (0,29’') sidebar :white_check_mark:
  • 1 digital pixel → 2x2 physical pixels :white_check_mark: = 1440x960 = 154 PPI :white_check_mark: = 0,78 cm (0,31’') sidebar :white_check_mark:
  • 1 digital pixel → 3x3 physical pixels :white_check_mark: = 960x640 = 96 PPI :white_check_mark: = 1,17 cm (0,46’') sidebar :white_check_mark:
  • 1 digital pixel → 4x4 physical pixels = 720x480 = 72 PPI :warning: = 1,6 cm (0,63’') sidebar :warning:

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 = :white_check_mark: Nice, on the smaller side for the interface
  • 960x640 = :white_check_mark: 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’‘) = :warning: Not usable, unless you love tiny little cute unclickable icons
0,39 mm x 2 = 0,78 cm (0,31’‘) = :white_check_mark: Quite OK, on the smaller side
0,39 mm x 3 = 1,18 cm (0,46’‘) = :white_check_mark: Also OK, on the bigger side
0,39mm x 4 = 1,56 cm (0,61’') = :warning: 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.


I assume you are talking about videogames:
It depends on the videogame. Some will have the issue, some won’t. Some will offer to scale the UI to compensate, most will not. It really depends on the videogame.

If you are not talking about videogames:
Most programs will run just fine. Notable exceptions are usually found in development tools, that for some reason are still a bit behind.

I will probably run the screen at full resolution most of the time, resorting to 1440x960 for videogames or for some development tools.

I was talking about the OS itself and any programs. Most programs will run just fine… but only if they scale up the interface. Otherwise, you will just get tiny and unusable interface elements. That’s just what I meant by saying that “almost no one will be using 1x UI scaling with native resolution”.

In games, as you say, you will either change the resolution, or will handle (or not) the scaling of its UI elements to make itself usable.

BTW, for those wondering what’s the problem with using fractional scaling (like 1,5x, 1,75x, etc.), here’s a good article explaining everything about it.

Here is an image from the article, visually explaining the issue. From left to right 1×, 2×, and 1.5× scaling drawing a 1px dot:

1 Like

Well, you see, the tablet itself is quite small. So if you scale it up so that the taskbar is 1cm, it will be difficult to fit anything on the screen… All the working area will be taken by window decorations and so on.

I’m using my 11" 1080p tablet with 100% scaling, and I find that the perfect amount of scaling. sometimes I wish something was just a tad larger, but everything is readable and usually I’m comfortable with it. Remember, you usually look at a tablet screen from a closer distance than at a desktop monitor…

If you scale the V resolution down twice, you’ll get 960p. That is lower than 1080p, so hardly enough for me. Especially when it’s 3:2, so not only the height but also (and especially) the width is lower. It’s just my opinion, but this resolution is almost too low to work on.

So, I really don’t know what I’m gonna do with this screen lol… But I guess there is no better solution than 960p… (I hate blur)

1 Like

Sooooo. What’s the point of having a high res screen?

Wow, that’s pretty small! I’m using a 1080p 13’ screen with 1x scaling and I find that already to be on the lower limit.

It’s true that you get used to it quickly, and that in tablet mode you are somewhat closer to the screen. The V will also be used in laptop mode, so I guess 2x scaling should be OK for most people, and easier to tap with the fingers. But for you it will definitely be a big jump UP!

In general you get a lot of marketing hype (I fear that’s the main reason manufacturers are using them), weird UI scaling issues and also real sharpness. Even if the UI is scaled up, you will see lines, texts, pictures and vector icons MUCH sharper. That’s the main point.

But if you depend on programs that can’t be scaled properly or can’t be used at high resolutions with a low power integrated GPU, like games… then yes, a HiDPI screen is useless because you have to use lower resolutions anyway.

Well for games i can understand that, but games weren’t the topic here

That is true if you use Windows DPI scaling and apps that have proper support for it. That is not true if you just set a lower resolution. Even if it’s exactly two times lower. So basically the second part of your comment applies, because most desktop apps suck at scaling. Even Windows’ built-in utilities…