I just needed to install the drivers for my graphics card, and I can get more display sizes in the settings display section, silly me!

Linux display

This is detailed in depth on how does Linux's display works? QA.

On most desktops system (like KDE or Gnome) there are settings available on their respective settings panel, this guide is for additional/manual settings that can be applied to scale an application or the whole desktop. This reference article have many valuable informations for the matter.

Scaling applications

Scaling application can be done mainly via DPI, specific environment variable (explained bellow), application own setting or some specific desktop setting (out of scope of this QA).

• Qt applications can be scaled with the following environment variables, note that many applications are hard-coding sizing and font and thus the result on such app may not be as expected.

  export QT_AUTO_SCREEN_SET_FACTOR=0
  export QT_SCALE_FACTOR=2
  export QT_FONT_DPI=96
  

• Gnome/GTK applications can be scaled with the following environment variables

  export GDK_SCALE=2
  export GDK_DPI_SCALE=0.5
  

• Gnome/GTK can as well be scaled globally with this Gnome setting

  gsettings set org.gnome.desktop.interface text-scaling-factor 2.0
  

• Chromium, can be scaled with the following command

  chromium --high-dpi-support=1 --force-device-scale-factor=1.5
  

• Xpra (python) can be used along with Run scaled to achieve a per app scaling.

• Environment variables modification can be placed in ~/.profile for a global and automatic appliance after login.

Scaling the desktop with Xorg X11

Xorg's extension RandR have a scaling feature and can be configured with xrandr. This can be used to scale the desktop to display a bigger environment, this can be useful for HiDPI (High Dots Per Inch) displays.

RandR can also be used the other way around, example making a screen with 1366x768 max resolution support a greater resolution like 1920x1080. This is achieved by simulating the new greater resolution while rendering it for the supported max resolution, similar to when we watch a Full-HD video on a screen that is not Full-HD.

Scaling the desktop without changing the resolution

• Getting the screen name:

  xrandr | grep connected | grep -v disconnected | awk '{print $1}'
  

• Reduce the screen size by 20% (zoom-in)

  xrandr --output screen-name --scale 0.8x0.8
  

• Increase the screen size by 20% (zoom-out)

  xrandr --output screen-name --scale 1.2x1.2
  

• Reset xrandr changes

  xrandr --output screen-name --scale 1x1
  

Scaling the desktop and simulate/render a new resolution

When using xrandr to "zoom-in" with the previous method, the desktop remain full screen but when we "zoom-out" with for instance xrandr --output screen-name --scale 1.2x1.2 (to get an unsupported resolution) the desktop is not displayed in full screen because this require updating the resolution (to probably a higher unsupported resolution by the screen), we can use a combinaison of --mode, --panning and --scale, xrandr's parameters to achieve a full screen "zoom-out" scaling (simulate a new resolution), example:

• Get the current setup

  xdpyinfo | grep -B 2 resolution
  # or
  xdpyinfo
  

• Configuration example

  Scaling at:                      120%
  Used/max screen resolution:      1366 x 768
  Resolution at 120% (res x 1.2):  1640 x 922 (round)
  Scaling factor (new res / res):  1.20058565 x 1.20208604
  

• The idea here is to increase the screen resolution virtually (because we are limited to 1366x768 physically) the command would be (replace screen-name):

  xrandr --output screen-name --mode 1366x768 --panning 1640x922 --scale 1.20058565x1.20208604
  

• Reset the changes with

  xrandr --output screen-name --mode 1366x768 --panning 1366x768 --scale 1x1
  
  # restarting the desktop may be required example with KDE
  # kquitapp5 plasmashell
  # plasmashell &
  

Making xrandr changes persistant

There is a multitude of methods to make xrandr changes persistant, this and this QA have many examples.

Experiments notes

As a side note and experiments result while using SDDM + KDE, and after many tests to achieve a persistant config, I ended up loading a script with ~/.config/autostart (systemsettings5 > Startup... > Autostart), and naming my script 00-scriptname to make it run first.

# 00-scriptname

# Applying the main xrandr suited changes (scaling at x1.15)

xrandr --output eDP1 --mode 1366x768 --panning 1574x886 --scale 1.15226939x1.15364583

# This is where it get odd/complicated, sometimes the screen resolution is not applied correctly or not applied at all... 
# Note that "xrandr --fb" can be used alone to change the screen resolution on a normal situation... 
# Here we will be taking advantage of xrandr's "--fb" feature to make the config appliance stable and works every-time.

# The odd thing here is while re-applying the new resolution 1574x886 with "--fb" nothing happen, but 
# if we use use an unsupported resolution like 1574x884 (vs 1574x886) then xrandr force the resolution 
# to "reset itself" to the configured resolution (1574x886)... 

# In short just re-apply the setting with "--fb" and an unsupported resolution to force a reset.
# ("--fb" can be used alone here without re-applying everything)

#xrandr --fb 1574x884 
xrandr --fb 1574x884 --output eDP1 --mode 1366x768 --panning 1574x886 --scale 1.15226939x1.15364583

References

Some KDE's gui tools: systemsettings5 > display, kcmshell5 xserver and kinfocenter.

Enter the following commands in a terminal to enable 1920x1080 resolution:

xrandr --newmode "1920x1080"  173.00  1920 2048 2248 2576  1080 1083 1088 1120 -hsync +vsync
xrandr --addmode Virtual1 1920x1080
xrandr --output Virtual1 --mode 1920x1080

This will set your display resolution to 1920x1080 and also enable several other 16:9 aspect ratio resolutions in the display settings.

