HiDPI

Related articles
Font configuration
HiDPI (High Dots Per Inch) displays, also known by Apple's "
Retina display
" marketing name, are screens with a high resolution in a relatively small format. They are mostly found in high-end laptops and monitors.
Not all software behaves well in high-resolution mode yet. Here are listed most common tweaks which make work on a HiDPI screen more pleasant.
Background
The terminology in this space can be misleading. Prior to HiDPI, the terms were:
Dots per inch
(DPI)—specifies the output density of ink droplets when printing a paper.
[1]
Higher dots-per-inch correspond to a more dense output.
Pixel density
,
pixels per inch
(PPI)—specifies the input density of a digital image.
[2]
Computed as
(number of pixels in image) / (physical size of the photo)
.
Every display has an intrinsic PPI as the ratio of native screen resolution to physical screen size.
[3]
Although some technical sources use the term "PPI",
[4]
it is much more common to (inaccurately) refer to this ratio as DPI. 96 DPI screens are regarded as comfortable for most people to read ~12pt font on, and is about where most "low-DPI" monitors fall. HiDPI screens are around 192 DPI and greater, with some screens falling in the middle ("medium PPI").
When using a HiDPI screen on a DPI-unaware system which assumes a DPI of ~96, small fonts will be uncomfortable to read. Since font rendering is relatively easy to adjust, even "DPI-unaware" systems (such as
#Wine applications
) often provide a knob for adjusting the font DPI. Whenever a DPI setting is exposed as a number (as opposed to a multiplier or a percentage), it is likely referring to the text rendering alone.
Most modern GUI toolkits are capable of "integer scaling", rendering the UI at least 2x size. This is achieved by applying a different font DPI as well as providing HiDPI versions of assets. Some toolkits also support fractional scaling, with GTK
#Fractional scaling
using a combination of applying arbitrary font DPI and downscaling graphical resources.
On a desktop which is otherwise using UI scaling, applications that lack
resolution independence
(such as
#Xwayland
) may render at 1x scale and then be scaled up by the display server.
Desktop environments
GNOME
To enable HiDPI, navigate to
Settings > Devices > Displays > Scale
and choose an appropriate value. Or, use gsettings:
$ gsettings set org.gnome.settings-daemon.plugins.xsettings overrides "[{'Gdk/WindowScalingFactor', <2>}]"
$ gsettings set org.gnome.desktop.interface scaling-factor 2
Note
By default, GNOME only allows integer scaling numbers to be set.
1
= 100%,
2
= 200%, etc. See
#Fractional scaling
below.
Fractional scaling
A setting of
2
,
3
, etc, which is all you can do with
scaling-factor
, may not be ideal for certain HiDPI displays and smaller screens (e.g. small tablets). Fractional scaling is possible on both Wayland and Xorg, though the process differs.
Implementation was mainly discussed and decided in GNOME fractional scaling hackfest 2017, check
[5]
for more technical details.
Note
The factual accuracy of this article or section is disputed.
Reason:
The information below is subject to change. For more, please see
this online discussion
. (Discuss in
Talk:HiDPI
)
Currently, GTK only supports fractional scaling for fonts. On the other hand, widgets, like buttons or labels,
may only use integer (DPI) scaling
.  As such, fractional scaling for most native GNOME applications requires first rendering at a higher resolution, then downscaling to the requested resolution. GTK utilizes this technique in both Wayland and Xorg sessions.
For some setups
running GTK 3 applications
, this can increase CPU and GPU usage and power usage, resulting in a less responsive experience - particularly in Xorg. If these issues are considerable in your use case, please consider using another desktop environment or deactivating fractional scaling.
Wayland
Enable the experimental fractional scaling feature:
$ gsettings set org.gnome.mutter experimental-features "['scale-monitor-framebuffer']"
then open
Settings > Devices > Displays
(the new options may only appear after a restart).
To enable the option for all users, create the following three files with the corresponding content
/etc/dconf/profile/user
user-db:user
system-db:local
/etc/dconf/db/local.d/00-hidpi
[org/gnome/mutter]
experimental-features=['scale-monitor-framebuffer']
/etc/dconf/db/locks/hidpi
/org/gnome/mutter/experimental-features
Then run
dconf update
and restart the machine. This will permanently lock the option.
Xwayland
As of Mutter 47.0
it is possible to enable native fractional scaling as an experimental feature.
Enable it by issuing:
$ gsettings set org.gnome.mutter experimental-features "['scale-monitor-framebuffer', 'xwayland-native-scaling']"
Text Scaling
Alternatively, or in addition to changing the display scaling, you can separately scale text. This can be done by navigating to
Fonts > Scaling Factor
in Gnome Tweaks, or using gsettings. Note that the text scaling factor need not be limited to whole integers, for example:
$ gsettings set org.gnome.desktop.interface text-scaling-factor 1.5
GTK+ vs Gnome Shell elements on Xorg
Adjusting the text scaling as per the above only affects GTK+ elements of the GNOME desktop. This should cover everything on Wayland. However, those on an Xorg session may find that they need to make further adjustments on HiDPI environments, since the GNOME Shell UI (including the top bar, dock, application menus, etc.) relies separately on the
St
toolkit. Note that this is a long-standing issue to which a
patch
has been merged and available for Gnome Shell 3.35 onward. For older releases, Xorg users can resolve most of the Gnome shell scaling problems by manually editing the shell theme that they are currently using. The relevant CSS files are normally located at
/usr/share/themes/YOUR-THEME/gnome-shell/gnome-shell.css
. Users should increase all "font-size" elements in this file in proportion to their display scaling (doubling font sizes for 200% scaling, etc.) For example, the top of an edited CSS file for the
adapta-gtk-theme
shell theme might look like:
/usr/share/themes/Adapta/gnome-shell/gnome-shell.css
stage { font-size: 20pt; font-family: Roboto, Noto Sans, Sans-Serif; color: #263238; }
Once these changes have been saved, activate them by switching to another theme (for example, using
gnome-tweaks
) and then reverting back again. The top bar, application menus, calendar, and other shell elements should now be correctly scaled.
In addition to editing the relevant shell theme's CSS file, users on Xorg may also wish to increase the title bar font at the top of open applications. This can be done through the dconf editor (
org > gnome > desktop > wm > preferences :: titlebar-font
). Note that the
title-bar-uses-system-fonts
option should also be turned off. Alternatively, use gsettings:
$ gsettings set org.gnome.desktop.wm.preferences titlebar-font 'Cantarell Bold 22' ## Change as needed
$ gsettings set org.gnome.desktop.wm.preferences titlebar-uses-system-font false
KDE Plasma
You can use Plasma's settings to fine tune font, icon, and widget scaling. This solution affects both Qt and GTK applications.
Note
Plasma 5.27
dropped
use of
GDK_SCALE
/
GDK_DPI_SCALE
variables and
switched
to
Xsettingsd
. It should be installed to make scaling work for GTK apps. Or you can set this variables manually as described in
#GDK 3 (GTK 3)
.
To adjust font, widget, and icon scaling together:
System Settings > Display and Monitor > Display Configuration > Global Scale
Drag the slider to the desired size
Restart for the settings to take effect
Note
If you are using xorg, and global scaling is set but not applied to Qt applications after reboot, please check if
xft.dpi
is set in
~/.Xresources
. If so, removing the variable and adjusting global scaling again may take effect.
However, using
X11
session, Plasma ignores the Qt scaling settings by default, which affects panels and other desktop elements. To make Plasma respect the Qt settings,
set
PLASMA_USE_QT_SCALING=1
.
Cursor size
To adjust cursor size:
System Settings > Appearance > Cursors > Size
Font scaling
To adjust only font scaling:
System Settings > Appearance > Fonts
Check "Force fonts DPI" and adjust the DPI level to the desired value. This setting should take effect immediately for newly started applications. You will have to logout and login for it to take effect on Plasma desktop.
Icon scaling
To adjust only icon scaling:
System Settings > Appearance > Icons > Advanced
Choose the desired icon size for each category listed. This should take effect immediately.
Panel scaling
To adjust only panel scaling:
Right click the panel, select
Enter Edit Mode
, and manually adjust
Panel height
.
Xwayland
As of Plasma 5.26, the Xwayland scale method can be chosen at the bottom of the
System Settings > Display and Monitor > Display Configuration
page.
In "Scaled by the system" mode, the X application will be rendered at 1x and then magnified (scaled) by KDE. This works for all applications, but causes blurriness due to the magnification.
In "Apply scaling themselves" mode, the X application will have to render itself at the appropriate size. This will avoid blurriness, but applications which aren't HiDPI-aware will render themselves at 1x scale and therefore will appear small.
See this
blog post
for details.
Xfce
Xfce supports HiDPI scaling which can be enabled using the settings manager:
Go to
Settings Manager > Appearance > Settings > Window Scaling
and select 2 as the scaling factor.
Go to
Settings Manager > Window Manager > Style
and select
Default-xhdpi
theme.
Alternatively, it is possible to do the same from command line using
xfconf-query
:
$ xfconf-query -c xsettings -p /Gdk/WindowScalingFactor -s 2
$ xfconf-query -c xfwm4 -p /general/theme -s Default-xhdpi
After either of the above changes, fonts in some GTK applications may still not be scaled; you may additionally do the following (see
#GDK 3 (GTK 3)
):
Go to
Settings Manager > Appearance > Fonts > Custom DPI setting
and change from 96 to 192
Set the
environment variable
GDK_DPI_SCALE=0.5
to un-scale some fonts that would be scaled twice.
The steps above would set 2x scaled resolution for Xfce and other GTK 3 applications.
Scaling for Qt 5 applications should be set manually, see
#Qt 5
. Note that if you set a Custom DPI for fonts above, you likely need to set
QT_FONT_DPI=96
to avoid double-scaling of fonts in Qt applications.
Cinnamon
Has good support out of the box.
Enlightenment
For E18, go to the E Setting panel. In
Look > Scaling
, you can control the UI scaling ratios. A ratio of 1.2 seems to work well for the native resolution of the MacBook Pro 15" screen.
LXDE
In general, the generic
X Server
settings apply. To change the size of the mouse cursor, edit the file
~/.config/lxsession/LXDE/desktop.conf
and change the value of
iGtk/CursorThemeSize
.
Wayland compositors
Sway
See
Sway#HiDPI
.
Hyprland
See
Hyprland#Setting screen resolution
.
X Resources
The factual accuracy of this article or section is disputed.
Reason:
libxft
is a
font rendering interface library
, the
Xft.dpi
setting was not intended to be abused by other applications. On the other hand, the
xorg.conf
value should affect everything. (Discuss in
Talk:HiDPI
)
If you are not using a desktop environment such as KDE, Xfce, or other that manipulates the X settings for you, you can set the desired DPI setting manually via the
Xft.dpi
variable in
Xresources
:
~/.Xresources
Xft.dpi: 192