Remember that you may have to enable full screen mode in VMWare before these resolutions become selectable.

This works fine in my case, using 3k notebook and 1600px monitor with different scale:

1. Open dconf Editor.
2. Go to /org/gnome/mutter/experimental-features
3. Disable "Use default value"
4. Write custom value: ['scale-monitor-framebuffer', 'x11-randr-fractional-scaling']

Now you can use different scale for each screen in the display settings.

Scale 200% in screen 3000x2000px

Scale 100% in secondary screen 1600x900px

Tested in Ubuntu 19.10, GNOME 3.34.2.

For KDE 5.28 on (K)ubuntu 16.04 (screenshots from Kubuntun 18.04), I've needed to set both Display scaling under System Settings → Display and Monitor → Display Configuration → Scale Display:

And I've needed to set the font dpi manually under System Settings → Fonts → Force fonts DPI:

That helped for KDE applications, but also e.g. for Firefox and Chrome.

Ubuntu or the other versions of it like (k,l,x,edu,etc.,) are required to add the resolution we want to set on some monitors.

So follow my steps:-

1. Open a Terminal by CTRL+ALT+T

2. Type xrandr and ENTER

3. Note the display name usually VGA-1 or HDMI-1 or DP-1

4. Type cvt 1920 1080 (to get the --newmode args for the next step) and ENTER

5. Type sudo xrandr --newmode "1920x1080_60.00" 173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync and ENTER

6. Type sudo xrandr --addmode VGA-1 "1920x1080_60.00" and ENTER (replace VGA-1 with your display type (step 3) like HDMI-1 or DP-1)

7. Now close the terminal and go to Settings >> Display settings and change it to 1920x1080

8. Enjoy FHD.

To make the above settings stick when you restart your computer, do the following.

For integrated displays

• goto your terminal and type vim ~/.profile ENTER
• Paste in the shell command from step 5 and 6, then save.

For external displays

• create a script called external_monitor_resolution.sh in the directory /etc/profile.d/. using sudo vim /etc/profile.d/external_monitor_resol.sh.

• Paste in the shell command from step 5 and 6, then save.

(Note: if using sudo would require you typing a password, your system might freeze on startup while waiting for you to input a password. So when pasting do away with the sudo) Something like this:

xrandr --newmode "1920x1080_60.00"  173.00  1920 2048 2248 2576  1080 1083 1088 1120 -hsync +vsync
xrandr --addmode VGA-1 "1920x1080_60.00"`

and ENTER (replace VGA-1 with your display type (step 3) like HDMI-1 or DP-1)

Normally, these settings are in Settings --> Display and Monitor --> Displays --> Scale display.

1280x1024 and you need to scale down? My desktop screen is that resolution and I still use Dejavu Sans size 11/12! But I have bad sight.

The problem here seems to be that Swing is by default claiming that it is DPI aware, so windows doesn't scale it. Use this switch to turn off this behavior and windows will start scaling your swing app:

-Dsun.java2d.dpiaware=false

[EDIT: Unfortunately, this flag no longer seems to work in Java 8, I was testing it in Java 6. Looks like this is a known issue.]

[EDIT 2: You can modify a Java 8 install to work correctly, using a program to modify the EXE manifests. I changed the setting from true to false in the manifests inside of java.exe and javaw.exe, and now my Swing programs scale correctly in Windows 10 high dpi. I used Resource Tuner to this.]

[Edit 3] Just use Java 9

Install the Hyper-V Integration Services. This provides better display/input/network integration between the guest and host.

Here are the steps you need to add a new custom resolution and apply it. Following steps are for adding a 1920x1080 resolution, but you can use it for any other resolution you want. But make sure your monitor and onboard graphics support that resolution.

# First we need to get the modeline string for xrandr
# Luckily, the tool "gtf" will help you calculate it.
# All you have to do is to pass the resolution & the-
# refresh-rate as the command parameters:
gtf 1920 1080 60

# In this case, the horizontal resolution is 1920px the
# vertical resolution is 1080px & refresh-rate is 60Hz.
# IMPORTANT: BE SURE THE MONITOR SUPPORTS THE RESOLUTION

# Typically, it outputs a line starting with "Modeline"
# e.g. "1920x1080_60.00"  172.80  1920 2040 2248 2576  1080 1081 1084 1118  -HSync +Vsync
# Copy this entire string (except for the starting "Modeline")

# Now, use "xrandr" to make the system recognize a new
# display mode. Pass the copied string as the parameter
# to the --newmode option:
xrandr --newmode "1920x1080_60.00"  172.80  1920 2040 2248 2576  1080 1081 1084 1118  -HSync +Vsync

# Well, the string within the quotes is the nick/alias
# of the display mode - you can as well pass something
# as "MyAwesomeHDResolution". But, careful! :-|

# Then all you have to do is to add the new mode to the
# display you want to apply, like this:
xrandr --addmode VGA1 "1920x1080_60.00"

# VGA1 is the display name, it might differ for you.
# Run "xrandr" without any parameters to be sure.
# The last parameter is the mode-alias/name which
# you've set in the previous command (--newmode)

# It should add the new mode to the display & apply it.
# Usually unlikely, but if it doesn't apply automatically
# then force it with this command:
xrandr --output VGA1 --mode "1920x1080_60.00"

Original source: https://gist.github.com/debloper/2793261

I also wrote a script that does all these steps automatically. You can try it out if the above steps seem too complicated for you: https://gist.github.com/chirag64/7853413