! These might also be useful depending on your monitor and personal preference:
Xft.autohint: 0
Xft.lcdfilter:  lcddefault
Xft.hintstyle:  hintfull
Xft.hinting: 1
Xft.antialias: 1
Xft.rgba: rgb
For
Xft.dpi
, using integer multiples of 96 usually works best, e.g. 192 for 200% scaling.
Make sure the settings are loaded properly when X starts, for instance in your
~/.xinitrc
with
xrdb -merge ~/.Xresources
(see
Xresources
for more information).
This will make the font render properly in most toolkits and applications, it will however not affect things such as icon size!
Setting
Xft.dpi
at the same time as toolkit scale (e.g.
GDK_SCALE
) may cause interface elements to be much larger than intended in some programs like firefox.
X Server
Some programs may still interpret the DPI given by the X server (most interpret X Resources, though, directly or indirectly). Older versions of i3 (before 2017) and Chromium (before 2017) used to do this.
To verify that the X Server has properly detected the physical dimensions of your monitor, use the
xdpyinfo
utility from the
xorg-xdpyinfo
package:
$ xdpyinfo | grep -B 2 resolution
screen #0:
  dimensions:    3200x1800 pixels (423x238 millimeters)
  resolution:    192x192 dots per inch
This example uses inaccurate dimensions (423mm x 238mm, even though the Dell XPS 9530 has 346mm x 194mm) to have a clean multiple of 96 dpi, in this case 192 dpi. This tends to work better than using the correct DPI — Pango renders fonts crisper in i3 for example.
If the DPI displayed by xdpyinfo is not correct, see
Xorg#Display size and DPI
for how to fix it.
GUI toolkits
Qt 5
Since Qt 5.6, Qt 5 applications can be instructed to honor screen DPI by setting the
QT_AUTO_SCREEN_SCALE_FACTOR
environment variable
. Qt 5.14 introduced a new environment variable
QT_ENABLE_HIGHDPI_SCALING
which
replaces
the
QT_AUTO_SCREEN_SCALE_FACTOR
variable. It is recommended to set both
environment variables
for maximum compatibility:
$ export QT_AUTO_SCREEN_SCALE_FACTOR=1
$ export QT_ENABLE_HIGHDPI_SCALING=1
If automatic detection of DPI does not produce the desired effect, scaling can be set manually per-screen (
QT_SCREEN_SCALE_FACTORS
/
QT_ENABLE_HIGHDPI_SCALING
) or globally (
QT_SCALE_FACTOR
). For more details see the
Qt blog post
or
Qt developer documentation
.
Note
If you manually set the screen factor, it is important to set
QT_AUTO_SCREEN_SCALE_FACTOR=0
and
QT_ENABLE_HIGHDPI_SCALING=0
otherwise some applications which explicitly force high DPI enabling get scaled twice.
QT_SCALE_FACTOR
scales fonts, but
QT_SCREEN_SCALE_FACTORS
may not scale fonts, depending on the application.
If you also set the font DPI manually in
xrdb
to support other toolkits,
QT_SCALE_FACTORS
will give you huge fonts.
If you have multiple screens of differing DPI ie:
#Side display
you may need to do
QT_SCREEN_SCALE_FACTORS="2;2"
An
alternative
is e.g.:
$ QT_FONT_DPI=96 clementine
GDK 3 (GTK 3)
Note
As stated in the
#X Resources
section, if you have xft.dpi set to a larger dpi, it will make other scales larger than usual, including GDK.
Setting the GDK scale (in X11, not Wayland) will scale the UI; however, it will not scale icons. If you are using a minimal window manager where you are setting the dpi via Xft.dpi, GDK should scale perfectly fine with it. In other cases,
do the following
:
To scale UI elements by an integer only factor:
$ export GDK_SCALE=2
GTK3 does not support fractional scaling currently, so fractional factors will be ignored. This environment variable is also ignored in mutter wayland sessions.
GTK4 supports fractional scaling since 4.14 under Wayland.
GDK_DPI_SCALE
can be used to scale text only. To undo scaling of text, fractional scale can be used:
$ export GDK_DPI_SCALE=0.5
Under GTK3/4 it not currently possible to scale icon sizes, unless the application explicitly implements a way to do so. See bug report
#4528
. If you need this feature, use Qt when possible.
GTK 2
Scaling of UI elements is not supported by the toolkit itself, however it is possible to generate a theme with elements pre-scaled for HiDPI display using
themix-full-git
AUR
.
SDL
SDL3 windows are marked to the compositor as DPI-aware, by default. For incompatible applications, this can be disabled via the
SDL_HINT_VIDEO_WAYLAND_SCALE_TO_DISPLAY
hint. This is done either by the application itself via the
SDL hint API
, or by setting the environment variable:
$ export SDL_VIDEO_WAYLAND_SCALE_TO_DISPLAY=1.
By default,
sdl2-compat
forces 1:1 scaling (non-DPI-aware) using this hint,
[6]
with some per-application exceptions.
[7]
Electron
Electron
applications (e.g.
slack-desktop
AUR
,
signal-desktop
, etc.) can be configured to always use a custom scaling value by adding a
--force-device-scale-factor
flag to the
.desktop
file. Electron packages in the official repositories and packages that use them, can be configured with a
configuration file
.
Desktop files are normally located at
/usr/share/applications/
, and can normally be overridden on a per-user basis by copying it to
~/.local/share/applications/
. The flag should be added to the line beginning with "Exec=". For example:
~/.local/share/applications/slack.desktop
Exec=env LD_PRELOAD=/usr/lib/libcurl.so.3 /usr/bin/slack --force-device-scale-factor=1.5 %U
Elementary (EFL)
To scale UI elements by a factor of 1.5:
export ELM_SCALE=1.5
For more details see
https://phab.enlightenment.org/w/elementary/
[
dead link
2024-10-12—domain name not resolved]
GNUstep
GNUstep applications that use its gui (AppKit) library accept a
GSScaleFactor
property in their defaults (STEP preferences). To define a scaling factor of 1.5 for all applications:
defaults write NSGlobalDomain GSScaleFactor 1.5
Note that you must also disable font hinting by setting the value of
GSFontHinting
to 17, else text rendering will look broken when rendering long lines.
defaults write NSGlobalDomain GSFontHinting 17
Some automatic detection was possible back in 2011, but the code responsible for the X11 backend was
commented out
thereafter.
FLTK
FLTK 1.3, the default FLTK version available in Arch Linux, does not support resolution scaling. Support will arrive when applications start using FLTK 1.4.
AvaloniaUI (C# / .NET)
AVALONIA_GLOBAL_SCALE_FACTOR
can be used to scale. To undo scaling, fractional scale can be used:
$ export AVALONIA_GLOBAL_SCALE_FACTOR=0.5
For per monitor configuring see
avalonia wiki
].
Boot managers
GRUB
Lower the framebuffer resolution
Set a lower resolution for the framebuffer as explained in
GRUB/Tips and tricks#Setting the framebuffer resolution
.
Change GRUB font size
Find a ttf font that you like in
/usr/share/fonts/
.
Convert the font to a format that GRUB can utilize:
# grub-mkfont -s 30 -o /boot/grubfont.pf2 /usr/share/fonts/FontFamily/FontName.ttf
Note
Change the
-s 30
parameter to modify the font size
Edit
/etc/default/grub
to set the new font as shown in
GRUB/Tips and tricks#Background image and bitmap fonts
:
GRUB_FONT="/boot/grubfont.pf2"
Note
GRUB_THEME
overrides
GRUB_FONT
if it is used.
Finally
regenerate the main configuration file
.
Tip
The font size can also be changed with the GUI tool
grub-customizer
AUR
.
systemd-boot
Set a lower resolution for the console through
console-mode
as explained in
systemd-boot#Loader configuration
and
loader.conf(5) § OPTIONS
.
Applications
If you are running a Wayland session, but application is running via Xwayland (either because it does not support Wayland natively or because it uses X11 by default), you could still get blurry fonts and interface, even if the application supports HiDPI. See
this bug report
. See also
Wayland#Detect Xwayland applications
.
Browsers
Firefox
Firefox should use the
#GDK 3 (GTK 3)
settings. However, the suggested
GDK_SCALE
suggestion does not consistently scale the entirety of Firefox, and does not work for fractional values (e.g., a factor of 158DPI/96DPI = 1.65 for a 1080p 14" laptop). You may want to use
GDK_DPI_SCALE
instead. Another option, which will avoid Firefox-specific settings in many setups is to use the settings in
#X Resources
as Firefox should respect the
Xft.dpi
value defined there.
To view the internal UI scaling settings of Firefox, open the advanced preferences page (
about:config
) and check those parameters:
widget.wayland.fractional-scale.enabled
: Set it to true to enable fractional scaling on wayland. Otherwise, on some desktop environments (e.g., KDE on wayland), Firefox may be double scaled. For example, if you set the screen scale to 150% in plasma system settings, Firefox will enlarge to 200% first and then be down-scaled to 150%, so all fonts look blurry.
layout.css.devPixelsPerPx
: The actual parameter that controls UI scaling.
1.25
for 125% scaling,
1.50
for 150%, and so on. Default is
-1.0
(follow the system's HiDPI setting).
If you use a HiDPI monitor such as Retina display together with another monitor, you can use the
ffreszoom
add-on, which will adjust the page zoom if it detects you are using a large monitor (zoom level and threshold are configurable). Modifying the internal CSS DPI setting from an extension is currently unsupported
[8]
.
Chromium / Google Chrome
Chromium should use the
#GDK 3 (GTK 3)
settings.
To override those, use the
--force-device-scale-factor
flag with a scaling value. This will scale all content and ui, including tab and font size. For example
chromium --force-device-scale-factor=2
.
Using this option, a scaling factor of 1 would be normal scaling. Floating point values can be used. To make the change permanent, for Chromium, you can add it to
~/.config/chromium-flags.conf
:
~/.config/chromium-flags.conf
--force-device-scale-factor=2
To make this work for Chrome, add the same option to
~/.config/chrome-flags.conf
instead.
If you use a HiDPI monitor such as Retina display together with another monitor, you can use the
reszoom
extension in order to automatically adjust the zoom level for the active screen.
If using Wayland session, you should
enable
native wayland support to avoid blurriness. See also
Chromium#Incorrect HiDPI rendering
.
Opera
Opera should use the
#GDK 3 (GTK 3)
settings.
To override those, use the
--alt-high-dpi-setting=
X
command line option, where X is the desired DPI. For example, with
--alt-high-dpi-setting=144
Opera will assume that DPI is 144.  Newer versions of opera will auto detect the DPI using the font DPI setting (in KDE: the force font DPI setting.)
Inkscape
To scale the icons to a "usable" size go to
Preferences > Interface
and set the icon size to Large or Larger
[9]
[10]
.
Java applications
AWT/Swing
Java applications using the
AWT/Swing
framework can be scaled by defining the
sun.java2d.uiScale
VM property when invoking
java
. The value can be an integer percentage value, or a float value. For example,
java -Dsun.java2d.uiScale=2 -jar
some_swing_application
.jar
java -Dsun.java2d.uiScale=300% -jar
some_swing_application
.jar
Since Java 9 the
GDK_SCALE
environment variable is used to scale Swing applications accordingly.
Note that at this point, Java
AWT/Swing
(up to including OpenJDK 13) only effectively supports integer values. A setting of
-Dsun.java2d.uiScale=250%
or
GDK_SCALE=2.5
will be treated as if it were set to
-Dsun.java2d.uiScale=2
resp.
GDK_SCALE=2
.
JavaFX
Java applications using
JavaFX
can be scaled by defining the
glass.gtk.uiScale
VM property when invoking
java
. The value can be an integer percentage value, an integer DPI value (where
96dpi
represents a scale factor of
100%
, and for example
192dpi
represents a scale factor of
200%
), or a float value. For example,
java -Dglass.gtk.uiScale=200% -jar
some_jfx_application
.jar
java -Dglass.gtk.uiScale=192dpi -jar
some_jfx_application
.jar
java -Dglass.gtk.uiScale=2.0 -jar
some_jfx_application
.jar
JavaFX
perfectly well supports fractions. Using values like
-Dglass.gtk.uiScale=250%
or
-Dglass.gtk.uiScale=2.5
will deliver the expected result.
Mixed AWT/Swing and JavaFX
Some Java applications mix
JavaFX
and
AWT/Swing
(via
javafx.embed.swing.JFXPanel
). In that case, the settings for
AWT/Swing
will also affect
JavaFX
, and setting
-Dglass.gtk.uiScale
will have no effect.
JetBrains IDEs
On Wayland, HiDPI with fractional scaling is experimentally supported since version 2024.2. The
Wayland support preview
can be enabled, by adding
-Dawt.toolkit.name=WLToolkit
to the VM options (
Help > Edit custom VM options
).
JetBrains products (IntelliJ IDEA and other IDEs) support two HiDPI modes (JRE-managed and IDE-managed). The sequence for determining system scale factor is well documented at
[11]
:
Java property –
-Dsun.java2d.uiScale
gsettings(1)
–
ubuntu.user-interface/scale-factor
or
org.gnome.desktop.interface/scaling-factor
GDK_SCALE
and
GDK_DPI_SCALE
Xresources
–
Xft.dpi
1.0
For troubleshooting, consult the "Show HiDPI Info" dialog via
search everywhere "Shift Shift"
.
When using per-monitor scaling, an issue might occur where IntelliJ fails to recognize the real, original monitor resolution.
To remediate this problem some people have success by adding the
-Dsun.java2d.uiScale.enabled=true
option to the
ide_name
.vmoptions
file (
Help > Edit custom VM options
).
If this does not work, the experimental GTK option
scale-monitor-framebuffer
might be enabled on Wayland (
see above
) and the Wayland support preview might be disabled (
see above
). Currently JetBrains products run on Xwayland and thus
have no full native Wayland support yet
. This makes the rendering in JetBrains products incompatible with the monitor scaling framebuffer. Disabling the framebuffer thus might solve blurry font/rendering issues for JB products, but alas results in disabled fractional scaling. Another options is to enable the Wayland support preview.
Maple
Maple can be scaled for HiDPI monitors using the AWT/Swing solution. But it has to be added inside your Maple installation directory to
maple-directory
/bin/maple
to the
JVM_OPTIONS
:
maple-directory
/bin/maple
...
JVM_OPTIONS="-Dsun.java2d.uiScale=2 ..."
...
Alternatively, the
GDK_SCALE
environment variable can be used to start the application scaled:
$ GDK_SCALE=2
maple-directory
/bin/xmaple %f
MATLAB
Recent versions (since R2017b) of
MATLAB
allow to set the scale factor
[12]
:
Version R2024b and earlier
To adjust the scale factor, execute the following instructions in a MATLAB command window:
>> s = settings;
>> s.matlab.desktop.DisplayScaleFactor %Get current value
>> s.matlab.desktop.DisplayScaleFactor.PersonalValue = 2 %Set personal value
The settings take effect after MATLAB is restarted.
This can become tedious if you need to change the scaling frequently. To simplify this, consider using the following script:
~/bin/matlab-scale
#!/bin/sh
exec matlab -r "s = settings;s.matlab.desktop.DisplayScaleFactor.PersonalValue=$1;quit" -nodesktop -nosplash
To change the display scaling to 3:
$ matlab-scale 3
Version R2025a and later
In the latest MATLAB versions, changing the DisplayScaleFactor property often has no effect. However, a newly introduced parameter enables varying the scale factor in real-time, with no need for restarting MATLAB:
>> s = settings;
>> s.matlab.desktop.Zoom %Get current value
>> s.matlab.desktop.Zoom.PersonalValue=150 %Set personal value
Mono applications
According to
[13]
[
dead link
2023-04-23—domain name not resolved]
, Mono applications should be scalable like
GTK 3
applications. The precise method depends on the GUI library: GtkSharp obviouslys points back to Gtk, while the usual Windows Forms (libgdiplus) simply detects Xft settings.
NetBeans
NetBeans allows the font size of its interface to be controlled using the
--fontsize
parameter during startup. To make this change permanent edit the
/usr/share/netbeans/etc/netbeans.conf
file and append the
--fontsize
parameter to the
netbeans_default_options
property.
[14]
The editor fontsize can be controlled from
Tools > Option > Fonts & Colors
.
The output window fontsize can be controlled from
Tools > Options > Miscellaneous > Output
OBS Studio
OBS 29 supports HiDPI setups without any extra configuration.
For older versions of OBS, the recommendation was to set the environment variable
QT_AUTO_SCREEN_SCALE_FACTOR=0
to disable
Qt’s hi-dpi migration mode
and install the Yami theme. Do not use the Yami theme with OBS 29 or newer, as it is not necessary anymore and will cause buggy behavior.
Rofi
Rofi defaults to 96 DPI and relies on its own configuration only
~/.config/rofi/config.rasi
configuration {
    …
    dpi: 150;
    …
}
Spotify
Note
See
Spotify#HiDPI Mode
for more details and when using other clients.
You can change scale factor by simple
Ctrl++
for zoom in,
Ctrl+-
for zoom out and
Ctrl+0
for default scale. Scaling setting will be saved in
~/.config/spotify/Users/YOUR-SPOTIFY-USER-NAME/prefs
, you may have to create this file by yourself:
~/.config/spotify/Users/YOUR-SPOTIFY-USER-NAME/prefs
app.browser.zoom-level=100
Also Spotify can be launched with a custom scaling factor which will be multiplied with setting specified in
~/.config/spotify/Users/YOUR-SPOTIFY-USER-NAME/prefs
, for example
$ spotify --force-device-scale-factor=1.5
Steam
Official HiDPI support
Starting on 25 of January 2018 in the beta program there is actual support for HiDPI and it should be automatically detected.
Steam > Settings > Interface
, check
Enlarge text and icons based on monitor size
(restart required)
If it is not automatically detected, use
GDK_SCALE=2
to set the desired scale factor.
If the above fails, use
steam -forcedesktopscaling 2
or set
STEAM_FORCE_DESKTOPUI_SCALING=2.0
.
[15]
As of the June 2023 UI overhaul, this parameter also supports non-integer scale factors, such as
1.25
.
You can also adjust the interface scale in
Steam > Settings > Accessibility
, though the slider does not display a number value.
Unofficial
The
HiDPI-Steam-Skin
can be installed to increase the font size of the interface. While not perfect, it does improve usability.
Note
The README for the HiDPI skin lists several possible locations for where to place the skin. The correct folder out of these can be identified by the presence of a file named
skins_readme.txt
.
MetroSkin Unofficial Patch
also helps with HiDPI on Steam with Linux.
Sublime Text 3
Sublime Text 3 has full support for display scaling. Go to
Preferences > Settings > User Settings
and add
"ui_scale": 2.0
to your settings.
Thunderbird
See
#Firefox
. To access
about:config
, go to
Edit > Preferences > Advanced >Config editor
.
VirtualBox
Note
This only applies to KDE with scaling enabled.
VirtualBox also applies the system-wide scaling to the virtual monitor, which reduces the maximum resolution inside VMs by your scaling factor (see
[16]
).
This can be worked around by calculating the inverse of your scaling factor and manually setting this new scaling factor for the VirtualBox execution, e.g.
$ QT_SCALE_FACTOR=0.5 VirtualBoxVM --startvm
vm-name
VMware
Text in the VMware application is rendered at an appropriate size following the system configuration, but icons are small and UI elements have little padding between them.
As described in
#GDK 3 (GTK 3)
, you can use
GDK_SCALE
to further scale up the entire UI (including icons & padding) and then use
GDK_DPI_SCALE
to scale only the text back down to a reasonable size.
For example, to get a final 2x scale factor:
$ GDK_SCALE=2 GDK_DPI_SCALE=0.5 vmware
Wine applications
Run
$ winecfg
and change the "dpi" setting found in the "Graphics" tab. This only affects the font size.
Zathura document viewer
No modifications required for document viewing.
UI text scaling is specified via
configuration file
(note that "font" is a
girara option
):
set font "monospace normal 20"
Zoom
Set the
scaleFactor
variable in
~/.config/zoomus.conf
.
For the Flatpak version, set the environment variable
QT_SCALE_FACTOR
(e.g. to 0.5
[17]
). This can be easily done with
Flatseal
, if using a GUI tool is preferred.
Gazebo
Gazebo only renders an upper left of a view instead of the whole view. To fix this a Qt environment variable must be set.
To run Gazebo:
$ QT_SCREEN_SCALE_FACTORS=[1.0] gazebo
To run a ROS simulation:
$ TURTLEBOT3_MODEL=burger QT_SCREEN_SCALE_FACTORS=[1.0] roslaunch turtlebot3_gazebo turtlebot3_world.launch
Making an alias such as
gazebo="QT_SCREEN_SCALE_FACTORS=[1.0] gazebo"
works for the first case but not for the second.
Fcitx
Fcitx preedit
FontSize
can be changed in
~/.config/fcitx/conf/fcitx-classic-ui.config
.
For Fcitx5, set
Font
with a size inside double quotes in
~/.config/fcitx5/conf/classicui.conf
.
Synthesizer V Studio Pro
Synthesizer V Studio Pro has support for UI scaling. It can setup the scaling automatically, but if it fails the scale can be adjusted with option --with-scaling:
$ synthv-studio --with-scaling 2.0
V2RayN, SourceGit and other AvaloniaUi C# / .NET applications
As described in
#AvaloniaUI (C# / .NET)
, you can use
AVALONIA_GLOBAL_SCALE_FACTOR
.
Unsupported applications, via a network layer
xpra
includes a
run_scaled
script which can be used to scale applications.
Another approach is to run the application full screen and without decoration in its own VNC desktop. Then scale the viewer. With
vncdesk-git
AUR
you can set up a desktop per application, then start server and client with a simple command such as
vncdesk 2
.
x11vnc
has an experimental option
-appshare
, which opens one viewer per application window. Perhaps something could be hacked up with that.
Unsupported applications, via Weston
There is a no-network, potentially GPU-accelerated solution to scale old/unsupported applications via Weston. The basic example goes as:
$ weston --xwayland --socket=testscale --scale=2
$ DISPLAY=:1 WAYLAND_DISPLAY=testscale
your_app
Note 1: You can make it look nicer. Create a dedicated
weston.ini
and use it with
weston --config
:
[core]
idle-time=0
[shell]
panel-position=none
locking=false
Note 2: Adjust your
DISPLAY
according to your system,
:1
is simply the default that comes after the main
:0
. Check files created in
/tmp/.X11-unix
to do that.
Note 3: If you want a separate window per each scaled app, adjust the
--socket
parameter to weston and
WAYLAND_DISPLAY
+
DISPLAY
for each started app. Scripting that is not easy because Xorg display has to be a small-ish integer, but you can create a semi-safe script to infer it.
Note 4: It is not fully tested yet whether weston and xwayland truly off-board the heavy parts to the GPU. At least
weston
advertises to do so, but no tests on that were done yet. Please edit if you make the GPU usage tests.
Multiple displays
The HiDPI setting applies to the whole desktop, so non-HiDPI external displays show everything too large. However, note that setting different scaling factors for different monitors is already supported in
Wayland
.
Side display
One workaround is to use
xrandr
's
scale
option. To have a non-HiDPI monitor (on DP1) right of an internal HiDPI display (eDP1), one could run:
$ xrandr --output eDP-1 --auto --output DP-1 --auto --scale 2x2 --right-of eDP-1
When extending above the internal display, you may see part of the internal display on the external monitor. In that case, specify the position manually.
You may adjust the
sharpness
parameter on your monitor settings to adjust the blur level introduced with scaling.
Note
Above solution with
--scale 2x2
does not work on some
NVIDIA
cards. No solution is currently available.
[18]
A potential workaround exists with configuring
ForceFullCompositionPipeline=On
on the
CurrentMetaMode
via
nvidia-settings
. For more info see
[19]
.
If you are using the
modesetting
driver you will get mouse flickering. This can be solved by scaling your non-scaled screen by 0.9999x0.9999.
Multiple external monitors
There might be some problems in scaling more than one external monitors which have lower dpi than the built-in HiDPI display. In that case, you may want to try downscaling the HiDPI display instead, with e.g.
$ xrandr --output eDP1 --scale 0.5x0.5 --output DP2 --right-of eDP1 --output HDMI1 --right-of DP2
In addition, when you downscale the HiDPI display, the font on the HiDPI display will be slightly blurry, but it is a different kind of blurriness compared with the one introduced by upscaling the external displays. You may compare and see which kind of blurriness is less problematic for you.
Mirroring
If all you want is to mirror ("unify") displays, this is easy as well:
With AxB your native HiDPI resolution (for ex 3200x1800) and CxD your external screen resolution (e.g. 1920x1200)
$ xrandr --output HDMI --scale [A/C]x[B/D]
In this example which is QHD (3200/1920 = 1.66 and 1800/1200 = 1.5)
$ xrandr --output HDMI --scale 1.66x1.5
For UHD to 1080p (3840/1920=2 2160/1080=2)
$ xrandr --output HDMI --scale 2x2
You may adjust the
sharpness
parameter on your monitor settings to adjust the blur level introduced with scaling.
Tools
There are several tools which automate the commands described above.
This script
extend a non-HiDPI external display above a HiDPI internal display.
xrandr-extend
.
xlayoutdisplay
AUR
is a CLI front end for xrandr which detects and sets correct DPI:
README
Linux console (tty)
In-kernel fonts
The
Linux console
changes the font to
TER16x32
(based on
ter-i32b
from
terminus-font
[20]
) based on the vertical and horizontal pixel count of the display
[21]
regardless of its physical size. If your monitor is not recognised as HiDPI, the default font can be changed. In that case, specify
fbcon=font:TER16x32
in the
kernel command line
.
Fonts outside the kernel (tty)
The largest fonts present in the
kbd
package are
latarcyrheb-sun32
and
solar24x32
. Other packages like
terminus-font
contain further alternatives, such as
ter-132n
(normal) and
ter-132b
(bold). See
Linux console#Fonts
for configuration details and
Linux console#Persistent configuration
in particular for applying the font setting during the early userspace boot sequence.
After changing the font, it is often garbled and unreadable when changing to other virtual consoles (
tty2
–
6
). To fix this you can
force specific mode
for KMS, such as
video=2560x1600@60
(substitute in the native resolution of your HiDPI display), and reboot. Using small resolutions will make the text look bigger, but also pixelated.
Users booting through
UEFI
may experience the console and
boot loader
being constrained to a low resolution despite correct
KMS
settings being set. This can be caused by legacy/BIOS boot being enabled in UEFI settings. Disabling legacy boot to bypass the compatibility layer should allow the system to boot at the correct resolution.
Modern HiDPI support (kmscon)
For real HiDPI support, see
KMSCON
instead of changing the font size in the tty.
See also
Ultra HD 4K Linux Graphics Card Testing
(Nov 2013)
Understanding pixel density
Mixed DPI and the X Window System