Dusko Pijetlovic

Replicate FVWM3's 9 Desks in Wayland GNOME on RHEL 10.2

Sun, 07 Jun 2026 02:00:13 +0000

AKA Replicate FVWM3 with 9 Virtual Desktops in Wayland GNOME on RHEL 10.2

Fix 9 Static Workspaces

GNOME defaults to dynamic workspaces (creates/destroys them automatically). Disable that and set to 9 workspaces.

$ gsettings set org.gnome.mutter dynamic-workspaces false
$ gsettings set org.gnome.desktop.wm.preferences num-workspaces 9

Set Keyboard Shortcuts to Switch Directly to Each Desk

GNOME only binds a few workspaces by default. Set all 9:

$ for i in $(seq 1 9); do
  gsettings set org.gnome.desktop.wm.keybindings \
    switch-to-workspace-$i "['<Super>$i']"
done

Move a Window to a Specific Workspace (Optional)

$ for i in $(seq 1 9); do
  gsettings set org.gnome.desktop.wm.keybindings \
    move-to-workspace-$i "['<Super><Shift>$i']"
done

Install GNOME Shell Extension: “Workspace Indicator”

This extension shows the current workspace number/name in the top bar.

$ dnf search gnome-shell-extension
. . .

Here’s what’s directly relevant to my 9-workspace setup:

$ sudo dnf install \
  gnome-shell-extension-workspace-indicator \
  gnome-shell-extension-dash-to-panel \
  gnome-shell-extension-auto-move-windows \
  gnome-shell-extension-windowsNavigator \
  gnome-extensions-app

$ gnome-extensions enable workspace-indicator@gnome-shell-extensions.gcampax.github.com
$ gnome-extensions enable dash-to-panel@jderose9.github.com
$ gnome-extensions enable auto-move-windows@gnome-shell-extensions.gcampax.github.com
$ gnome-extensions enable windowsNavigator@gnome-shell-extensions.gcampax.github.com
Extension “workspace-indicator@gnome-shell-extensions.gcampax.github.com” does not exist
Extension “dash-to-panel@jderose9.github.com” does not exist
Extension “auto-move-windows@gnome-shell-extensions.gcampax.github.com” does not exist
Extension “windowsNavigator@gnome-shell-extensions.gcampax.github.com” does not exist

The extensions installed fine; however, GNOME Shell hasn’t picked up the newly installed extensions yet because they were installed after your session started.

Restart GNOME Shell to load them. Log out and back in:

$ gnome-session-quit --logout

Or simply log out from the system menu and log back in.

After logging back in, verify and enable the newly installed GNOME extensions.

See all available extensions (including newly installed ones):

$ gnome-extensions list --active
background-logo@fedorahosted.org

$ gnome-extensions list --inactive
auto-move-windows@gnome-shell-extensions.gcampax.github.com
windowsNavigator@gnome-shell-extensions.gcampax.github.com
workspace-indicator@gnome-shell-extensions.gcampax.github.com
dash-to-panel@jderose9.github.com

Then, enable each one using the UUID from the output above.

$ gnome-extensions enable dash-to-panel@jderose9.github.com
$ gnome-extensions enable auto-move-windows@gnome-shell-extensions.gcampax.github.com
$ gnome-extensions enable windowsNavigator@gnome-shell-extensions.gcampax.github.com

Verify:

$ gnome-extensions list --active
auto-move-windows@gnome-shell-extensions.gcampax.github.com
windowsNavigator@gnome-shell-extensions.gcampax.github.com
dash-to-panel@jderose9.github.com
background-logo@fedorahosted.org

# Or:

$ gnome-extensions list --enabled
auto-move-windows@gnome-shell-extensions.gcampax.github.com
windowsNavigator@gnome-shell-extensions.gcampax.github.com
dash-to-panel@jderose9.github.com
background-logo@fedorahosted.org

Disable dash-to-panel’s app shortcuts (keep Super+N).

$ gsettings list-recursively org.gnome.shell.extensions.dash-to-panel | grep -i hot | grep -i overlay
org.gnome.shell.extensions.dash-to-panel hotkeys-overlay-combo 'TEMPORARILY'

$ gsettings set org.gnome.shell.extensions.dash-to-panel hotkeys-overlay-combo 'NEVER'

$ gsettings get org.gnome.shell.extensions.dash-to-panel hotkeys-overlay-combo
'NEVER'

Temporarily disable dash-to-panel.

$ gnome-extensions disable dash-to-panel@jderose9.github.com

Disable (clear) all switch-to-application bindings:

$ for i in $(seq 1 9); do
  gsettings set org.gnome.shell.keybindings switch-to-application-$i "[]"
done

The hotkeys-overlay-combo ‘NEVER’ hides the visual number overlay but it doesn’t remove the actual key grabs in this version.

Find dash-to-panel’s shortcut settings:

$ dconf dump /org/gnome/shell/extensions/dash-to-panel/
---- snip ----
hot-keys=true
---- snip ----

The master switch is hot-keys=true, and because of that dash-to-panel’s app-hotkey-N is active and conflicts with workspace and move-to-workspace.

app-hotkey-N       -> <Super>N (conflicts with workspace switching)
app-shift-hotkey-N -> <Shift><Super>N (conflicts with move-to-workspace)
app-ctrl-hotkey-N  -> <Ctrl><Super>N

Disable the master switch (hot-keys):

$ gsettings set org.gnome.shell.extensions.dash-to-panel hot-keys false

Re-enable dash-to-panel:

$ gnome-extensions enable dash-to-panel@jderose9.github.com

My final configuration:

+---------------------+------------------------------------------------+
| static 9 workspaces | gsettings / mutter                             |
| Super+1–9           | switch to workspace N                          |
| Super+Shift+1–9     | move window to workspace N                     |
| dash-to-panel       | panel with workspace switcher (hot-keys=false) |
| auto-move-windows   | assign apps to specific workspaces             |
| windowsNavigator    | keyboard selection in Activities overview      |
+---------------------+------------------------------------------------+

Remaining Things Worth Configuring

auto-move-windows

Open gnome-extensions-app.

$ gnome-extensions-app

Find Auto Move Windows, click the gear icon, and assign applications to specific workspace numbers.

This is Style * StartsOnDesk equivalent (on FVWM3/FVWM).

Enable Workspace Indicator

Open gnome-extensions-app.

$ gnome-extensions-app

Click on ‘Workspace Indicator’ - Enable it. Then, click on the three vertical dots menu (Settings) > Under ‘Indicator’, select ‘Workspace Name’.

Workspace Names - If You Want Named Desks Like in FVWM3

$ gsettings set org.gnome.desktop.wm.preferences workspace-names \
    "['1', '2', '3', '4', '5', '6', '7', '8', '9']"

$ gsettings get org.gnome.desktop.wm.preferences workspace-names
['1', '2', '3', '4', '5', '6', '7', '8', '9']

Export Dash to Panel’s Settings

Right-click the panel -> Dash to Panel Settings. Click ‘About’ - under ‘Export and Import’, click ‘Export to file’.

FreeBSD 15 ZFS, RHEL 10, Windows 11 Triple Boot [UEFI GPT]

Sat, 30 May 2026 20:12:33 +0000

The three OSs for this configuration: FreeBSD 15, RHEL 10, Windows 11 Professional.

PC: Lenovo ThinkPad E14 Gen 6 laptop AMD model, Type (Machine Type or MT) 21M3 - customized

Configure FreeBSD and Windows dual-boot as explained in this post:

FreeBSD ZFS and Windows 11 Dual Boot [UEFI GPT] [Manual Setup]

Plug in a bootable USB flash drive with the RHEL 10.1 installer and boot from it.

GRUB version 2.12
  Install Red Hat Enterprise Linux 10.1

Langauge
  English

Keyboard
  English (Canada)

Installation Destination
  Corsair MP600 MICRO - nvme1n1 / 822.5 GiB free

Full disk summary and boot loader...
  Selected Disks and Boot Loader
    Corsair MP600 MICRO (Corsair_MP600_MICRO_AA4GB439003RGY_1)

Root Account
  - Enable Root Account
  - Root Pasword: ************
  - [X] Allow root SSH login with password

Time & Date
  Americas/Vancouver timezone  ## ** Autodeteced - I didn't need to change anything

Network & Host Name
  Connected: enp2s0            ## ** Autodeteced - I didn't need to change anything
  Host Name: rhel.home.arpa   ->  Clicked 'Apply'

Software Selection
  Changed from
    Server with GUI
  To
    Workstation
  Additional Software for Selected Environment
    Backup Client
    Headless Management
    Remote Desktop Clients
    Legacy UNIX Compatibility
    Console Internet Tools
    Container Management
    Development Tools
    Graphical Administration Tools
    Scientific Support
    Security Tools
    System Tools

User Creation
  - Full name: dusko
  - User name: dusko
  - [X] Add administrative privileges to this user account (wheel group membership)
  - [X] Require a password for this account

Begin Installation

------------------

Red Hat Enterprise Linux is now succefully installed and ready for you to use!

Go ahead and reboot your system to start using it!

(Use of this product is subject to the license agreement at /usr/share/redhat-license/EULA)

Clicked 'Reboot System'

After reboot:

GRUB version 2.12

Red Hat Enterprise Linux (6.12.0-124.8.1.el10_1.x86_64) 10.1 (Coughlan)
Red Hat Enterprise Linux (0-rescue-cf00eadc488c4103b67539f044a271ef) 10.1 (Coughlan)
Windows Boot Manager (on /dev/nvme1n1p1)
UEFI Firmware Settings

When you press F12 for Boot Menu:

ThinkPad

Boot Menu

Red Hat Enterprise Linux 
FreeBSD
Windows Boot Manager
NVMe0: Corsair MP600 MICRO 
NVMe1: Samsung SSD 990 EVO Plus 2TB
PXE BOOT

Red Hat Developer Portal

After registering for Red Hat Developer Subscription, register your system:

$ sudo subscription-manager register \
 --username <your_username> --password <your_password> --auto-attach

Update all packages - kernel, glibc, OpenSSL, systemd, everything - to the latest versions available in the RHEL repos.

$ sudo dnf upgrade

Is reboot required? In this case, it was required:

$ sudo needs-restarting -r
Updating Subscription Management repositories.
Core libraries or services have been updated since boot-up:
  * glibc
  * kernel
  * kernel-core
  * linux-firmware
  * microcode_ctl
  * systemd

Reboot is required to fully utilize these updates.
More information: https://access.redhat.com/solutions/27943

To list the affected systemd services:

$ sudo needs-restarting -s

Restart the system.

$ sudo shutdown -r now

For personal machines, especially laptops, you can run:

$ fwupdmgr get-updates 

$ sudo fwupdmgr update

For servers, as of May 2026, it’s recommended not to enable LVFS (Linux Vendor Firmware Service) and not to use fwupdmgr(1). For enterprise servers, use their own purpose-built, out-of-band firmware management tools that don’t require the host OS at all (aka Remote Server Management):

+--------+----------------------------------------------------+
| Vendor | Tool                                               |
+--------+----------------------------------------------------+
| Lenovo | XClarity Controller (XCC) + XClarity Administrator | [*] 
+--------+----------------------------------------------------+
| HP/HPE | iLO (Integrated Lights-Out)                        | [*]
+--------+----------------------------------------------------+
| Dell   | iDRAC (Integrated Dell Remote Access Controller)   | [*] [**]
+--------+----------------------------------------------------+

These tools operate independently of the OS, and you can flash firmware even when the server won’t boot. In contrast, fwupdmgr(1) runs inside the host OS.

[*] Lenovo XClarity vs. HP iLO vs. Dell iDRAC - Remote Server Management - Post - LinkedIn

[**] PowerEdge: How to Update Firmware Remotely Using the iDRAC Web Interface - Dell

References

How do I get the no-cost Red Hat Enterprise Linux Developer Subscription or renew it?
Red Hat Developer Portal
Getting Started Guide - Get Started with Red Hat Enterprise Linux
Getting Started Guide covers downloading and installing Red Hat Enterprise Linux on a physical system or virtual machine (VM) using your choice of VirtualBox, VMware, Microsoft Hyper-V, or Linux KVM/Libvirt.

Beginner
- Learning paths - Cheat sheets - Articles & blogs - Interactive labs - Red Hat Customer Portal labs - Interactive demos
Intermediate
- Learning paths - Cheat sheets - E-books - Articles & blogs - Interactive labs - Red Hat Customer Portal labs - Interactive demos
Advanced
- Learning paths - Cheat sheets - Articles & blogs - Interactive labs - Red Hat Customer Portal labs
Lenovo XClarity vs. HP iLO vs. Dell iDRAC - Remote Server Management - Post - LinkedIn
PowerEdge: How to Update Firmware Remotely Using the iDRAC Web Interface - Dell
iDRAC vs. iLO vs. XCC (XClarity Controller) vs. IPMI: Remote Server Management Explained

How to Scroll in VT (Virtual Terminal) on FreeBSD and Linux

Sun, 29 Mar 2026 23:39:59 +0000

AKA: Scrollback in VT (Virtual Terminal) (text console, the system console, tty)

FreeBSD: Scrollback in VT - Scroll Lock Key

On FreeBSD, to scroll back in VT (virtual terminal), you need to press the Scroll Lock key, then scroll up and down with the arrow keys. To scroll up or down a full screen at a time, use the Page Up and Page Down keys.

If Keyboard doesn’t have Scroll Lock Key

If your keyboard doesn’t have a Scroll Lock key, it very likely uses a special function key sequence to access Scroll Lock.

On my wired split mechanical keyboard, Mistel Barocco MD770, you can activate Scroll Lock by pressing Fn + [{ (the key to the right of ‘P’).

Alternative - Remap Keys (Key Remapping)

Changing your keyboard mapping - FreeBSD Diary

Keyboard without Scroll Lock - freebsd-questions mailing list

How can I scroll back the output in FreeBSD’s console without Scroll Lock? - serverfault

Linux: Software Scrollback was Removed in version 5.9 of the Kernel

On Linux, Scrollback via Shift+PageUp and Shift+PageDown is no longer supported on console terminals by kernels newer than version 5.9.

vgacon (the VGA soft scrollback): remove software scrollback support - Linux kernel source tree

fbcon: remove soft scrollback code - Linux kernel source tree

Alternatives - Use a Terminal Multiplexer or less(1) or KMSCon

Use a terminal multiplexer; for example, tmux(1) or screen(1).
Use the less(1) program.

Of course, by the time you launch tmux(1), screen(1) or less(1), the message you need may have already scrolled out of view.

KMSCon offers perhaps a better alternative by serving as a system console terminal emulator that captures all output from the start, avoiding this timing issue.

For more about KMSCon, see the References section below.

References

vt(4) – virtual terminal system video console driver – FreeBSD Manual Pages

Scrolling Back
  Output that has scrolled off the screen can be reviewed by pressing the
  Scroll Lock key, then scrolling up and down with the arrow keys.

  The Page Up and Page Down keys scroll up or down a full screen at a time.

  The Home and End keys jump to the beginning or end of the scrollback buffer.
 
  When finished reviewing, press the Scroll Lock key again to return to 
  normal use.  

  Some laptop keyboards lack a Scroll Lock key, and use a special function 
  key sequence (such as Fn + K) to access Scroll Lock.

X11 DPI Scaling Guide

Sun, 23 Nov 2025 17:16:11 +0000

X11 DPI, Xft, X Server DPI, and Scaling

A consolidated, reference for DPI, Xft, X Server DPI, EDID, and scaling in X11 environments - especially for FreeBSD with FVWM3 window manager or any non-DE workflow.

FreeBSD * X11 * FVWM3 * No DE

My environment: FreeBSD 14.3, Shell: csh, WM (window manager): FVWM3, No DE (Desktop Environment), Lenovo ThinkPad T14s Gen 3 (14”, Intel) laptop.

Scenario: You have a 14-inch laptop, and its built-in screen is a WUXGA (Wide Ultra XGA) (resolution: 1920 x 1200) screen, so even though it’s not HiDPI (as HiDPI typically starts at displays with a pixel density greater than 200 pixels per inch (PPI)), it’s still a Very High Pixel Density (140+ PPI) panel. When you use it with an external monitor that supports PPI (DPI) of 90-110 DPI, it works fine. However, when you use the laptop with only its built-in screen, everything appears smaller than it’s comfortable for you. (Sharp fonts but microscopic UI elements.)

TL;DR

What DPI should I use on this laptop?

Set Xft.dpi: 120 in ~/.Xresources

Explanation:

Physical DPI on this laptop = 162. –> See 11a. Compute Physical DPI, and footnote [¹].
DPI that I like on the extarnal monitor = 94.
Preferred effective DPI ~94.

To approximate this scaling, I use DPI = 120, or DPI = 144, so set Xft.dpi to 120 or 144.

Add either this line:

Xft.dpi: 120

or this line:

Xft.dpi: 144

to ~/.Xresources.

Recommended DPI values for my laptop: 120 = ~125% scaling (good for 90-110 DPI screens), or 144 = ~150% scaling.
Physical DPI: use xrandr | grep -w connected -> compute with (pixels/mm) x 25.4. See 11a. Compute Physical DPI, and footnote [¹]
Logical DPI (what apps use): check with xrdb -query | grep Xft.dpi.
xdpyinfo shows X server DPI (rarely used by modern apps).
Modern apps (GTK, Qt, Firefox, Thunderbird) need their own scaling settings.
Xft.dpi can be changed live (xrdb -merge), while X server DPI cannot.
Scaling on X11 is per-toolkit; no universal scaling unless inside a Desktop Environment.
For Firefox/Thunderbird, use layout.css.devPixelsPerPx = 1.0 for 1x scaling.
For bitmap (XLFD) fonts, Xterm uses its own font sizes, independent of DPI.

What DPI should I use on an external monitor?

NOTE: Usually no scaling needed for external monitors. The goal is to be standing or sitting and be able to comfortably read text at 100% scaling without eye strain.

Choose one of monitors with the following specifications, listed here in order of preference:

1920x1200 - WUXGA: 24-inch (PPI 94.34, pixel pitch 0.27 mm)
2560x1440 - QHD (Quad HD) or WQHD (Wide QHD) or 1440p: 27-inch (PPI 108.79, pixel pitch 0.23 mm
1920x1080 - FHD (Full HD): 24-inch (PPI 91.79, pixel pitch 0.28 mm)

NOTE: Panel Type of the chosen monitor needs to be: IPS (In-Plane Switching).

For other possible monitor choices see footnote [²].

1. Check or Compute Physical DPI (from EDID)

aka: Actual pixel density of the monitor
aka: Commands you use for DPI diagnostics

$ xrandr --prop | grep -w connected   # gives pixels + mm size

Then, compute the physical DPI:

(pixels / millimeters) x 25.4

For an example of computing physical DPI, see 11a. Compute Physical DPI.

NOTE: EDID may sometimes report incorrect millimeter sizes.

2. Check X Server DPI (rarely meaningful)

aka: What Xorg calculates at startup from EDID or overrides (e.g., overrides by commands)

aka: What Xorg thinks your DPI is
aka: “xdpyinfo dots-per-inch” (often physical DPI, not logical DPI)

Shown in:

$ xdpyinfo | grep dots

For an example of using xdpyinfo to get X Server DPI, see 11b. X Server DPI.

Almost never affects anything modern.
Only very old X11 programs care.
Cannot be changed live.

3. Check Logical DPI (Read X Resources)

aka: Xft.dpi
aka: What apps use
aka: User-controlled DPI (or Effective user scaling)

Toolkit DPI, used by Fontconfig/Xft, GTK, Qt, and many modern apps.

Shown in:

$ xrdb -query | grep Xft.dpi

Also:

$ grep Xft.dpi ~/.Xresources

Can be changed live via xrdb -merge.

For an example using xrdb -query or using grep on .Xresources to query the logical DPI, see 11c. Logical DPI.

Set Logical DPI (Recommended Workflow)

Logical DPI = Xft.dpi, controls font scaling for modern apps.

Where is the logical DPI set?

See 3a, 3b, 3c.

3a. To set logical DPI temporary - during the current X session

$ printf "%s\n" "Xft.dpi:  120" | xrdb -merge

3b. To set logical DPI permanently

Add the following line to ~/.Xresources:

Xft.dpi: 120

3c. To set X server DPI (requires restart) - rarely meaningful

aka: Change logical DPI server-wide

$ startx -- -dpi 120

4. Recommended Flexible Workflow

Keep Xft.dpi = 120 - 144, and adjust individual toolkits/apps via environment variables instead of relying on a Desktop Environment (DE). Works well in FVWM3 + FreeBSD.

Why DPI of 120 to 144?

120 DPI = 96 x 1.25, and 144 DPI = 96 x 1.50, which are clean, well-tested 125% and 150% scaling steps.

$ printf "%s\n" "scale = 2; 94 * 1.5" | bc
141.0

$ printf "%s\n" "scale = 2; 96 * 1.25" | bc
120.00

$ printf "%s\n" "scale = 2; 96 * 1.5" | bc
144.0

In X11, DPI increments historically follow multiples of: 96 (baseline), 120 (scale: 1.25x), 144 (1.5x), 168 (1.75x), 192 (2x), … These values have the best support across: Xft, Fontconfig, GTK2/GTK3, Qt, Web engines (Firefox/Chromium), …

STEP A - Compute physical DPI (optional but recommended)
- Use (11a) Example.

STEP B - Choose a starting logical DPI

Based on comfort + physical DPI.

Use this table:

| Physical DPI | Recommended Xft.dpi |
| ------------ | ------------------- |
| 70-90        | 96-110              |
| 90-110       | 96-132              |
| 110-140      | 120-144             |
| 140-200      | 120-168             |
| >200         | 150-200 (HiDPI zone)|

For my preference (96-120 comfortable PPI):
- Start at Xft.dpi: 120.
- Try 132 or 144 if needed.

STEP C - Set logical DPI

For the current X session:

$ printf "%s\n" "Xft.dpi: 120" | xrdb -merge

To survive system restart:

$ printf "%s\n" "Xft.dpi: 120" >> ~/.Xresources
$ xrdb ~/.Xresources

Restart apps.

5. Understanding DPI Differences

Toolkits use different DPI systems:

| Concept      | Command                    | Meaning         | Matches       |
|              |                            |                 | Physical DPI? |
|--------------|----------------------------|-----------------|---------------|
| Physical DPI | xrandr                     | Actual          | Always        |
|              |   or                       | pixel           |               |
|              | xdpyinfo dimensions        | density         |               |
|--------------|----------------------------|-----------------|---------------|
| X Server DPI | xdpyinfo | grep dots       | What Xorg uses  | Sometimes     |
|              |                            | internally      |               |
|--------------|----------------------------|-----------------|---------------|
| Logical DPI  | xrdb -query | grep Xft.dpi | Font/UI scaling | Usually       |
|              |                            | for toolkits    | different     |

6. Toolkit and Application Notes (Short)

aka: How toolkits and applications interpret scaling

Xterm

I use bitmap fonts (XLFD) in Xterm.

Use XLFD names in ~/.Xresources.
Bitmap X core fonts (XLFD) - unaffected by DPI changes.
Xterm with (Fontconfig/Freetype) fonts (OTF/TTF) -> obeys Xft.dpi.

GTK

GTK2 (font sizes) Configured via ~/.gtkrc-2.0.
GTK3 (scaling + font sizes) Configured via: ~/.config/gtk-3.0/settings.ini.
GDK Environment Variables
```
GDK_SCALE=1
GDK_DPI_SCALE=1
```
Firefox/Thunderbird
```
layout.css.devPixelsPerPx = 1.0
```

NOTE: It’s recommanded to install the package lxappearance to manage the GTK themes.

Qt5/Qt6 (e.g. KeePassXC, ReText, etc.)

Environment variables:

QT_SCALE_FACTOR=1.0
QT_FONT_DPI=144
QT_AUTO_SCREEN_SCALE_FACTOR=0

7. Recommended X11 Workflow (Non‑DE)

Best overall workflow for FVWM3 + FreeBSD

Set Xft DPI globally:
```
Xft.dpi: 120
```
Leave X Server DPI (startx -- -dpi 120) untouched (do not chase it).
Adjust individual toolkits:
- QT_FONT_DPI=120
- GTK_THEME, gsettings, or settings.ini for GTK
- Firefox/Thunderbird: layout.css.devPixelsPerPx = 1.0
Adjust xterm with XLFD font sizes.

This avoids XSETTINGS daemons and keeps scaling predictable.

8. High-Level Rules

Rule 1: Xft.dpi controls almost all modern GUI apps.
Rule 2: X server DPI (xdpyinfo dots) rarely matters today.
Rule 3: Bitmap fonts ignore scaling (hardcoded pixel sizes).
Rule 4: For laptop screens with physical DPI > ~132, typical comfort values:
- 120-144 DPI (~120%-150% scaling)
Rule 5: Set Xft.dpi in .Xresources -> consistent behavior across apps.

9. Q&A

What is EDID?
EDID = Extended Display Identification Data. EDID is metadata stored in the display panel firmware that tells the GPU and OS about the display’s characteristics. These characteristics include: physical dimensions (mm), display name/model, preferred resolution, supported modes.

X uses EDID to determine physical size -> which determines physical DPI.
Xorg does not measure your screen.
- It only reports what the EDID claims.

What sets physical DPI?
EDID.

Which DPI do apps use?
Logical DPI.

Is X Server DPI the same as physical DPI?
No. They often match but are not guaranteed to. Xorg computes DPI at startup using EDID or policy. xdpyinfo -> dots per inch may differ from actual monitor DPI.
If EDID size is wrong or the system forces 96 DPI, xdpyinfo | grep dots will not reflect real DPI.

Is logical DPI the same as X Server DPI?
No. Xft.dpi is a separate logical value used by toolkits.

Can logical DPI be changed live?
Yes, with: xrdb -merge.

Can X Server DPI be changed live?

No.
Requires restarting X.
- Shut down X: In my case, in the window manager (FVWM3), choose the “Exit” menu item. (Alternatively, run pkill Xorg from the terminal emulator.)
- Then, initialize an X session with this command: startx -- -dpi 120.

Does xrandr show DPI?
No. It shows millimeter size; DPI must be computed manually.

Why does Xorg snap DPI to 96/120/144/etc.?
Legacy X11 relies on values divisible by 12 (1/12‑inch granularity).

10. Terminology: PPI vs DPI vs Pixel Pitch

PPI (Pixels Per Inch): Number of pixels along one inch of screen - very relevant for monitors.
DPI (Dots Per Inch): Originally for printing - number of dots of ink per inch. When used for screens it’s often used loosely like “screen DPI” but technically PPI is more appropriate.
Are PPI and DPI approximately the same? Yes - when vendors say “DPI” for a monitor, they often mean “PPI”. So for practical purposes you can treat a monitor with ~100 PPI as ~100 DPI.
Pixel Pitch: Distance between the centres of two adjacent pixels (usually in mm).
- Relationship: PPI ~= 25.4/pixel‐pitch (mm)
- Example: Pixel pitch 0.27 mm => PPI ~= 25.4/0.27 ~= 94.1

| Pixel Pitch | PPI (approx.) |
| ----------- | ------------- |
| 0.31 mm     | 82 PPI        |
| 0.29 mm     | 88 PPI        |
| 0.27 mm     | 94 PPI        |
| 0.25 mm     | 102 PPI       |
| 0.23 mm     | 110 PPI       |
| 0.20 mm     | 127 PPI       |
| 0.16 mm     | 159 PPI       |
| 0.12 mm     | 212 PPI       |

So for my use (text, terminal use), aiming for PPI ~90-110 is a good target.

11. Examples

11a. Compute Physical DPI

Physical DPI = (pixels / millimeters) x 25.4

$ xrandr | grep -w connected
eDP-1 connected primary 1920x1200+0+0 (normal left inverted right x axis y axis) 301mm x 188mm

$ printf "%s\n" "scale = 2; (1920 / 301) * 25.4" | bc
161.79
 
$ printf "%s\n" "scale = 2; (1200 / 188) * 25.4" | bc
162.05

Horizontal physical DPI ~162. Vertial physical DPI ~162.

Physical DPI = ~162.

(11b) X Server DPI

$ xdpyinfo | grep dots
  resolution:    162x162 dots per inch

X Server DPI = 162.

(11c) Logical DPI

$ xrdb -query | grep Xft.dpi
Xft.dpi:  120 

$ grep Xft.dpi ~/.Xresources
Xft.dpi:  120 

12. Toolkit Analyzers - xdpi and qtdpi

NOTE: For directions on how to build and install xdpi and qtdpi, see my post Building and Using xdpi on FreeBSD - About DPI and HiDPI.

xdpi and qtdpi confirm how toolkits actually perceive DPI.

Useful because toolkits sometimes guess wrong physical DPI.

Resources and References

GitHub - Oblomov/xdpi: X11 DPI information retrieval
Mixed DPI and the X Window System
Display DPI detector - find out DPI of your monitor

A square with 1 inch width and 1 inch height is shown below.

1” x 1”

DPI is based on CSS 1” size in pixels and might be inaccurate on some operating systems, notably mobile phones. You can easily check if DPI is detected correctly by measuring the black square above with a ruler. If it is different from 1” then DPI value should be adjusted accordingly. To display a square of a different size please click on one of the buttons below.

1” 2” 4” 4cm 8cm
Screen resolution detector - find out resolution of your monitor

For my 14-inch WUXGA screen:

Your screen resolution and color depth are: 1920 x 1200 x 24 (width x height x color depth) Your display aspect ratio is: 8 / 5 = 1.6

Screen resolution is the number of pixels your monitor have in horizontal and vertical dimensions. Another characteristic of the screen resolution is color depth which measures the number of bits representing color of each pixel. Higher screen resolution is commonly associated with higher productivity as you can see more information at the same time and don’t have to switch between windows frequently. As a result increasing your screen resolution is often a better investment than buying a faster processor or more memory.
How to Pick a Good Monitor for Software Development
DPI Calculator / PPI Calculator
Screen DPI Calculator
Monitor DPI Calculator
TFTCentral - Monitor reviews, articles, information and news
srandrd - simple randr daemon

srandrd(1) is a tool that executes a command on xrandr output change events, i.e. if a monitor is plugged or unplugged. By default srandrd forks to background and exits if the xserver exits.
Time to upgrade your monitor
Time to Upgrade Your Monitor - Hacker News

Footnotes

[1] Sometimes xdpyinfo doesn’t show dimensions for the current monitor (screen or output). For example, after I unplugged an external monitor from my laptop, without restarting X (X11, X Window System), xdpyinfo was showing dimensions of only the external monitor:

$ xdpyinfo | grep dimensions
  dimensions:    2560x1440 pixels (334x188 millimeters)

However, the laptop’s screen (eDP-1) was actually 301x188 mm, 1920x1200 pixels:

$ grep "Display dimensions" /var/log/Xorg.0.log
[686196.891] (**) modeset(0): Display dimensions: (301, 188) mm

$ grep "using initial mode" /var/log/Xorg.0.log
[686196.891] (II) modeset(0): Output eDP-1 using initial mode 1920x1200 +0+0
[686196.891] (II) modeset(0): Output DP-1 using initial mode 2560x1440 +1920+0

$ xrandr --verbose | grep -w connected
eDP-1 connected primary 1920x1200+0+0 (0x49) normal (normal left inverted right x axis y axis) 301mm x 188mm
 
$ xrandr --verbose | grep -w disconnected | grep '0mm x 0mm'
DP-1 disconnected 2560x1440+0+0 (0x96) normal (normal left inverted right x axis y axis) 0mm x 0mm

Similarly, the X Server log file, /var/log/Xorg.0.log, sometimes doesn’t show correct DPI for the current monitor.

$ grep DPI /var/log/Xorg.0.log

While this command should show the DPI value Xorg is using, it might not always reflect the physical DPI of your monitor, especially if Xorg is unable to correctly determine the display’s physical dimensions or if a default DPI (like 96 DPI) is being applied. For a more accurate physical DPI calculation, you need to manually compute it from its actual physical dimensions and resolution (pixels).

As above with xdpyinfo, after I unplugged an external monitor from my laptop, without restarting X (X11, X Window System), the Xorg log file was not showing correct physical DPI:

$ grep DPI /var/log/Xorg.0.log
[686196.891] (**) modeset(0): DPI set to (378, 194)

[2] Possible monitors for use with laptop.

| Resolution                 | Diagonal Size | PPI    | Dot Pitch     |
| (Horizontal x Vertical )   | (inches)      |        | (Pixel Pitch) |
| (pixels)                   |               |        | (mm)          |

| 1920x1080 (FHD or Full HD) | 27            | 81.59  | 0.31          |
|                            | 25            | 88.12  | 0.29          |
|                            | 24            | 91.79  | 0.28          |
|                            | 22            | 100.13 | 0.25          |
|                            | 21            | 104.90 | 0.24          |
|                            | 19            | 115.94 | 0.22          |

| 1920x1200 (WUXGA or 1200p) | 27            | 83.86  | 0.30          |
|                            | 25            | 90.57  | 0.28          | 
|                            | 24            | 94.34  | 0.27          |
|                            | 22            | 102.92 | 0.25          |
|                            | 20            | 113.21 | 0.22          |
|                            | 16            | 114.51 | 0.18          |

| 2560x1440 (WQHD, 1440p)    | 32            | 91.79  | 0.28          |
|                            | 27            | 108.79 | 0.23          |
|                            | 24            | 122.38 | 0.21          |
|                            | 25            | 117.49 | 0.22          |
|                            | 22            | 133.51 | 0.19          |

X11 DPI Reference

Sat, 22 Nov 2025 22:22:17 +0000

X11 DPI & Font Scaling: Essential Reference

My environment:

FreeBSD 14.3
Shell: csh
WM (window manager): FVWM3
No DE (Desktop Environment)

TL;DR

For my 14-inch laptop, set Xft.dpi: 120 in ~/.Xresources to match the external monitor scaling.
Physical DPI (from EDID): use xdpyinfo | grep dimensions -> compute with (pixels/mm) × 25.4.
Logical DPI (what apps use): check with xrdb -query | grep Xft.dpi.
xdpyinfo shows X server DPI (rarely used by modern apps).
Modern apps (GTK, Qt, Firefox, Thunderbird) need their own scaling settings.
Xft.dpi can be changed live (xrdb -merge). X server DPI cannot.
Scaling on X11 is per-toolkit; no universal scaling unless inside a Desktop Environment.
For Firefox/Thunderbird, use layout.css.devPixelsPerPx = 1.0 for 1× scaling.
xterm for bitmap fonts (XLFD) uses its own font sizes, independent of DPI.

1. Core Terms

Physical dimensions - The size of the display in millimeters, usually read from EDID.

Physical DPI - Pixels per inch computed from physical size; often inaccurate on laptops.

Logical DPI - The DPI value X uses for UI and font scaling; controlled by Xft.dpi or XSETTINGS.

Global Xft.dpi - A logical DPI value that affects all applications using Xft/Fontconfig (not XLFD).

X Server DPI (xdpyinfo DPI) - The DPI value determined by the X server at startup, based on EDID or defaulting to 96.

EDID - A small data block from the display that reports resolution, size, and capabilities.

2. What Each Command Shows

xdpyinfo - Shows what the X server believes: physical size, resolution, and the X server’s DPI.

xrandr - Shows physical size and resolution per output, as reported via EDID.

xrdb -query - Shows the current logical DPI (Xft.dpi) used by Xft/Fontconfig-based apps.

/var/log/Xorg.0.log - Shows EDID-reported millimeter size and the DPI computed by Xorg at startup.

xdpi (external tool) - Shows physical DPI per display using EDID values.

3. Commands

Show X server DPI

xdpyinfo | grep -i dots

Show Xft.dpi (logical DPI for modern font rendering)

xrdb -query | grep -i dpi

Show physical dimensions and resolution

xdpyinfo | grep dimensions
xrandr | grep -w connected

Show EDID-derived dimensions from Xorg

grep -i "dimension" /var/log/Xorg.0.log

4. DPI Formulas

Physical DPI:

(pixels / millimeters) × 25.4

Logical DPI - no formula; it’s whatever you set in:

~/.Xresources (Xft.dpi)
xrdb -merge
A desktop environment’s XSETTINGS daemon

5. Examples

Example laptop:

Resolution: 1920 × 1200
Size:       301 × 188 mm

Physical DPI:

(1200 / 188) × 25.4 = 162.05
(1920 / 301) × 25.4 = 161.79
≈ 162 DPI

If Xft.dpi is set to 120 (in ~/.Xresources):

xrdb -query | grep Xft.dpi -> 120 
xdpyinfo -> still shows 162 (X server DPI)

This is normal because X server DPI does not change automatically when Xft.dpi changes.

6. Changing DPI

Change logical DPI (affects fonts/UI in modern apps)

printf "Xft.dpi: 120" | xrdb -merge

Effective immediately for most apps (you’ll probably need to restart them).

Change X server DPI (rare, requires restart)

startx -- -dpi 120

Or add to Xorg config.

Changing X server DPI live is generally not supported.

7. Q&A

Q: How do I check physical DPI?
A: xdpyinfo | grep dimensions or xrandr, then compute using the formula.

Q: How do I check logical DPI?
A: xrdb -query | grep Xft.dpi.

Q: Why do xdpyinfo DPI and Xft.dpi differ?
A: xdpyinfo shows X server DPI; Xft.dpi is a separate logical DPI for modern font systems.

Q: Is Xft.dpi global?
A: Yes - global for all Xft/Fontconfig-based applications; does not affect legacy XLFD apps.

Q: Can I change Xft.dpi live?
A: Yes, using xrdb -merge.

Q: Can I change the X server DPI live?
A: No, it requires restarting X.

Q: How can I verify whether EDID-reported millimeters are correct?
A: Compare xrandr or xdpyinfo millimeter values with the actual physical measurement of the screen.

8. Additional Answers for FreeBSD + FVWM3 Environment

What DPI should I set on my laptop?
To match a 94-DPI external monitor, set Xft.dpi: 120 so all Fontconfig/Xft applications scale similarly.

Can this be set globally?
Yes: put Xft.dpi: 120 in ~/.Xresources and load with xrdb -merge. Some toolkits (GTK, Qt, Firefox, Thunderbird) still need separate per-toolkit scaling.

Is today’s scaling situation per-application?
Yes. There is no universal scaling across X11; each toolkit may require overrides.

Font scaling vs. full scaling
Font scaling affects text size only. Full scaling enlarges entire UI elements (buttons, icons, padding, windows), typically via toolkit DPI multipliers.

Do I need fractional scaling?
No. Since you want ~120 DPI, set Xft.dpi: 120 and adjust toolkit settings; fractional scaling is mostly needed for DEs (Desktop Environments)

Do apps render at their own resolution?
Yes. Applications draw at native resolution unless toolkit scaling is applied.

Why is scaling difficult?
Because each toolkit (GTK, Qt, Xlib, Xft) uses its own environment variables and X settings.

Which tools give DPI?

Physical DPI: xdpyinfo, xrandr, Xorg logs, xdpi.
Logical DPI: xrdb -query (Xft.dpi).
Real DPI: same as physical DPI.
xrandr shows physical size but does not compute DPI.

DPI vs PPI?
DPI originated from printing; PPI is correct for screens. In practice, DPI ~= PPI.

Can Xft.dpi be changed live?
Yes: printf "Xft.dpi: 120" | xrdb -merge.
Toolkit-specific DPI (Qt, GTK) can also be changed live via environment variables.

What do xdpi and qtdpi report?
xdpi reports EDID-based physical DPI. qtdpi reports logical DPI per screen (Qt’s internal interpretation).

Toolkits you need to configure:

GTK2: ~/.gtkrc-2.0 (font sizes).
GTK3: ~/.config/gtk-3.0/settings.ini (scaling + font sizes).
Qt5/Qt6: env vars (QT_SCALE_FACTOR, QT_FONT_DPI, etc.).
Firefox/Thunderbird: set layout.css.devPixelsPerPx = 1.0 for 1× scaling.

xterm scaling (for bitmap fonts)
Bitmap fonts: use XLFD names in ~/.Xresources.

Compiling and Building X11 Program on FreeBSD

Sun, 09 Nov 2025 19:52:34 +0000

Alternate title: “Building and Using xdpi and qtdpi on FreeBSD - DPI and Pixel Density”

xdpi - Display DPI and Physical Dimensions from X11/XCB

xdpi queries Xlib, XRandR, Xinerama, and XCB to reveal the actual pixel density and physical dimensions reported by your X server. It’s a tiny diagnostic tool that helps you understand why your display looks the way it does.

From the project’s Github Oblomov - xdpi: X11 DPI information retrieval:

xdpi - This is a small C program that retrieves all information about DPI (dots per inch) of the available displays in X11.

[ . . . ]

qtdpi - A simple program to illustrate how Qt 5.6 and higher handle DPI information depending on the application settings

My environment: FreeBSD 14.3, Shell: csh, WM (window manager): FVWM3, No DE (Des ktop Environment), Lenovo ThinkPad T14s Gen 3 (14”, Intel) laptop - 14-inch WUXGA (Wide Ultra XGA), 1920 by 1200 pixels - So, not strictly High DPI (HighDPI or HiDPI) display but still a Very High Pixel Density (140+ PPI) panel.

Xlib (aka libX11) - X Window System Protocol Client Library

Xlib (also known as libX11) is an X Window System protocol client library written in the C programming language. It contains functions for interacting with an X server. These functions allow programmers to write programs without knowing the details of the X protocol.

Applications usually don’t use Xlib directly; rather, they employ other libraries that use Xlib functions to provide widget toolkits (to generate GUI applications): Xt (X Toolkit Intrinsics), Xaw (Athena widget set), Motif, FLTK, GTK, Qt (X11 version), Tk (an extension for the Tcl scripting language), SDL (Simple DirectMedia Layer), SFML (Simple and Fast Multimedia Library), which in turn use Xlib for interacting with the server [X server].

How to Build xdpi

Step 1 - Get the source code

Clone the repository:

$ git clone https://github.com/Oblomov/xdpi/ 
$ cd xdpi

Step 2 - Check prerequisites

FreeBSD installs X11 components under /usr/local.

Check that the required X11 development libraries are installed:

$ pkg info | egrep 'libX11 | libXrandr | libXinerama | libxcb | xcb-util | xcb-util-xrm | xorgproto'

If any are missing, install them:

$ sudo pkg install libX11 libXrandr libXinerama libxcb xcb-util xcb-util-xrm xorgproto

Step 3 - Build (preferred and alternatives)

Preferred (recommended) - pkg-config (simple, portable, correct).

This asks pkg-config(8) for the right include & link flags for your system:

$ cc -std=c99 xdpi.c `pkg-config --cflags --libs x11 xrandr xinerama xcb xcb-randr xcb-xinerama xcb-xrm` -lm -o xdpi

pkg-config returns the correct -I and -L -l pieces (on FreeBSD those will point to /usr/local/include and /usr/local/lib).

Backup manual method (if pkg-config is unavailable)

$ cc -std=c99 -I/usr/local/include -L/usr/local/lib -D_THREAD_SAFE xdpi.c -lX11 -lXrandr -lXinerama -lxcb -lxcb-randr -lxcb-xinerama -lxcb-xrm -lm -o xdpi

NOTE: How the manual compile line was derived? - aka - Why these flags?

These flags come directly from the libraries the program includes.

Looking at the source code (xdpi.c), you see includes like:

$ grep include xdpi.c
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <X11/Xlib.h>
#include <X11/extensions/Xinerama.h>
#include <X11/extensions/Xrandr.h>
#include <xcb/xproto.h>
#include <xcb/xinerama.h>
#include <xcb/randr.h>
#include <xcb/xcb_xrm.h>

Rule of thumb - when analyzing a C/C++ source file and classifying headers (header names) as likely standard or non-standard based on the presence of a directory prefix:

No directory, simple name -> probably standard C.
Directory-prefixed name (X11/, xcb/, GL/) -> external library.

For external libraries, each header implies one library must be linked [2]:

NOTES:

Header–library is not alwasy one-to-one: Including a header does not guarantee you need to link a library - some headers are purely inline macros or depend on other headers, but for X11/XCB extensions, you generally do need the corresponding library.
Library dependencies cascade: For example, linking -lXrandr may implicitly require -lX11 because libXrandr depends on it. Similarly, linking XCB extensions often requires -lxcb.
For portability, using pkg-config is preferred. For example:

$ cc myprog.c `pkg-config --cflags --libs x11 xrandr xinerama xcb xcb-randr xcb-xinerama xcb-xrm` -o myprog

Here’s a table that provides the safest approach to explicitly list headers<->libraries<->FreeBSD package names, so that the user can manually supply -I and -L options and link -l libraries:

+----------------------------+-----------------+-----------------------+
| Header                     | Library         | FreeBSD Package       |
|----------------------------|-----------------|-----------------------|
| stdio.h, stdlib.h,         | -lm             | base system           |
| string.h, stdint.h, math.h |                 |                       |
| X11/Xlib.h                 | -lX11           | x11/libX11            |
| X11/extensions/Xinerama.h  | -lXinerama      | x11/libXinerama       |
| X11/extensions/Xrandr.h    | -lXrandr        | x11/libXrandr         |
| xcb/xcb.h / xcb/xproto.h   | -lxcb           | x11/libxcb            |
| xcb/randr.h                | -lxcb-randr     | x11/xcb-util-randr    |
| xcb/xinerama.h             | -lxcb-xinerama  | x11/xcb-util-xinerama |
| xcb/xrm.h                  | -lxcb-xrm       | x11/xcb-util-xrm      |
+----------------------------+-----------------+-----------------------+

Notes:
- Linking order matters: XCB extensions follow core X11/XCB.
- Include paths: -I/usr/local/include or -I/usr/local/include/X11
- Library paths: -L/usr/local/lib
- For math functions, always add -lm

FreeBSD stores X11 development headers in:

/usr/local/include
/usr/local/lib

So you add the following flags for cc(1) (clang(1)) [3]:

-I/usr/local/include
-L/usr/local/lib

In summary, the logic behind the flags - aka Why these flags?

-I/usr/local/include -L/usr/local/lib: FreeBSD installs X headers/libs under /usr/local (not /usr).
-lX11 -lXrandr -lXinerama: link the Xlib and extensions used by the program.
-lxcb -lxcb-randr -lxcb-xinerama -lxcb-xrm: link the optional xcb support libraries.
-lm: math library (used by the program).
-std=c99: program is written for C99.

NOTE: Why wasn’t <xcb/xproto.h> checked in the pkg or header checks?

Because:

xcb/xproto.h comes from the core libxcb package, not from one of the extension-specific packages.

On FreeBSD, installing libxcb always provides it. The file lives at:

/usr/local/include/xcb/xproto.h

When you checked for:

libxcb xcb-util xcb-util-xrm

you implicitly covered the presence of the libxcb development headers, so the assumption was:

if libxcb is installed, xproto.h is guaranteed.

The check list was aimed at extension libraries that might or might not be installed (randr, xinerama, xcb-xrm).

Core XCB is “always included” and therefore not usually listed.

If you want a robust checklist, you can explicitly check for it. It doesn’t harm, and it makes the steps feel complete.

Something like:

$ pkg info | grep ^libxcb
libxcb-1.17.0                  The X protocol C-language Binding (XCB) library

or explicit headers:

$ test -f /usr/local/include/xcb/xproto.h && echo "xproto.h OK"

Why pkg-config didn’t require anything special for it?

pkg-config --cflags --libs xcb automatically pulls in the correct include path for the core XCB headers. It doesn’t list the header names; it only provides the flags needed to find them.

So xccb/xproto.h was silently handled by the xcb package’s metadata.

In short:

<xcb/xproto.h> is installed by the base libxcb package.
That package was already included in your checks (libxcb).
That’s why it didn’t get its own dedicated check line.
If you prefer explicit completeness, add a quick header test or a pkg info libxcb.

Alternatively, a quick header check:

$ ls /usr/local/include/X11/Xlib.h \
   /usr/local/include/X11/extensions/Xrandr.h \
   /usr/local/include/X11/extensions/Xinerama.h \
   /usr/local/include/xcb/randr.h \
   /usr/local/include/xcb/xinerama.h \
   /usr/local/include/xcb/xcb_xrm.h || echo "some headers missing"

Makefile method (for automation or packaging)

The supplied Makefile is convenient. On FreeBSD it may override your environment CPPFLAGS.

It works after adding these two lines for appending pkg-config-derived flags to the Makefile:

CPPFLAGS += $(shell pkg-config --cflags x11 xrandr xinerama xcb xcb-randr xcb-xinerama xcb-xrm)

LDLIBS += $(shell pkg-config --libs x11 xrandr xinerama xcb xcb-randr xcb-xinerama xcb-xrm)

Then simply run:

$ make

Step 4 - Install

For personal use:

$ install -m 755 xdpi ~/bin/

For system-wide use (as root):

$ install -m 755 xdpi /usr/local/bin/

Step 5 - Run

$ xdpi

This reports DPI for each connected monitor and suggests per-monitor scaling ratios.

What the output means

xdpi reports the physical size, pixel resolution, and computed DPI for each connected display, using Xlib, XRandR, and Xinerama. It helps determine correct DPI values and optional scaling ratios when working with mixed-DPI monitors.

Example useful lines:

eDP-1: ... 162x162 dpi - laptop screen DPI
HDMI-1: ... 94x94 dpi  - external monitor DPI
Xft.dpi: 94            - global Xft DPI visible to many GUI toolkits

Step 6. Short summary

Preferred modern method: use pkg-config (cc … pkg-config --cflags --libs ...) - simple, portable, correct.
Backup manual method: add -I/usr/local/include -L/usr/local/lib and the -l flags manually.
Makefile method: fine for automation; on FreeBSD you may need to append pkg-config flags or override CPPFLAGS/LDFLAGS as shown above.

How to Build qtdpi

$ command -V qmake; type qmake; which qmake; whereis -a qmake; where -a qmake
qmake: not found
qmake: not found
qmake: Command not found.
qmake: /usr/ports/devel/qmake
 
$ command -V qmake-qt5; type qmake-qt5; which qmake-qt5; whereis -a qmake-qt5; where -a qmake-qt5
qmake-qt5 is /usr/local/bin/qmake-qt5
qmake-qt5 is /usr/local/bin/qmake-qt5
/usr/local/bin/qmake-qt5
qmake-qt5: /usr/local/bin/qmake-qt5 /usr/ports/devel/qt5-qmake/work/stage/usr/local/bin/qmake-qt5
/usr/local/bin/qmake-qt5
 
$ command -V qmake6; type qmake6; which qmake6; whereis -a qmake6; where -a qmake6 
qmake6 is /usr/local/bin/qmake6
qmake6 is /usr/local/bin/qmake6
/usr/local/bin/qmake6
qmake6: /usr/local/bin/qmake6
/usr/local/bin/qmake6

$ cd xdpi/qt

$ ls -Alh
total 10
-rw-r--r--  1 dusko wheel   35B Nov  4 16:55 .gitignore
-rw-r--r--  1 dusko wheel  1.4K Nov  4 16:55 main.cpp
-rw-r--r--  1 dusko wheel  258B Nov  4 16:55 qtdpi.pro

$ qmake-qt5
Info: creating stash file /tmp/xdpi/qt/.qmake.stash

$ ls -Alhrt
total 23
-rw-r--r--  1 dusko wheel   35B Nov  4 16:55 .gitignore
-rw-r--r--  1 dusko wheel  1.4K Nov  4 16:55 main.cpp
-rw-r--r--  1 dusko wheel  258B Nov  4 16:55 qtdpi.pro
-rw-r--r--  1 dusko wheel  669B Nov 11 16:11 .qmake.stash
-rw-r--r--  1 dusko wheel   26K Nov 11 16:11 Makefile

$ make
clang++ -c -pipe -Wextra -g -std=c++11 -Wall -Wextra -pthread -fPIC -DQT_GUI_LIB -DQT_CORE_LIB -I. -I/usr/local/include/qt5 -I/usr/local/include/qt5/QtGui -I/usr/local/include/qt5/QtCore -I. -I/usr/local/include -I/usr/local/include -I/usr/local/lib/qt5/mkspecs/freebsd-clang -o main.o main.cpp
clang++ -pthread -Wl,-rpath,/usr/local/lib/qt5 -o qtdpi main.o   -L/usr/local/lib /usr/local/lib/qt5/libQt5Gui.so /usr/local/lib/qt5/libQt5Core.so -lGL

$ ls -Alhrt
total 708
-rw-r--r--  1 dusko wheel   35B Nov  4 16:55 .gitignore
-rw-r--r--  1 dusko wheel  1.4K Nov  4 16:55 main.cpp
-rw-r--r--  1 dusko wheel  258B Nov  4 16:55 qtdpi.pro
-rw-r--r--  1 dusko wheel  669B Nov 11 16:11 .qmake.stash
-rw-r--r--  1 dusko wheel   26K Nov 11 16:11 Makefile
-rw-r--r--  1 dusko wheel  1.0M Nov 11 16:12 main.o
-rwxr-xr-x  1 dusko wheel  606K Nov 11 16:12 qtdpi
 
$ file qtdpi
qtdpi: ELF 64-bit LSB executable, x86-64, version 1 (FreeBSD), dynamically linked, interpreter /libexec/ld-elf.so.1, for FreeBSD 14.3, FreeBSD-style, with debug_info, not stripped

With a single monitor (laptop only):

$ ./qtdpi
QT version: 0x50f11
Enable/Disable: 0/0
Global pixel ratio: 1
Screens: 1
        eDP-1 @ (0,0) size (1920, 1200):
                Physical DPI: 162.074
                 Logical DPI: 144
                 pixel ratio: 1
Enable/Disable: 0/1
Global pixel ratio: 1
Screens: 1
        eDP-1 @ (0,0) size (1920, 1200):
                Physical DPI: 162.074
                 Logical DPI: 144
                 pixel ratio: 1
Enable/Disable: 1/0
Global pixel ratio: 2
Screens: 1
        eDP-1 @ (0,0) size (960, 600):
                Physical DPI: 81.0369
                 Logical DPI: 96
                 pixel ratio: 2
Enable/Disable: 1/1
Global pixel ratio: 1
Screens: 1
        eDP-1 @ (0,0) size (1920, 1200):
                Physical DPI: 162.074
                 Logical DPI: 144
                 pixel ratio: 1

Resources

GitHub - Oblomov/xdpi: X11 DPI information retrieval
X11 DPI information retrieval

This is a small C program that retrieves all information about DPI (dots per inch) of the available displays in X11. Information from both the core protocol and the XRANDR extension is presented. Xinerama information (which lacks physical dimensions, and is thus not directly useful to determine output DPI) is also presented. If an XSETTINGS daemon is found, the reported (scaled and raw) Xft/DPI value is presented.

(Limitation: XSETTINGS is currently only shown for Xlib, not xcb.)

From the retrieved information, xdpi will also compute (and present) “proposed” per-monitor/per-output UI scaling factors, assuming a reference 96 DPI. Each scaling factor is computed as a single-precision floating-point integer, and four values are shown:
- the floor (largest integer no larger than),
- the value itself,
- the rounded value (closest integer),
- and the ceiling (smallest integer no smaller than).
For each monitor/output, both the native scaling factors (based on the reported DPI) and the prorated factors (which take into account the ratio of the core DPI to the primary output DPI) are shown.

Finally, to improve the usefulness of xdpi as a debugging tool, we also show the content of the following known-relevant environment variables, if set:
- CLUTTER_SCALE
- GDK_SCALE
- GDK_DPI_SCALE
- QT_AUTO_SCREEN_SCALE_FACTOR
- QT_SCALE_FACTOR
- QT_SCREEN_SCALE_FACTORS
- QT_DEVICE_PIXEL_RATIO
Qt

A simple program to illustrate how Qt 5.6 and higher handle DPI information depending on the application settings Qt::AA_EnableHighDpiScaling and Qt::AA_DisableHighDpiScaling can be found in the qt directory.

Build it with
```
qmake && make
```
and then run it with
```
./qtdpi
```
If your qmake by defaults builds against Qt4, run qtmake -qt=5 before make.
Mixed DPI and the X Window System

I’m writing this article because I’m getting tired of repeating the same conce pts every time someone makes misinformed statements about the (lack of) support for mixed-DPI configurations in X11. It is my hope that anybody looking for information on the subject may be direc ted here, to get the facts about the actual possibilities offered by the protoco l, avoiding the biased misinformation available from other sources.
(Simple:) A Flawless i3wm experience on a HiDPI/Retina display
(Very useful:) x11 - How to scale the resolution/display of the desktop and/or applications? - Unix & Linux Stack Exchange <– For Qt and GDK/Gnome environment variables
Linux High DPI Settings - Lobsters
Linux High DPI Settings
How to set custom resolution using xrandr when the resolution is not available in ‘Display Settings’
Configuring mixed DPI monitors with xrandr

I use xrandr to configure a dual monitor setup with a high DPI and low DPI monitor on Linux. I also use it to switch back and forth between a dual monitor and a single monitor setup.
Handling different DPI settings for different monitors - GitHub gist - xrandr-config.md

// Taken from: https://blog.summercat.com/configuring-mixed-dpi-monitors-with-xrandr.html
Improving Linux HiDPI Support For Gnome, KDE, Xfce, Cinnamon And Firefox
Using Archlinux on a Retina (HiDPI) MacBook Pro with Xmonad
High DPI Displays - Qt 5.15

High DPI Displays

High DPI displays have increased pixel density, compared to standard DPI displays.

Pixel density is measured in Dots per Inch (DPI) or Pixels per Inch (PPI), and is determined by the number of display pixels and their size. Consequently, the number of pixels alone isn’t enough to determine if a display falls into the high-DPI category.

A 4K monitor has a fixed number of pixels (~8M), however its DPI varies between 185 (23 inches) and 110 (40 inches). The former is around twice the standard 96 DPI desktop resolution; the latter barely exceeds this resolution.
High-DPI displays and Linux [LWN.net]
Display DPI detector - find out DPI of your monitor
HOWTO set DPI in Xorg
xorg - How does Linux’s display work? - Unix & Linux Stack Exchange
x11 - Is X DPI (dot per inch) setting just meant for text scaling? - Unix & Linux Stack Exchange
xrandr with XPS 13” (3840x2160) HiDPI and 30” (2560x1600) LowDPI
new laptop with 2560x1660 resolution but programs are too small on arch. Adjusting the DPI isn’t really changing applications like chrome/firefox, is there an equivalent to the windows scale?
multiple monitors - XRandR DPI on multihead linux - Super User
How to find and change the screen DPI?
HiDPI - ArchWiki - wiki.archlinux.org
[Solved][xfce] What should be proper way to set correct DPI for laptop
Xsettingsd - ArchWiki - wiki.archlinux.org

Footnotes

[1] EDID (Extended Display Identification Data) is a small block of metadata stored inside your display (monitor, laptop panel, projector, etc.). It’s provided by the display hardware to the graphics card so that the operating system (Xorg, Wayland, Windows, macOS, etc.) knows:

The display’s native resolution
The physical size (millimeters)
Supported refresh rates
Colour characteristics
Vendor/model information
Preferred timing modes

Xorg reads this data from the GPU/driver.

Details

EDID is stored in the screen hardware.
For laptop panels, it is inside the LCD panel’s firmware (EEPROM).
Xorg does not measure the screen. Instead, it only reports what the EDID claims.

[2] The other includes:

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

are all part of the C standard library (libc on FreeBSD, glibc on Linux, etc.) and the standard C headers. On FreeBSD (or any modern Unix-like OSs):

They come with the compiler and system C library.
You do not need to install anything extra from ports/packages to use them.
They are automatically available when you invoke cc or clang (or any standard-compliant compiler).

In contrast:

#include <X11/Xlib.h>
#include <X11/extensions/Xinerama.h>
#include <X11/extensions/Xrandr.h>
#include <xcb/xproto.h>
#include <xcb/xinerama.h>
#include <xcb/randr.h>
#include <xcb/xcb_xrm.h>

These do not come with the standard compiler.
They are part of the X11 and XCB development libraries, which must be installed separately via ports/packages (like libX11, libXrandr*, libxcb`, etc.).

So the rule of thumb is:

Standard C headers -> always included, no extra installation.
X11/other GUI or third-party libraries -> may require installation of -devel or equivalent packages.

This is why the pkg info | egrep ... check only looks for libX11, libXrandr, libxcb, etc., and not the standard C headers.

[3] Why /usr/bin/cc and /usr/bin/clang look identical?

FreeBSD uses Clang as its system compiler - not GCC - and has done so for years.

To ensure build scripts work across Unix systems, FreeBSD provides:

/usr/bin/cc (the traditional POSIX C compiler name)
/usr/bin/clang (the actual compiler)

On FreeBSD, cc is just Clang with a different name. It is not a symlink. It is a hardlink

That’s why the following listing shows:

$ ls -lh /usr/bin/cc
-r-xr-xr-x  6 root wheel  105M Jul 13 12:50 /usr/bin/cc

$ ls -lh /usr/bin/clang
-r-xr-xr-x  6 root wheel  105M Jul 13 12:50 /usr/bin/clang

And the size and timestamp match exactly. The “6” before root is the link count: meaning that six filenames point to the same underlying file.

$ diff /usr/bin/cc /usr/bin/clang

shows nothing because they are literally the same executable.

In addition to the identical size and link count as clues for showing that they are hardlinks, here’s the canonical way for confirming it:

$ ls -li /usr/bin/cc /usr/bin/clang

You’ll see the same inode number.

Same inode -> same file.

Let’s check:

$ ls -li /usr/bin/cc /usr/bin/clang

Output:

165166 -r-xr-xr-x  6 root wheel 110230808 Jul 13 12:50 /usr/bin/cc
165166 -r-xr-xr-x  6 root wheel 110230808 Jul 13 12:50 /usr/bin/clang

$ command -V cc; type cc; which cc; whereis -a cc; where -a cc
cc is /usr/bin/cc
cc is /usr/bin/cc
/usr/bin/cc
cc: /usr/bin/cc /usr/share/man/man1/cc.1.gz /usr/share/man/man4/cc.4.gz /usr/ports/devel/py-pyperscan/files/cc /usr/ports/lang/quilc/files/cc /usr/src/contrib/netbsd-tests/usr.bin/cc
/usr/bin/cc

$ command -V clang; type clang; which clang; whereis -a clang; where -a clang
clang is /usr/bin/clang
clang is /usr/bin/clang
/usr/bin/clang
clang: /usr/bin/clang /usr/share/man/man1/clang.1.gz /usr/src/usr.bin/clang /usr/ports/devel/llvm11/files/clang /usr/ports/emulators/wine-proton/files/clang /usr/src/contrib/llvm-project/clang /usr/src/contrib/llvm-project/clang/include/clang /usr/src/usr.bin/clang/clang
/usr/bin/clang

Why FreeBSD does this?

Portability.

Many build systems (e.g., ancient autoconf scripts) expect:

cc = system C compiler
gcc = GNU compiler, if available
clang = Clang, if available

FreeBSD ensures that:

cc  -> clang
c++ -> clang++

This keeps the system consistent and avoids breaking thousands of build scripts.

So which one should you use?

For compiling xdpi or any C program on FreeBSD:

cc

is the canonical choice.

It points to Clang anyway, and that’s what FreeBSD expects.

You can use clang explicitly if you want to, but it makes no difference.

Why does FreeBSD use hardlinks instead of symlinks?

Because:

Hardlinks survive chroot environments more predictably.
Some early-boot tools need a real binary, not a symlink.
It makes the compiler available even in minimal environments.

It’s a robust-choice tradition in BSD land.

Summary

cc is Clang.
clang is Clang.

They are two faces of the same compiler.

You can use either, and FreeBSD will happily treat them as the same being wearing different hats.

FreeBSD avoids shipping GCC for base, but still provides it in ports.

HOWTO Change Themes and Colours in GTK Applications

Tue, 07 Oct 2025 17:28:08 +0000

AKA: HOWTO Change Themes and Colours in Zim Desktop Wiki

OS: FreeBSD 14

% freebsd-version 
14.3-RELEASE-p1

Shell:

% ps $$
  PID TT  STAT    TIME COMMAND
43316  8  Ss   0:00.13 -csh (csh)

X11 Window Manager:

% cat ~/.xinitrc
---- snip ----
exec fvwm3

% env GTK_DEBUG=interactive zim

In the debugger, click ‘Visual’ tab.

For ‘GTK+ Theme’ drop-down menu, change it from ‘decay’ to some other theme, e.g. Yaru-viridian.

GTK themes are in:

/usr/local/share/themes/

Example:

% cat /usr/local/share/themes/Yaru-viridian/index.theme
[Desktop Entry]
Name=Yaru-viridian
Type=X-GNOME-Metatheme
Comment=Ubuntu Yaru-viridian theme
Encoding=UTF-8

[X-GNOME-Metatheme]
GtkTheme=Yaru-viridian
MetacityTheme=Yaru
IconTheme=Yaru-viridian
CursorTheme=Yaru
CursorSize=24
X-Yaru-Dark=false
X-Yaru-Accent-Name=viridian
X-Yaru-Accent-Color=#03875B

% cat /usr/local/share/themes/Yaru-viridian/gtk-3.0/gtk.css
@import url("resource:///com/ubuntu/themes/Yaru-viridian/3.0/gtk.css");

% ls -Alh ~/.config/gtk-3.0/
total 9
-rw-r--r--  1 dusko wheel  226B Oct  7 21:02 gtk.css
-rw-r--r--  1 dusko wheel  467B Mar  5  2025 settings.ini

% grep theme ~/.config/gtk-3.0/settings.ini
gtk-cursor-theme-name=XCursor-Pro-Decay
gtk-cursor-theme-size=0
gtk-icon-theme-name=Papirus-Dark
gtk-theme-name=decay

% grep gtk-theme-name ~/.config/gtk-3.0/settings.ini
gtk-theme-name=decay

This worked (you can ignore warnings):

% env GTK_THEME=Yaru-viridian zim

References

ASCII/Unicode Control Characters (^L in Terminal)

Sun, 21 Sep 2025 17:28:08 +0000

AKA: NPC (Non-Printable Characters or Non-Printing Characters)

Word cloud: ASCII Unicode UTF-8 CLI terminal xterm shell console RS232serial “control characters” “ASCII control codes” “C0 control characters” NPC “non-printable characters” “non-printing characters” locale teletype Unix “caret notation” “Control Pictures” FF “Form Feed” “Page break” delimiter marker typography font history “insert ASCII control characters in text” “character escape sequences” “C-style escaped characters” “C escapes” dump “ASCII dump” less(1) xxd(1) hexdump(1) od(1) remind(1)

TLDR: The remind(1) program outputs the Form Feed (FF, ASCII 0x0C, represented as ^L) control character in its calendar displays. Purpose of the FF character in remind(1) output is to facilitate pagination in terminal environments. ^L only becomes visible when the program in the pipeline decides to render it (less, cat -v, od, hexdump).

Tested on FreeBSD 14.3-RELEASE-p1 in xterm (version/patch number 400) with csh shell.

% freebsd-version 
14.3-RELEASE-p1

% ps $$
  PID TT  STAT    TIME COMMAND
70183  5  Ss   0:00.32 -csh (csh)

% printf %s\\n "$SHELL"
/bin/csh

% xterm -version
XTerm(400)

% printf %s\\n "$XTERM_VERSION"
XTerm(400)

% locale
LANG=en_CA.UTF-8
LC_CTYPE="en_CA.UTF-8"
LC_COLLATE="en_CA.UTF-8"
LC_TIME="en_CA.UTF-8"
LC_NUMERIC="en_CA.UTF-8"
LC_MONETARY="en_CA.UTF-8"
LC_MESSAGES="en_CA.UTF-8"
LC_ALL=

What is ^L in Output on Terminal?

For example, when I used remind(1) with less(1), the ouptut had two ^L characters; one in the line separating months, and the other at the end of output, after the last line of the last month displayed.

% remind -c2 /path/to/.reminders  | less
+----------------------------------------------------------------------------+
|                               September 2025                               |
+----------+----------+----------+----------+----------+----------+----------+
|  Sunday  |  Monday  | Tuesday  |Wednesday | Thursday |  Friday  | Saturday |
+----------+----------+----------+----------+----------+----------+----------+
---- snip ----
+----------+----------+----------+----------+----------+----------+----------+
|28        |29        |30        |          |          |          |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
+----------+----------+----------+----------+----------+----------+----------+
^L+----------------------------------------------------------------------------+
|                                October 2025                                |
+----------+----------+----------+----------+----------+----------+----------+
|  Sunday  |  Monday  | Tuesday  |Wednesday | Thursday |  Friday  | Saturday |
+----------+----------+----------+----------+----------+----------+----------+
|          |          |          |1         |2         |3         |4         |
|          |          |          |          |          |          |          |
---- snip ---
+----------+----------+----------+----------+----------+----------+----------+
|26        |27        |28        |29        |30        |31        |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
|          |          |          |          |          |          |          |
+----------+----------+----------+----------+----------+----------+----------+
^L

% remind -c2 /path/to/.reminders  | less --use-color

% remind -c2 /path/to/.reminders | less | tail -1 | xxd
00000000: 0c                                       .

Switch xxd(1) to bits (binary digits) dump, rather than hex dump:

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -b
00000000: 00001100                                               .

As per footnote [¹], the first bit of 00001100 is 0 (zero), so this is a 1-byte character.

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -s0 -l1
00000000: 0c                                       .

Since it’s a 1-byte character, there’s nothing in the next position.

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -s1 -l1

Alternatively, you can use the -g bytes | -groupsize bytes [²] option of the xxd(1) tool, and separate the outupt in groups of 1-byte:

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -g1
00000000: 0c 

% remind -c2 /path/to//.reminders | less | tail -1 | xxd -g1 -b
00000000: 00001100                                               .

Back to the first position (first byte):

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -s0 -l1 -b
00000000: 00001100                                               .

Continuing with the explanation:

00001100 starts with a 0, so it’s a single-byte ASCII character.

What do the remaining bits 00001100 represent?

The bits from that byte (excluding the leading bits) combine to form the binary sequence 1100.

From the man page for ascii(7), for 1100:

     The binary set:

      00     01     10     11

     NUL     SP      @      `     00000
     ---- snip ----
      FF      ,      L      l     01100
     ---- snip ----

So, it’s the line with:

      FF      ,      L      l     01100

Again, from the man page for ascii(7):

    The full names of the control character set:

     NUL      NULl
     ---- snip ----
      FF      new page Form Feed
     ---- snip ----

It’s the Form Feed character, abbreviated FF.

Binary 1100 is 12 in decimal. [³]

% printf "obase=10; ibase=2; 1100" | bc
12

From the man page for ascii(7), for 12:

     The decimal set:

       0 NUL    1 SOH    2 STX    3 ETX    4 EOT    5 ENQ    6 ACK    7 BEL
       8 BS     9 HT    10 LF    11 VT    12 FF    13 CR    14 SO    15 SI

So, 12 is FF (Form Feed).

By default, xxd(1) creates a hexadecimal dump (a hex dump):

% remind -c2 /path/to/.reminders | less | tail -1 | xxd -s0 -l1 
00000000: 0c  

From the man page for ascii(7), for C (0c);

     The hexadecimal set:

     00 NUL   01 SOH   02 STX   03 ETX   04 EOT   05 ENQ   06 ACK   07 BEL
     08 BS    09 HT    0a LF    0b VT    0c FF    0d CR    0e SO    0f SI

So, 0c is FF (Form Feed).

% remind -c2 /path/to/.reminders | less | tail -1 | cat -v
^L%

From the man page for cat(1):

     -v      Display non-printing characters so they are visible.
             Control characters print as `^X' for control-X; the delete
             character (octal 0177) prints as `^?'. 
             Non-ASCII characters (with the high bit set) are printed as
             `M-' (for meta) followed by the character for the low 7 bits.

QUESTION: Why L?

ANSWER: From the man page for ascii(7):

     The binary set:
               
      00     01     10     11
               
     NUL     SP      @      `     00000
     ---- snip ----
      FF      ,      L      l     01100

Also, from Unicode lookup table source: UnicodeData.txt:

0000;<control>;Cc;0;BN;;;;;N;NULL;;;;
---- snip ----
000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;;
---- snip ----

Cc: control character

WS: white space

From Control character (“Non-printable character” redirects here) - Wikipedia:

0x0C (form feed, FF, \f, ^L), to cause a printer to eject paper to the top of the next page, or a video terminal to clear the screen.

From Page break - Wikipedia: [⁴]

The form feed character is sometimes used in plain text files of source code as a delimiter for a page break, or as marker for sections of code. Some editors, in particular emacs and vi, have built-in commands to page up/down on the form feed character. This convention is predominantly used in Lisp code, and is also seen in C and Python source code. GNU Coding Standards require such form feeds in C.

From Insert ASCII Control Characters in Text:

It is possible to insert ASCII Control Characters while editing test with the insert, append, replace or substitute commands. Some Control Characters are inserted directly by typing x:
<ctrl>G bell
<ctrl>L form feed
Be careful: x can operate directly as editor command (i.e. `[` operates **insert break**).

If we want to insert a *visible <, we must use: `V` followed by ``. The full set of *vi* supported control characters is listed in the following table.

[ . . . ]

In UTF-8 Tool, select Hex code point

UTF-8 Tool, Hex UTF-8 bytes

Output:

Character: ^L (Invisible in web browser but appears when copy-paste in terminal)
Character name: FORM FEED (FF)
Hex code point: 000C
Decimal code point: 12
Hex UTF-8 bytes: 0C
Octal UTF-8 bytes: 14
UTF-8 bytes as Latin-1 characters bytes: <0C>

Notes:

Some browsers may not be able to display all Unicode characters; they may display blanks, boxes, or question marks for some characters. Installing more fonts may help.
Cutting and pasting does not work reliably in all browsers.
When cutting and pasting hex numbers from dump output on little-endian machines (eg x86), beware of byte order problems.
Hex numbers should not be prefixed with "0x", "U+", or anything else.
When entering a character in UTF-8 as multiple hex or octal bytes, the bytes should be separated by spaces.
"UTF-8 bytes as Latin-1 characters" is what you typically see when you display a UTF-8 file with a terminal or editor that only knows about 8-bit characters.
Spaces are ignored in the input of bytes as Latin-1 characters, to make it easier to cut-and-paste from dump output.

Additionally (having in mind that the Form Feed character is a non-printable character):

Complete Character List for UTF-8

Unicode Character ‘FORM FEED (FF)’ (U+000C)

Fonts that support U+000C

LastResort font

Unifont font

The uconv(1) also says that it’s a control character.

% remind -c2 /path/to/.reminders | less | tail -1 | uconv -x 'any-name'
\N{<control-000C>}% 

% remind -c2 /path/to/.reminders | less | tail -1 | hexdump
0000000 000c
0000001

% remind -c2 /path/to/.reminders | less | tail -1 | hexdump -c
0000000  \f
0000001

% remind -c2 /path/to/.reminders | less | tail -1 | hexdump -C
00000000  0c                                                |.|
00000001

From the man page for hexdump(1) - AKA standard escape notation:

     The single character escape sequences described in the C
     standard are supported:

           NUL                  \0
           <alert character>    \a
           <backspace>          \b
           <form-feed>          \f
           <newline>            \n
           <carriage return>    \r
           <tab>                \t
           <vertical tab>       \v

So, the line with \f is form-feed:

           <form-feed>          \f

hexdump Format Strings

% hexdump -e ' [iterations]/[byte_count] "[format string]" '

From the man page for hexdump(1):

A format string contains any number of format units, separated by
whitespace.  A format unit contains up to three items: an iteration
count, a byte count, and a format.

The iteration count is an optional positive integer, which defaults to
one.  Each format is applied iteration count times.

The byte count is an optional positive integer.  If specified it defines
the number of bytes to be interpreted by each iteration of the format.

If an iteration count and/or a byte count is specified, a single slash
must be placed after the iteration count and/or before the byte count to
disambiguate them.  Any whitespace before or after the slash is ignored.

The format is required and must be surrounded by double quote (" ") marks.
It is interpreted as a fprintf-style format string (see fprintf(3)),
with the following exceptions:
---- snip ----

Continuing with the man page for hexdump(1):

     The hexdump utility also supports the following additional conversion
     strings:

---- snip ----

     _u          Output US ASCII characters, with the exception that control
                 characters are displayed using the following, lower-case,
                 names.  Characters greater than 0xff, hexadecimal, are
                 displayed as hexadecimal strings.

                 000 NUL  001 SOH  002 STX  003 ETX  004 EOT  005 ENQ
                 006 ACK  007 BEL  008 BS   009 HT   00A LF   00B VT
                 00C FF   00D CR   00E SO   00F SI   010 DLE  011 DC1
                 012 DC2  013 DC3  014 DC4  015 NAK  016 SYN  017 ETB
                 018 CAN  019 EM   01A SUB  01B ESC  01C FS   01D GS
                 01E RS   01F US   07F DEL

So, the control character FF (form feed) is 0xC in hexadecimal in ASCII:

                 00C FF   00D CR   00E SO   00F SI   010 DLE  011 DC1

% remind -c2 /path/to/.reminders | tail -1 | hexdump -e '"%_u"'
ff% 
 
% remind -c2 /path/to/.reminders | tail -1 | hexdump -e '"%_u\n"'
ff

The _p conversion string outputs characters in the default character set. Nonprinting characters are displayed as a single “.”.

% remind -c2 /path/to/.reminders | tail -1 | hexdump -e '"%_p"'
.% 

The _c conversion string outputs characters in the default character set. Nonprinting characters are displayed in three character, zero-padded octal, except for those representable by standard escape notation (see above), which are displayed as two character strings.

% remind -c2 /path/to/.reminders | tail -1 | hexdump -e '"%_c"'
\f% 

Output named characters:

% remind -c2 /path/to/.reminders | less | tail -1 | od -a
0000000   ff
0000001

Output C-style escaped characters:

% remind -c2 /path/to/.reminders | less | tail -1 | od -c
0000000   \f
0000001

Combine -a and -c options to display both named characters and C-style escaped characters:

% remind -c2 /path/to/.reminders | less | tail -1 | od -a -c
0000000   ff
          \f
0000001

From the man page for od(1):

     -a         Output named characters.  Equivalent to -t a.
     -c         Output C-style escaped characters.  Equivalent to -t c.

     -t type    Specify the output format.  The type argument is a string
                containing one or more of the following kinds of type
                specifiers:

                a       Named characters (ASCII).  Control characters are
                        displayed using the following names:

                        000 NUL 001 SOH 002 STX 003 ETX 004 EOT 005 ENQ
                        006 ACK 007 BEL 008 BS  009 HT  00A NL  00B VT
                        00C FF  00D CR  00E SO  00F SI  010 DLE 011 DC1
                        012 DC2 013 DC3 014 DC4 015 NAK 016 SYN 017 ETB
                        018 CAN 019 EM  01A SUB 01B ESC 01C FS  01D GS
                        01E RS  01F US  020 SP  07F DEL

                c       Characters in the default character set.  Non-printing
                        characters are represented as 3-digit octal character
                        codes, except the following characters, which are
                        represented as C escapes:

                        NUL              \0
                        alert            \a
                        backspace        \b
                        newline          \n
                        carriage-return  \r
                        tab              \t
                        vertical tab     \v

                        Multi-byte characters are displayed in the area
                        corresponding to the first byte of the character.  The
                        remaining bytes are shown as ‘**’.

                [d|o|u|x][C|S|I|L|n]
                        Signed decimal (d), octal (o), unsigned decimal (u) or
                        hexadecimal (x).  Followed by an optional size
                        specifier, which may be either C (char), S (short), I
                        (int), L (long), or a byte count as a decimal integer.

                f[F|D|L|n]
                        Floating-point number.  Followed by an optional size
                        specifier, which may be either F (float), D (double)
                        or L (long double).

The line:

                        00C FF  00D CR  00E SO  00F SI  010 DLE 011 DC1

indicates that 00C is FF (Form Feed).

Position

Dump (ASCII dump) the first byte (-j <skip> option: skip <skip> bytes), that is, skip zero (0) bytes), using named characters and dumping no more than 1 byte:

% remind -c2 /path/to/.reminders | tail -1 | od -An -a -j 0 -N 1
          ff

Same as above but skip the first byte:

% remind -c2 /path/to/.reminders | tail -1 | od -An -a -j 1 -N 1

If you try to skip 2 bytes, which is end of input in this case:

% remind -c2 /path/to/.reminders | tail -1 | od -An -a -j 2 -N 1
od: cannot skip past end of input

From Unicode control characters - Wikipedia:

U+000C FORM FEED (FF) (denotes a page break in a plain text file)

From C0 and C1 control codes:

The C0 and C1 control code or control character sets define control codes for use in text by computer systems that use ASCII and derivatives of ASCII. The codes represent additional information about the text, such as the position of a cursor, an instruction to start a new line, or a message that the text has been received.

[ . . . ]

C0 controls

ASCII defines 32 control characters, plus the DEL character. This large number of codes was desirable at the time, as multi-byte controls would require implementation of a state machine in the terminal, which was very difficult with contemporary electronics and mechanical terminals.

Only a few codes have maintained their use: BEL, ESC, and the format effector (FEn) characters BS, TAB, LF, VT, FF, and CR.

[ . . . ]

Unicode provides Control Pictures that can replace C0 control characters to make them visible on screen. However, caret notation is used more often.

From ASCII control codes, originally defined in ANSI X3.4:
Caret notation: ^L
Decimal:        12
Hexadecimal:    0C 
Abbreviations:  FE4,FF
Name:           Form Feed
C escape:       \f
Description:    Move down to the top of the next page. 

Control Pictures - AKA Unicode Control Pictures

Control Pictures is a Unicode block containing characters for graphically representing the C0 control codes, and other control characters. Its block name in Unicode 1.0 was Pictures for Control Codes.

Control Picture for FF (Form Feed): ␌

Caret Notation

From Caret notation - Wikipedia

Caret notation is a notation for control characters in ASCII. The notation assigns ^A to control-code 1, sequentially through the alphabet to ^Z assigned to control-code 26 (0x1A). For the control-codes outside of the range 1–26, the notation extends to the adjacent, non-alphabetic ASCII characters.

Often a control character can be typed on a keyboard by holding down the Ctrl and typing the character shown after the caret. The notation is often used to describe keyboard shortcuts even though the control character is not actually used (as in “type ^X to cut the text”).

The meaning or interpretation of, or response to the individual control-codes is not prescribed by the caret notation.

[ . . . ]

Description

The notation consists of a caret (^) followed by a single character (usually a capital letter). The character has the ASCII code equal to the control code with the bit representing 0x40 reversed. A useful mnemonic, this has the effect of rendering the control codes 1 through 26 as ^A through ^Z. Seven ASCII control characters map outside the upper-case alphabet: 0 (NUL) is ^@, 27 (ESC) is ^[, 28 (FS) is ^\, 29 (GS) is ^], 30 (RS) is ^^, 31 (US) is ^_, and 127 (DEL) is ^?.

[ . . . ]

There is no corresponding version of the caret notation for control-codes with more than 7 bits such as the C1 control characters from 128–159 (0x80–0x9F). Some programs that produce caret notation show these as backslash and octal (“\200” through “\237”).

[ . . . ]

See also

C0 and C1 control codes, which shows the caret notation for all C0 control codes as well as DEL.

From the man page for less(1):

DESCRIPTION
   Less is a program similar to more(1), but it has many more features.
   Less does not have to read the entire input file before starting, so
   with large input files it starts up faster than text editors like
   vi(1).  Less uses termcap (or terminfo on some systems), so it can run
   on a variety of terminals.  There is even limited support for hardcopy
   terminals.  (On a hardcopy terminal, lines which should be printed at
   the top of the screen are prefixed with a caret.)

---- snip ----

   -r or --raw-control-chars
          Causes "raw" control characters to be displayed.  The default is
          to display control characters using the caret notation; for
          example, a control-A (octal 001) is displayed as "^A" (with some
          exceptions as described under the -U option).  Warning: when the
          -r option is used, less cannot keep track of the actual
          appearance of the screen (since this depends on how the screen
          responds to each type of control character).  Thus, various
          display problems may result, such as long lines being split in
          the wrong place.

          USE OF THE -r OPTION IS NOT RECOMMENDED.

---- snip ----

   --intr=c
          Use the character c instead of ^X to interrupt a read when the
          "Waiting for data" message is displayed.  c must be an ASCII
          character; that is, one with a value between 1 and 127
          inclusive.  A caret followed by a single character can be used
          to specify a control character.
---- snip ----

       Control and binary characters are displayed in standout (reverse
       video).  Each such character is displayed in caret notation if possible
       (e.g. ^A for control-A).  Caret notation is used only if inverting the
       0100 bit results in a normal printable character.  Otherwise, the
       character is displayed as a hex number in angle brackets.  This format
       can be changed by setting the LESSBINFMT environment variable.

Extracted from above:

On a hardcopy terminal, lines which should be printed at the top of the screen are prefixed with a caret.

The default is to display control characters using the caret notation; for example, a control-A (octal 001) is displayed as “^A” (with some exceptions as described under the -U option).

A caret followed by a single character can be used to specify a control character.

Control and binary characters are displayed in standout (reverse video). Each such character is displayed in caret notation if possible (e.g. ^A for control-A). Caret notation is used only if inverting the 0100 bit results in a normal printable character.

And, from the man page for lesskey(1):

The characters in the string may appear literally, or be prefixed by a caret to indicate a control key.

Footnotes

[1] UTF-8 Encoding – UTF-8 Playground

UTF-8 Encoding

UTF-8 is a variable-width character encoding designed to represent every character in the Unicode character set, encompassing characters from most of the world’s writing systems.

It encodes characters using one to four bytes. The first 128 characters (U+0000 to U+007F) are encoded with a single byte, ensuring backward compatibility with ASCII (read my post on this↗), while other characters require two, three, or four bytes.

The leading bits of the first byte determine the total number of bytes in the character. These bits follow one of four specific patterns, which indicate how many continuation bytes follow.
   0xxxxxxx: 1 byte
       0xxxxxxx
   110xxxxx: 2 bytes
       110xxxxx 10xxxxxx
   1110xxxx: 3 bytes
       1110xxxx 10xxxxxx 10xxxxxx
   11110xxx: 4 bytes
       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
The second, third, and fourth bytes in a multi-byte sequence always start with 10. This indicates that these bytes are continuation bytes, following the main byte.

The remaining bits in the main byte, along with the bits in the continuation bytes, are combined to form the character’s code point. A code point serves as a unique identifier for a character in the Unicode character set.

[2] From the man page for xxd(1):

   -g bytes | -groupsize bytes
         Separate the output of every <bytes> bytes (two hex characters
         or eight bit digits each) by a whitespace.  Specify -g 0 to
         suppress grouping.  <Bytes> defaults to 2 in normal mode, 4 in
         little-endian mode and 1 in bits mode.  Grouping does not apply
         to PostScript or include style.

[3] Rest assured that it’s known how to convert binary to decimal:

x 2^0 = 0 x 1 = 0
x 2^1 = 0 x 2 = 0
x 2^2 = 1 x 4 = 4
x 2^3 = 1 x 8 = 8

4 + 8 = 12

[4] More about Page break/Form feed Page break - Wikipedia: [⁴]

A page break is a marker in an electronic document that tells the document interpreter the content which follows is part of a new page. A page break causes a form feed to be sent to the printer during spooling of the document to the printer. It is one of the elements that contributes to pagination.

Form feed

Form feed is a page-breaking ASCII control character. It directs the printer to eject the current page and to continue printing at the top of another. It will often also cause a carriage return. The form feed character code is defined as 12 (0xC in hexadecimal), and may be represented as Ctrl+L or ^L.

In a related use, Ctrl+L can be pressed to clear the screen in Unix shells such as bash, or redraw the screen in TUI programs like vi/emacs. In the C programming language (and other languages derived from C), the form feed character is represented as '\f'.

Unicode also provides the character U+21A1 ↡ DOWNWARDS TWO HEADED ARROW as a printable symbol for a form feed (not as the form feed itself). The form feed character is considered whitespace by the C character classification function isspace().

[ . . . ]

Semantic use

The form feed character is sometimes used in plain text files of source code as a delimiter for a page break, or as marker for sections of code. Some editors, in particular emacs and vi, have built-in commands to page up/down on the form feed character. This convention is predominantly used in Lisp code, and is also seen in C and Python source code. GNU Coding Standards require such form feeds in C. [⁵]

[5] GNU Coding Standards - Use formfeed characters (control-L) to divide the program into pages at logical places:

Please use formfeed characters (control-L) to divide the program into pages at logical places (but not within a function). It does not matter just how long the pages are, since they do not have to fit on a printed page. The formfeeds should appear alone on lines by themselves.

References

Remind - a sophisticated calendar and alarm program
UTF-8 is a Brilliant Design (Posted on 2025-09-12. Retrieved on 2025-09-20.)
The first time I learned about UTF-8 encoding, I was fascinated by how well-thought and brilliantly it was designed to represent millions of characters from different languages and scripts, and still be backward compatible with ASCII.

Basically UTF-8 uses 32 bits and the old ASCII uses 7 bits, but UTF-8 is designed in such a way that:
- Every ASCII encoded file is a valid UTF-8 file.
- Every UTF-8 encoded file that has only ASCII characters is a valid ASCII file.
Designing a system that scales to millions of characters and still be compatible with the old systems that use just 128 characters is a brilliant design.
UTF-8 Playground
UTF-8 Encoding

UTF-8 is a variable-width character encoding designed to represent every character in the Unicode character set, encompassing characters from most of the world’s writing systems.

It encodes characters using one to four bytes. The first 128 characters (U+0000 to U+007F) are encoded with a single byte, ensuring backward compatibility with ASCII (read my post on this↗), while other characters require two, three, or four bytes.

The leading bits of the first byte determine the total number of bytes in the character. These bits follow one of four specific patterns, which indicate how many continuation bytes follow.
```
   0xxxxxxx: 1 byte
       0xxxxxxx
   110xxxxx: 2 bytes
       110xxxxx 10xxxxxx
   1110xxxx: 3 bytes
       1110xxxx 10xxxxxx 10xxxxxx
   11110xxx: 4 bytes
       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
```
The second, third, and fourth bytes in a multi-byte sequence always start with 10. This indicates that these bytes are continuation bytes, following the main byte.

The remaining bits in the main byte, along with the bits in the continuation bytes, are combined to form the character’s code point. A code point serves as a unique identifier for a character in the Unicode character set.
Complete Character List for UTF-8
Unicode Character ‘FORM FEED (FF)’ (U+000C)
Fonts that support U+000C
LastResort font - fileformat
Unifont font - fileformat
Control character - Wikipedia
Page break - Wikipedia
C0 and C1 control codes
How to get the unicode characters for CTRL+B, CTRL+L, ALT+K, etc…?
Four Column ASCII
I always thought it was a shame the ASCII table is rarely shown in columns (or rows) of 32

I always thought it was a shame the ascii table is rarely shown in columns (or rows) of 32, as it makes a lot of this quite obvious. e.g., http://pastebin.com/cdaga5i1

It becomes immediately obvious why, e.g., ^[ becomes escape. Or that the alphabet is just 40h + the ordinal position of the letter (or 60h for lower-case). Or that we shift between upper & lower-case with a single bit.

esr’s rendering of the table - forcing it to fit hexadecimal as eight groups of 4 bits, rather than four groups of 5 bits, makes the relationship between ^I and tab, or ^[ and escape, nearly invisible.

It’s like making the periodic table 16 elements wide because we’re partial to hex, and then wondering why no-one can spot the relationships anymore.
UTF-8 Tool
Why “caffè” may not be “caffè”
Unicode encodings - Programming with Unicode book
Insert ASCII Control Characters in Text
ASCII control codes
Unicode lookup table source: UnicodeData.txt
Transform Rule Tutorial - ICU Documentation (useful for uconv)
Unicode - a brief introduction (advanced
Control keys and control characters

Control-[

Some control characters correspond to characters other than letters. If you flip the second bit of the ASCII code for [ you get the control character for escape.
And in some software, such as vi or Emacs, Control-[ has the same effect as the escape key.

[ . . . ]

[1] Control keys are often written with capital letters, like Control-H. This can be misleading if you think this means you have to also hold down the shift key as if you were typing a capital H. Control-h would be better notation. But the ASCII codes for control characters correspond to capital letters, so I use capital letters here.
How UTF-8 works
ASCII Table
GNU coding standards stipulates formfeed in source code. Why? (gnu.org)

Simple X11 Setup - Notes

Sun, 31 Aug 2025 19:38:13 +0000

Word cloud: font, typography, kerning, bitmap, XLFD, monospaced, fixed, fixed-pitch, fixed-width, non-proportional, proportional, variable-pitch, glyph, XLFD, laptop, 14-inch screen, monitor, display, WUXGA (Wide Ultra XGA), High DPI (HighDPI or HiDPI), Very High Density (140+ PPI), FreeType, Xft, fontconfig, .otf, .ttf, .ttc, .bdf, Unicode, UTF-8, xterm, terminal, shell, CLI

My Notes from How to configure X11 in a simple way by Eugene Andrienko

(Posted on 2025-07-24. Retrieved on 2025-08-31.)

My Primary Concerns

Display: 14-inch WUXGA (Wide Ultra XGA), 1920 by 1200 pixels
- So, not strictly High DPI (HighDPI or HiDPI) display but still a Very High Density (140+ PPI) panel
Fonts
- Shell, terminal - XTerm
- Proportional vs. monospace(d) vs. bitmap (pixel fonts) vs. fixed bitmap vs. TrueType (Xft) [¹]
- Unicode
Brightness

Laptop - Main Screen (Built-In Display)

Very High Density (140+ PPI) DPI Display

aka: “Retina” display

How to setup X server to operate with a Very High Density (140+ PPI) display?

Laptop (and screen/display) used for this setup: Lenovo ThinkPad T14s Gen3

Lenovo ThinkPad T14s Gen3
Screen: 14.0” WUXGA (1920 x 1200), IPS, Anti-Glare, Touch, 100%sRGB, 500 nits, ePrivacy Filter
Display size: 14 inch (diagonal)
Display aspect ratio: 16:10
Resolution (Pixel format): 1920 (H) x 1200 (V)
Active area: 301mm (H) x 188mm (V)
CPU: 12th Gen Intel Core i7-1280P
RAM: 32 GB
OS: FreeBSD 14
Shell: csh
Window Manager: fvwm3 1.1.0

Starting X (X Window System, X11)

% exec xinit  # OR: exec startx

Brightness

Add the following two lines to /boot/loader.conf:

acpi_ibm_load="YES"
acpi_video_load="YES"

Current brightness:

% backlight
brightness: 32

Change brightness:

% backlight 80

% pkg search gammy
gammy-0.9.64_1  Adaptive screen brightness and temperature for Windows and Unix

% sudo pkg install gammy

Start gammy:

% gammy

DPI

% xrandr | wc -l
      47
 
% xrandr --verbose | wc -l
     440

% xrandr | grep "connected primary"
eDP-1 connected primary 1920x1200+0+0 (normal left inverted right x axis y axis) 301mm x 188mm

So, with active area dimensions 301mm x 188mm, my /usr/local/etc/X11/xorg.conf.d/10-intel.conf file looks like this:

% cat /usr/local/etc/X11/xorg.conf.d/10-intel.conf
Section "Monitor"
    Identifier  "MainMonitor"
    Option      "Primary" "true"
    DisplaySize 301 188
EndSection

Section "Device"
    Identifier  "intel"
    Option      "Monitor-eDP-1"   "MainMonitor"
    Option      "Monitor-HDMI-1"  "ExternalMonitor"
EndSection

Section "Screen"
    Identifier "MainScreen"
    Device     "intel"
    Monitor    "MainMonitor"
EndSection

Before the change, DPI on this system was set to 110:

% grep "Xft.dpi" ~/.Xresources
Xft.dpi:    110

% xrdb -query | grep dpi 
Xft.dpi:        110

What should be DPI for this laptop’s screen?

To calculate, use a DPI calculator/PPI calculator; for example:

https://www.sven.de/dpi/

For this laptop’s monitor:

Horizontal resolution: 1920 pixels
Vertical resolution: 1200 pixels
Diagonal: 14 inches
Aspect ratio: 16:10

The result is:

Display size:
11.87" × 7.42" = 88.09in (30.15cm × 18.85cm = 568.32cm) at 
161.73 PPI, 0.1571mm dot pitch, 26155 PPI

That is: DPI is 161.73

Edit the ~/.Xresources file, and change it from 110 to 161.73.

% grep "Xft.dpi" ~/.Xresources
Xft.dpi:    161.73

After that, run xrdb(1) to reload the .Xresources and replace current settings:

% xrdb ~/.Xresources

DPI is now set to 161.73:

% xrdb -query | grep dpi
Xft.dpi:        161.73

Fonts for Use with XTerm

In general, for xterm(1), I prefer using bitmapped (old-style) fixed width fonts when I’m using an external monitor, while for a laptop, I like better OpenType (OTF, new-style) and TrueType fonts (TTF, new-style).

From Install TTF font on xterm (cygwin):

TrueType fonts (TTF) with X are usually done using fontconfig. One of its features is that it looks by default in the .fonts directory under your home directory. You would use fc-list to list the fonts which are available, and use them with the -fa (family name) and -fs (font size) options of xterm. (while xfd has a corresponding -fa option, xfontsel does not).

xset on the other hand, looks for bitmap fonts which are referenced using the XLFD naming convention. You would use xlsfonts for listing those, and the -fn option of xterm.

Fonts for Use with XTerm on This Laptop - Main Screen (Built-In Display)

In order of preference:

0xProto - OpenType Font (OTF), TrueType Font (TTF)

For this laptop, I prefer 0xProto OpenType/TrueType font, so I start xterm with the -fa option (which corresponds to xterm’s faceName resource, and is used for selecting fonts from the FreeType library), and I also use the font size (-fs option) of 12:

% xterm -fa 0xProto -fs 12

To make it permanent, add the following two lines to your ~/.Xresources file:

XTerm*faceName: 0xProto
XTerm*faceSize: 12

Then, to re-read your Xresources file, and throw away your old resources, run:

% xrdb ~/.Xresources

X Core Fonts (Bitmapped, XLFD) for XTerm on This Laptop

As mentioned before, for xterm on the laptop I prefer TrueType and OpenType (new-style) fonts. However, when I sometimes choose to use bitmapped fonts (X core fonts, or old-style font), I like -adobe-courier-medium-r-normal--24-240-75-75-m-150-iso10646-1, so I start xterm with the -fn option.

% xterm -fn "-adobe-courier-medium-r-normal--24-240-75-75-m-150-iso10646-1"

To make it permanent, add the following line to your ~/.Xresources file:

XTerm*font: -adobe-courier-medium-r-normal--24-240-75-75-m-150-iso10646-1

Then, to re-read your Xresources file, and throw away your old resources, run:

% xrdb ~/.Xresources

Other X core (bitmapped, XLFD) fonts that look somewhat good on this laptop:

% xterm -fn "-b&h-lucidatypewriter-medium-r-normal-sans-34-240-100-100-m-200-iso10646-1"

% xterm -fn "-adobe-courier-medium-r-normal--34-240-100-100-m-200-iso10646-1"

% xterm -fn "-b&h-lucidatypewriter-medium-r-normal-sans-24-240-75-75-m-140-iso10646-1"

% xterm -fn "-b&h-lucidatypewriter-medium-r-normal-sans-26-190-100-100-m-159-iso10646-1"

% xterm -fn "-ibm-courier-medium-r-normal--0-0-0-0-m-0-iso10646-1"

% xterm -fn "-b&h-lucidatypewriter-medium-r-normal-sans-20-140-100-100-m-120-iso10646-1"

% xterm -fn "-misc-fixed-medium-r-normal--20-200-75-75-c-100-iso10646-1"

% xterm -fn "-bitstream-terminal-medium-r-normal--18-140-100-100-c-110-iso8859-1"

% xterm -fa '' -fn "-sun-gallant-medium-r-normal--22-220-75-75-c-120-iso10646-1"

For the last font (Gallant Font), you have to install it from https://github.com/NanoBillion/gallant.

Searching for Bitmap Fonts (X Core Fonts, XLFD Fonts)

XLFD: 14 fields. Field names are separated by dashes ‘-‘, and an XLFD font name starts with a dash ‘-‘):

-fndry-fmly-wght-slant-swdth-adstyl-pxlsz-ptsz-resx-resy-spc-avgwdth-rgstry-encdng

For additional searches for an X core font (bitmapped, old-style font), I often use the following XLFD fields.

* wght (Weight): medium
* slant (Slant): r for roman (or upright)
* swdth (Nominal width): normal, condensed
* pxlsz (height, in pixels, of the type - Also called "body size")
* ptsz (height, in points, of the type)
* resx (horizontal screen resolution the font was designed for, in DPI 
* resy (vertical screen resolution the font was designed for, in DPI) 
* spc (the kind of spacing used by the font (its *escapement* class); either 'p' (a *proportional* font containing characters with varied spacing), 'm' (a *monospaced* font containing characters with constant spacing), or 'c' (a *character cell* font containing characters with constant spacing and constant height)
* avgwdth (average width of the characters used in the font, in 1/10th pixel units) 

% xlsfonts | wc -l
   23232
 
% xlsfonts -fn "*" | wc -l
   23232

For example, for the search below with the xlsfonts(1) program: fmly (family): fixed, pxlsz (body size in pixels): 18.

% xlsfonts -fn "*-fixed-*-*-*-*-18-*" | less

This is good on an external monitor, but too small for this laptop:

% xterm -fn "-misc-fixed-medium-r-normal--18-120-100-100-c-90-iso10646-1"

Additional searches:

% xlsfonts -fn "*-fixed-*-*-*-*-24-*" | wc -l
% xlsfonts -fn "*-fixed-*-*-*-*-24-*" | less

% xlsfonts -fn "-*-*-medium-r-normal-*-24-*" | wc -l
% xlsfonts -fn "-*-*-medium-r-normal-*-24-*" | less 

The following search: spacing (11th field: spc): ‘m’ for monospaced - with medium weight (3rd field: wgth) and upright (‘r’ for roman) slant (4th field: slant).

% xlsfonts -fn "-*-*-*-r-normal-*-*-*-*-*-m-*" | wc -l
% xlsfonts -fn "-*-*-*-r-normal-*-*-*-*-*-m-*" | less 

The following search: spacing (11th field: spc): ‘c’ for character cell - with medium weight (3rd field: wgth) and upright (‘r’ for roman) slant (4th field: slant).

% xlsfonts -fn "-*-*-medium-r-normal-*-*-*-*-*-c-*" | wc -l
% xlsfonts -fn "-*-*-medium-r-normal-*-*-*-*-*-c-*" | less 

TODO - Clean this section

For use in X (X11, X Window System), there are two types of fonts:

X core fonts (old-style bitmapped fixed width fonts and Type1 fonts)
OpenType/TrueType (newer) fonts

There are two kinds of fonts in X11: server-side (drawn by the X server, shown in xlsfonts(1)) and client-side (drawn by the application, shown in fc-list(1).

https://man.freebsd.org/cgi/man.cgi?query=xterm&manpath=FreeBSD+10.2-RELEASE+and+Ports

However (even though xfd accepts a “-fa” option to denote FreeType fonts), xfontsel has not been similarly extended.

As a workaround, you may try:
fc-list :scalable=true:spacing=mono: family
to find a list of scalable fixed-pitch fonts which may be used for the faceName resource value.

XTerm’s Default Font - aka: XTerm uses X server’s built-in fixed font

The default font for xterm is an alias fixed.

For more about finding out what it resolves to on your system, see [²].

In short (TLDR):

% xset -q | grep -A1 "Font Path"
Font Path:
  /usr/local/share/fonts/ ---- snip ----

% ls -1 /usr/local/share/fonts/misc/fonts.*
/usr/local/share/fonts/misc/fonts.alias
/usr/local/share/fonts/misc/fonts.dir
/usr/local/share/fonts/misc/fonts.scale

NOTE: With xlsfonts(1):

% xlsfonts -l fixed
DIR  MIN  MAX EXIST DFLT PROP ASC DESC NAME
-->    0  255  some    0   23  11    2 -misc-fixed-medium-r-semicondensed--0-0-75-75-c-0-iso8859-1
-->    0  255  some    0   23  11    2 -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-->    0  255  some    0   23  11    2 -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-->    0  255  some    0   23  11    2 -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-koi8-r

Continuing - with exploring the fonts.alias and fonts.dir files.

% grep ^fixed /usr/local/share/fonts/misc/fonts.alias 
fixed        -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1

So, on my system, fixed alias resolves to -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1.

NOTE: Note that fixed is aliased specifically to the ISO 8859-1 version of the font, not to the Unicode version (which would be ISO 10646-1).

To find out that font’s file:

% grep -- "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1" /usr/local/share/fonts/misc/fonts.dir 
6x13-ISO8859-1.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
6x13-ISO8859-10.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-10
6x13-ISO8859-11.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-11
6x13-ISO8859-13.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-13
6x13-ISO8859-14.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-14
6x13-ISO8859-15.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-15
6x13-ISO8859-16.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-16

% ls /usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz
/usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz

So, on my system, fixed alias resolves to:

-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1

and that font’s file is:

/usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz

Unicode Support

If there is iso10646-1 in XLFD font name: it supports Unicode.

-misc-fixed-medium-o-semicondensed--13-120-75-75-c-60-iso10646-1

vs.

If there is iso8859-1 in XLFD font name: it does not support Unicode.

-misc-fixed-medium-o-semicondensed--13-120-75-75-c-60-iso8859-1

Steps for Laptop with an External Monitor

Open laptop lid
Plug in the external monitor
If the external monitor is blank, run:

% xrandr | grep -w connected

If the output shows only the internal built-in laptop’s screen, for example:

eDP-1 connected primary 1920x1200+0+0 (normal left inverted right x axis y axis) 301mm x 188mm

Exit X11 (aka Xorg, or X Window System):

% pkill Xorg

Start X11:

% exec xinit

If the external monitor is now not blank, you can run:

% xrandr | grep -w connected

OVDE

In this example, the output shows that the screen is extended (aka spanning desktop). Here, the external monitor is to the right of the laptop’s monitor:

eDP-1 connected primary 1920x1200+0+0 (normal left inverted right x axis y axis) 301mm x 188mm
DP-1 connected 2560x1440+1920+0 (normal left inverted right x axis y axis) 518mm x 324mm

If that’s the setup you like, you can stop here.

If, on the other hand, you want a mirrored configuration, run this shell script:

% ./mirror_ext_monitor_xrandr.sh

The content of that script:

% cat mirror_ext_monitor_xrandr.sh
#!/bin/sh

intern=eDP-1
extern=DP-1

xrandr --output "$intern" --primary --auto --output "$extern" --same-as "$intern" --auto

Now, the output from xrandr is:

% xrandr | grep -w connected
eDP-1 connected primary 1920x1200+0+0 (normal left inverted right x axis y axis) 301mm x 188mm
DP-1 connected 2560x1440+0+0 (normal left inverted right x axis y axis) 518mm x 324mm

Fonts for Use with XTerm on an External Monitor

X Core (Bitmapped, Old-Style) Fonts

In contrast to the laptop, with an external monitor, for xterm I prefer bitmapped fonts (X Core fonts, aka old-style fonts).

% xterm -fn "-b&h-lucidatypewriter-medium-r-normal-sans-14-140-75-75-m-90-iso10646-1"

% xterm -fn "-misc-fixed-medium-r-normal--18-120-100-100-c-90-iso8859-1"

% xterm -fn "-misc-fixed-medium-r-normal--20-200-75-75-c-100-iso10646-1"

% xterm -fn "-sun-gallant-medium-r-normal--22-220-75-75-c-120-iso10646-1"
# (You need to install it manually from:
# https://github.com/NanoBillion/gallant)

TrueType and OpenType (New-Style) Fonts

With Fontconfig.

Good but too big:

% xterm -fa 'Monospace' -fs 14

Not so good:

% xterm -fa 'Monospace' -fs 12
% xterm -fa 'Monospace' -fs 11

To list monospaced fonts (with using Fontconfig’s fc-list(1)):

% fc-list | cut -f2 -d: | sort -u | grep -i Mono

TODO:

The Unicode HOWTO: Display setup

TODO:

Pleasant Fonts - FreeBSD Forums
Fonts on Linux, Chapter One: Changing Default and Fallback Fonts with Fontconfig
How To Set Default Fonts and Font Aliases on Linux
UTF8 Playground
UTF8 Playground - Source on GitHub
Font configuration

Although Fontconfig is used often in modern Unix and Unix-like operating systems, some applications rely on the original method of font selection and display, the X Logical Font Description (XLFD).

TODO:

% pkg search terminus-font
terminus-font-4.49.1_1   Terminus Font - a clean fixed width font

% pkg search --regex ^terminus
terminus-font-4.49.1_1   Terminus Font - a clean fixed width font
terminus-ttf-4.49.3      Terminus Font - a clean fixed width font (TTF version)
 
% pkg rquery %dn terminus-font
mkfontscale
fontconfig

% xterm -report-fonts > xterm-report-fonts

% awk '{print $1}' xterm-report-fonts | grep -n "^f[A-Z]"
2:fNorm:
29:fBold:
56:fWide:
83:fWBold:
111:fNorm:
138:fBold:
165:fWide:
192:fWBold:

% sed -n 2p /tmp/xterm-report-fonts 
        fNorm: fixed

% sed -n 29p /tmp/xterm-report-fonts
        fBold: fixed

% sed -n 56p /tmp/xterm-report-fonts
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

% sed -n 83p /tmp/xterm-report-fonts
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

% sed -n 111p /tmp/xterm-report-fonts
        fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

% sed -n 138p /tmp/xterm-report-fonts
        fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

% sed -n 165p /tmp/xterm-report-fonts
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

% sed -n 192p /tmp/xterm-report-fonts
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

References

References - HiDPI, WUXGA, Very High Density (140+ PPI) X11 (Xorg) Setup

How to configure X11 in a simple way by Eugene Andrienko (Posted on 2025-07-24. Retrieved on 2025-08-31.)
HiDPI - ArchWiki
HOWTO set DPI in Xorg - LinuxReviews
Using X For A High Resolution Console On FreeBSD - By Warren Block (Last updated 2011-05-26)
Configure unreadable, tiny, small, …, huge XTerm fonts

References - Lenovo ThinkPad T14s Gen 3 (Intel) Specifications, details

Reference - DPI Calculator / PPI Calculator

DPI Calculator / PPI Calculator

For the laptop from this post, enter:

Horizontal resolution: 1920 pixels
Vertical resolution: 1200 pixels
Diagonal: 14 inches (35.56cm)
Aspect ratio (it was already prepopulated and was not editable): 16:10

Result:

Display size: 11.87” × 7.42” = 88.09in² (30.15cm × 18.85cm = 568.32cm²) at 161.73 PPI (pixels per inch), 0.1571mm dot pitch, 26155 PPI² (pixels per square inch)

References - Fractional scaling, font size, DPI (font scaling)

References - Some people had issues with T14s’ screen

Regretting Buying T14s

Got a used T14s gen 1 and am kind of regretting the purchase, mainly because of the screen quality.

First few days of using it gave me such eye strain and dizziness, I seriously considered going back to a MacBook, even though I don’t really like the OS. Watching videos are fine but somehow text appears fuzzy, how has this not been mentioned more online?

References - Larger XTerm fonts on HiDPI displays, Unicode, Bitmap

Larger XTerm fonts on HIDPI displays
PS8: vncdesk https://github.com/feklee/vncdesk is a good tool to use to scale up a single window: – How to use Xfig on high DPI screen?
How to increase the default font size? - FreeBSD Forums
Courier New-like font with Unicode support?
Per-application window scaling in Xorg for high DPI display
XTERM - Terminal emulator for the X Window System - Thomas E. Dickey’s software development projects – invisible-island.net
Thomas Dickey is the maintainer/developer of xterm, the standard terminal emulator for the X Window System. This page gives some background and pointers to xterm resources.

From XTerm FAQ:

What is XTerm?

From the manual page:
```
The xterm program is a terminal emulator for the X Window System. It provides DEC VT102/VT220 and selected features from higher-level terminals such as VT320/VT420/VT520 (VTxxx). It also provides Tektronix 4014 emulation for programs that cannot use the window system directly. If the underlying operating system supports terminal resizing capabilities (for example, the SIGWINCH signal in systems derived from 4.3bsd), xterm will use the facilities to notify programs running in the window whenever it is resized.
```
That is, xterm (pronounced “eks-term”) is a specific program, not a generic item. It is the standard X terminal emulator program.

[ . . . ]

As a stylistic convention, the capitalized form is “XTerm”, which corresponds to the X resource class name. Similarly, uxterm becomes “UXTerm”.

The bold font is ugly

XTerm lets you directly specify one bold font, which is assumed to correspond to the default font. Older versions of xterm make a fake bold font for the other choices via the fonts menu by drawing the characters offset by one pixel. I modified xterm to ask the font server for a bold font that corresponds to each font (other than the default one). Usually that works well. However, sometimes the font server gives a poor match. Xterm checks for differences in the alignment and size, but the font server may give incorrect information about the font size. The scaled bitmap font feature gives poor results for the smaller fonts. In your X server configuration file, that can be fixed by disabling the feature, e.g., by appending “:unscaled” to the path:
```
FontPath    "/usr/lib/X11/fonts/100dpi/:unscaled"
FontPath    "/usr/lib/X11/fonts/75dpi/:unscaled"
FontPath    "/usr/lib/X11/fonts/misc/:unscaled"
```
You can suppress xterm’s overstriking for bold fonts using the alwaysBoldMode and related resources. However, rendering ugly bold fonts is a “feature” of the font server. In particular, the TrueType interface provides less ability to the client for determining if a particular font supports a bold form.

Hidden gems of XTerm

One important note for users with bitmap fonts: Always select sizes which the fonts are prepared for. If you don’t stick with this rule, you will end up with slow and ugly resampled fonts which is something you don’t want to see. In my case, make sure the sizes match installed fonts (the directory can differ in you distribution - this is Fedora 19):
grep medium /usr/share/fonts/terminus/fonts.dir | grep iso10646
ter-x12n.pcf.gz -xos4-terminus-medium-r-normal--12-120-72-72-c-60-iso10646-1
ter-x14n.pcf.gz -xos4-terminus-medium-r-normal--14-140-72-72-c-80-iso10646-1
ter-x16n.pcf.gz -xos4-terminus-medium-r-normal--16-160-72-72-c-80-iso10646-1
ter-x18n.pcf.gz -xos4-terminus-medium-r-normal--18-180-72-72-c-100-iso10646-1
ter-x20n.pcf.gz -xos4-terminus-medium-r-normal--20-200-72-72-c-100-iso10646-1
ter-x22n.pcf.gz -xos4-terminus-medium-r-normal--22-220-72-72-c-110-iso10646-1
ter-x24n.pcf.gz -xos4-terminus-medium-r-normal--24-240-72-72-c-120-iso10646-1
ter-x28n.pcf.gz -xos4-terminus-medium-r-normal--28-280-72-72-c-140-iso10646-1
ter-x32n.pcf.gz -xos4-terminus-medium-r-normal--32-320-72-72-c-160-iso10646-1
As you can see sizes for the Terminus font are 12, 14, 16, 18, 20, 22, 24, 28 and 32. Note there are keyboard shortcuts for font size, more about them later on.

[ . . . ]

Electronic Font Open Laboratory - /efont/
Distributions
- efont-unicode-bdf/ The Bitmap Font for Unicode.
- shinonome-font/ BDF bitmap font by Yasuyuki Furukawa. Contains 12, 14 and 16 dot fonts.
- efont-japanese-bdf-collection/ The archive which includes Japanese (i.e. JISX0201, 0208 and 0213) and Roman (ISO8859-1) Fonts of some sizes.
- efont-serif/ The modifiable and distributable outline font which is based on Roman type and Mincho type. We are planning to distribute it in TrueType and CID Type-1 formats. The development started on November 29, 2000. Designers and testers are wanted.
- bdfresize/ Bdfresize is a command to magnify or reduce fonts which are described with the standard BDF format. The original author Hiroto Kagotani was pleased to hand over its maintenance to the /efont/.
Fixed (typeface) – misc-fixed – a collection of monospace bitmap fonts distributed with the X Window System – Wikipedia (Retrieved on Aug 31, 2025.)
misc-fixed is a collection of monospace bitmap fonts that is distributed with the X Window System. It is a set of independent bitmap fonts which—apart from all being sans-serif fonts—cannot be described as belonging to a single font family. The misc-fixed fonts were the first fonts available for the X Window System. Their individual origin is not attributed, but it is likely that many of them were created in the early or mid 1980s as part of MIT’s Project Athena, or at its industrial partner, DEC. The misc-fixed fonts are in the public domain.

The individual fonts in the collection have a short name that matches their respective pixel dimensions, plus a letter that indicates a bold or oblique variant. They can also be accessed using their (much longer) X Logical Font Description string:
```
5x7 	-Misc-Fixed-Medium-R-Normal--7-70-75-75-C-50-ISO10646-1
5x8 	-Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO10646-1
[ . . . ]
```
The “6x13” font is usually also available under the alias “fixed”, a font name that is expected to be available on every X server.

The fonts originally covered only the ASCII repertoire, and were in the early 1990s extended to cover all characters in ISO 8859-1. In 1997, Markus Kuhn initiated and headed a project to extend the misc-fixed fonts to as large a subset of Unicode/ISO 10646 as is feasible for each of the available font sizes This project’s goal was to get Linux developers interested in abandoning the 1990s dominant ISO 8859-1 encoding, in favour of using UTF-8 instead, which happened indeed within a few years.

[ . . . ]

The 6x13, 8x13, 9x15, 9x18, and 10x20 fonts cover a much larger repertoire, that covers in addition the comprehensive CEN MES-3A European Unicode 3.2 subset, the International Phonetic Alphabet, Armenian, Georgian, Thai, Yiddish, all Latin, Greek, and Cyrillic characters, all mathematical symbols (including the entire TeX repertoire), APL, Braille, Runes, and much more. 9x15 and 10x20 also cover Ethiopic.

The misc-fixed fonts have been much less commonly used since support for scalable outline font formats such as Type 1, TrueType and OpenType has become available for X. However, they are still commonly used with terminal emulators, such as XTerm, and as a fallback font for the many Unicode characters not yet found in common outline fonts.

The fonts are distributed in the BDF format and are currently maintained by Markus Kuhn.

[ . . . ]

External links
- Simon Tatham’s Fonts Page has, amongst other things, a Windows .FON bitmap font of the “fixed” (i.e. 6x13) font.
- Rasher’s Rockbox related stuff - Fonts - misc has all sizes of fixed-misc available as images and downloads in a .fnt format.
GNU Free Font’s Free Mono - Monospace font which is legible and relatively complete in terms of Unicode coverage.

References - The difference between PPI and DPI

PPI vs. DPI – The Difference Explained Simply

PPI: Pixels per Inch - The Digital World

DPI: Dots per Inch - The Printed World
What is the difference between DPI (dots per inch) and PPI (pixels per inch)?

References - Miscellaneous

Setting up FreeBSD for Lenovo Thinkpad X220 (2011 year)
Cannot change brightness on laptop (FreeBSD 13.1) (Thread Start date: Dec 15, 2022) – FreeBSD Forums
Brightness: lxqt-config-brightness and Gammy – FreeBSD Forums
XTerm introduction and TrueType fonts configuration
Vi-Mode Ubiquitous Cursor Indicator
Change font size in XTerm using keyboard
XLFD (X Logical Font Description) Conventions
Fonts - The Linux Cookbook, Second Edition, by Michael Stutz
How do you know the correct name to use for X11 fonts for XTerm*faceName or xterm -fa NAME?
Fontconfig - A library for configuring and customizing font access
The Unicode HOWTO: Display setup
The Unicode HOWTO, Bruno Haible, haible@clisp.cons.org, v1.0, 23 January 2001

This document describes how to change your Linux system so it uses UTF-8 as text encoding. This is work in progress. Any tips, patches, pointers, URLs are very welcome.
Gallant Font

The 12x22 raster font we love, used by Sun Microsystems SPARC stations. With a ton of Unicode glyphs!

Footnotes

[1] A monospaced font, also called a fixed-pitch, fixed-width, or non-proportional font, is a font whose letters and characters each occupy the same amount of horizontal space. This contrasts with variable-width fonts, where the letters and spacings have different widths.

The font resource is a standard resource setting for the X Toolkit, which deals only with XLFD (X Logical Font Description) Conventions bitmap, while faceName was added long after, in applications such as xterm to provide a way to specify TrueType fonts (actually whatever fontconfig supports, which can include bitmap fonts).

From XLFD (X Logical Font Description) Conventions:

Monospaced = fixed pitch
- A font whose logical character widths are constant (that is, every glyph in the font has the same logical width).
Proportional = variable pitch
- A font whose logical character widths vary for each glyph.
CharCell
- A monospaced font that follows the standard typewriter character cell model (that is, the glyphs of the font can be modeled by X clients as “boxes” of the same width and height that are imaged side-by-side to form text strings or top-to-bottom to form text lines). By definition, all glyphs have the same logical character width, and no glyphs have “ink” outside of the character cell. There is no kerning.

XLFD (bitmap): xlsfonts, xfontsel, xfd
fontconfig (TrueType and it can support bitmap fonts too): fc-list, fc-match
From X Logical Font Description (XLFD) - Arch Wiki:

X Logical Font Description (XLFD) is the original core X11 fonts system. It was designed for bitmap fonts, and support for scalable fonts (Type 1, TrueType, and OpenType/CFF) was added later.
XLFD does not support anti‑aliasing and sub‑pixel rasterization.

From Fonts in X11R6.8, Juliusz Chroboczek, jch@pps.jussieu.fr, 25 March 2004, Section 3. Fonts included with X11R6.8

Fonts included with X11R6.8

3.1. Standard bitmap fonts

The Sample Implementation of X11 (SI) comes with a large number of bitmap fonts, including the `fixed’ family, and bitmap versions of Courier, Times, Helvetica and some members of the Lucida family. In the SI, these fonts are provided in the ISO 8859-1 encoding (ISO Latin Western-European).

In X11R6.8, a number of these fonts are provided in Unicode-encoded font files instead. At build time, these fonts are split into font files encoded according to legacy encodings, a process which allows us to provide the standard fonts in a number of regional encodings with no duplication of work.

For example, the font file
/usr/X11R6/lib/X11/fonts/misc/6x13.bdf
with XLFD
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
is a Unicode-encoded version of the standard `fixed’ font with added support for the Latin, Greek, Cyrillic, Georgian, Armenian, IPA and other scripts plus numerous technical symbols.

[2] About XTerm’s Default Font

Default Font for XTerm

With default (xterm started with just xterm, that is, without using any of the xterm options):

% xterm

In the new xterm window, run:

% xtermcontrol --get-font
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

Confirm/check with xterm(1):

% xterm -report-fonts | wc -l
     218

% xterm -report-fonts | grep -- "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1"
     fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
     fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

As a contrast, next example shows xterm with a font selected from the FreeType library (new-style font), as opposed to a bitmap (old-style) font (which are specified with XLFD notation).

% xterm -fa mono -fs 12

In the new xterm window, run:

% xtermcontrol --get-font
mono

Ask the xprop(1) utility, using its -font argument, to show the properties of the font named fixed.

% xprop -font fixed | grep -w FONT
FONT = -Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1

% xprop -font fixed
---- snip ----
FOUNDRY = Misc
FAMILY_NAME = Fixed
WEIGHT_NAME = Medium
SLANT = R
---- snip ----
PIXEL_SIZE = 13
POINT_SIZE = 120
RESOLUTION_X = 75
RESOLUTION_Y = 75
SPACING = C
AVERAGE_WIDTH = 60
CHARSET_REGISTRY = ISO8859
CHARSET_ENCODING = 1
---- snip ----
FONT = -Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1
---- snip ----

From the man page for xterm(1):

   -fn font
           This option specifies the font to be used for displaying normal
           text.  The corresponding resource name is font.  The resource
           value default is fixed.

Note “The resource value (for the -fn option) default is fixed”.

From:

% xprop -font fixed
---- snip ----
FONT = -Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1

Also:

% xterm -report-fonts | grep "f[A-Z]" | grep -i fixed | wc -l
       8
 
% xterm -report-fonts | grep "f[A-Z]" | wc -l
       8
 
% xterm -report-fonts | grep "f[A-Z]" | grep -i fixed | wc -l
       8
 
% xterm -report-fonts | grep "f[A-Z]" | grep -i fixed
       fNorm: fixed
       fBold: fixed
       fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
       fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
       fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

% xterm -report-fonts | grep "f[A-Z]" | grep -i fixed | grep -- "-13-120-" | wc -l
       6
 
% xterm -report-fonts | grep "f[A-Z]" | grep -i fixed | grep -- "-13-120-" 
       fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
       fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
       fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
       fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

With xterm use its -xrm option specifies a resource string to be used.

Here, use the reportFonts resource.

From the man page for xterm(1):

   reportFonts (class ReportFonts)
           If true, xterm will print to the standard output a summary of
           each font's metrics (size, number of glyphs, etc.), as it loads
           them.  The default is “false”.

% xterm -xrm "*reportFonts: true" | wc -l
     218

% xterm -xrm "*reportFonts: true" | grep "f[A-Z]" | wc -l
       8
 
% xterm -xrm "*reportFonts: true" | grep "f[A-Z]" | grep -i fixed | wc -l
       8
 
% xterm -xrm "*reportFonts: true" | grep "f[A-Z]" | grep -i fixed 
        fNorm: fixed
        fBold: fixed
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
        fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

With xterm, explicitly load font fixed (which is actually an alias for the font that is loaded).

% xterm -xrm "*font:fixed"

Next, with xterm, load font fixed and use the resource string reportFonts to print to the standard output a summary of that font’s metrics (size, number of glyphs, etc.), as xterm loads them.

% xterm -xrm "*reportFonts: true" -xrm "*font:fixed" | wc -l
     218
 
% xterm -xrm "*reportFonts: true" -xrm "*font:fixed" | grep "f[A-Z]" | wc -l
       8
 
% xterm -xrm "*reportFonts: true" -xrm "*font:fixed" | grep "f[A-Z]" | grep -i fixed | wc -l
       8
 
% xterm -xrm "*reportFonts: true" -xrm "*font:fixed" | grep "f[A-Z]" | grep -i fixed 
        fNorm: fixed
        fBold: fixed
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
        fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

With the -report-xres option for xterm:

% xterm -report-xres | wc -l
     261

% xterm -report-xres | grep -E "font[[:space:]]"
font                    : fixed

% xterm -report-xres | grep -E "font[^[:alnum:]]"
font                    : fixed

% xterm -report-xres | grep -E "font[[:>:]]"
font                    : fixed

% xterm -report-xres
---- snip ----
font                    : fixed
font1                   : nil2
font2                   : 5x7
font3                   : 6x10
font4                   : 7x13
font5                   : 9x15
font6                   : 10x20
font7                   : -adobe-courier-medium-r-normal--24-240-75-75-m-150-iso10646-1
fontDoublesize          : true
fontWarnings            : 1
---- snip ----
utf8                    : default
utf8Fonts               : default
utf8Latin1              : false
---- snip ----

Use xset(1) to find the Font Path.

% xset -q | wc -l
      27

% xset -q | grep -A1 "Font Path"
Font Path:
  /usr/local/share/fonts/ . . . 

% ls -lh /usr/local/share/fonts/ | wc -l
      32
 
% ls -lh /usr/local/share/fonts/misc/ | wc -l
     413
 
% ls /usr/local/share/fonts/misc/fonts*
/usr/local/share/fonts/misc/fonts.alias /usr/local/share/fonts/misc/fonts.scale
/usr/local/share/fonts/misc/fonts.dir

% grep ^fixed /usr/local/share/fonts/misc/fonts.alias
fixed        -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1

% grep -- "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1" /usr/local/share/fonts/misc/fonts.dir 
6x13-ISO8859-1.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
6x13-ISO8859-10.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-10
6x13-ISO8859-11.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-11
6x13-ISO8859-13.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-13
6x13-ISO8859-14.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-14
6x13-ISO8859-15.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-15
6x13-ISO8859-16.pcf.gz -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-16

% ls /usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz                      
/usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz

% mkdir /tmp/6x13check
 
% cd /tmp/6x13check
 
% pwd
/tmp/6x13check
 
% cp -i /usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz .
 
% gunzip 6x13-ISO8859-1.pcf.gz
 
% ls
6x13-ISO8859-1.pcf
 
% file 6x13-ISO8859-1.pcf 
6x13-ISO8859-1.pcf: X11 Portable Compiled Font data, bit: MSB, byte: MSB first
 
% wc -l 6x13-ISO8859-1.pcf
      10 6x13-ISO8859-1.pcf
 
% strings 6x13-ISO8859-1.pcf | wc -l
     191

% strings 6x13-ISO8859-1.pcf | grep -i "misc-fixed"
-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1

% xlsfonts | grep -i -- "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1" | wc -l
      15
 
% xlsfonts | grep -i -- "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1"
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-10
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-10
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-11
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-11
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-13
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-13
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-14
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-14
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-15
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-15
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-16
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-16

% xlsfonts -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1" | wc -l
       6
 
% xlsfonts -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1"
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1

% xlsfonts -h
xlsfonts: unrecognized argument -h

usage:  xlsfonts [-options] [-fn pattern]
where options include:
    -l[l[l]]                 give long info about each font
---- snip ----
 
% xlsfonts -l -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1" | wc -l
       7
 
% xlsfonts -ll -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1" | wc -l
     228
 
% xlsfonts -lll -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1" | wc -l
    1770

With xfontsel(1) application, to work with only a subset of the fonts, specify -pattern option followed by a partially or fully qualified font name; so -pattern "*-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1*" will select that subset of fonts which contain that string somewhere in their font name.

% xfontsel -pattern "*-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1*"

This returned “6 names match”.

% xfd -fn "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1"

From the man page for xfd(1):

DESCRIPTION
       The xfd utility creates a window containing the name of the font being
       displayed, a row of command buttons, several lines of text for
       displaying character metrics, and a grid containing one glyph per cell.

In this case, xfd(1) created a window containing this name of the font displayed:

-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1

% xterm -fn "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1" -report-fonts | grep "f[A-Z]"
        fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
        fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fNorm: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
        fBold: -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso8859-1
        fWide: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1
        fWBold: -Misc-Fixed-medium-R-*-*-13-120-75-75-C-120-ISO10646-1

app-defaults

% locate "app-defaults" | grep -i xterm
/usr/local/lib/X11/app-defaults/KOI8RXTerm
/usr/local/lib/X11/app-defaults/KOI8RXTerm-color
/usr/local/lib/X11/app-defaults/UXTerm
/usr/local/lib/X11/app-defaults/UXTerm-color
/usr/local/lib/X11/app-defaults/XTerm
/usr/local/lib/X11/app-defaults/XTerm-color
 
% wc -l /usr/local/lib/X11/app-defaults/XTerm
     272 /usr/local/lib/X11/app-defaults/XTerm

% grep -v \! /usr/local/lib/X11/app-defaults/XTerm | wc -l
     149

% grep "font:" /usr/local/lib/X11/app-defaults/XTerm
*SimpleMenu*menuLabel.font: -adobe-helvetica-bold-r-normal--*-120-*-*-*-*-iso8859-*
*VT100.utf8Fonts.font:  -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
 
% grep "font:" /usr/local/lib/X11/app-defaults/XTerm | grep fixed
*VT100.utf8Fonts.font:  -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

% grep -i font /usr/local/lib/X11/app-defaults/XTerm | grep -i default
*fontMenu*fontdefault*Label:    Default
! The default fixed font and font2-font6 are commonly aliased to iso106461 (Unicode)
!                                         fontdefault/SmeBSB
!                                         fontdefault/SmeBSB
! xterm can switch at runtime between bitmap (default) and TrueType fonts.

appres

% sudo pkg install appres
appres-1.0.7    Program to list application's resources

% pkg info appres
appres-1.0.7
---- snip ----

Description    :
The appres program prints the resources seen by an application
(or subhierarchy of an application) with the specified class and
instance names.  It can be used to determine which resources a 
particular program will load.

% appres XTerm xterm | wc -l
     175

% appres XTerm xterm
---- snip ----

% appres XTerm xterm | grep "font:"
*SimpleMenu*menuLabel.font:     -adobe-helvetica-bold-r-normal--*-120-*-*-*-*-iso8859-*
*VT100.utf8Fonts.font:  -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

% appres XTerm xterm | grep "font:" | grep fixed
*VT100.utf8Fonts.font:  -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1

find-xterm-fonts Perl script

Using find-xterm-fonts Perl script from the maintainer of XTerm, Thomas E. Dickey:

% fetch https://invisible-island.net/datafiles/release/misc-scripts.tar.gz

% tar xf misc-scripts.tar.gz
 
% ls
misc-scripts-20250722   misc-scripts.tar.gz

% cd misc-scripts-20250722/

% ls
CHANGES                         MANIFEST
check-manpage                   nm_cmp
classpath                       no-local
compare-terminfo                nodot
count-nroff                     noenv
diffstat2css                    nolocale
find-xterm-fonts                noterm
---- snip ----

% file find-xterm-fonts
find-xterm-fonts: Perl script text executable

% ./find-xterm-fonts
# opening /usr/local/lib/X11/app-defaults/XTerm
---- snip ----
        *VT100.utf8Fonts.font:  -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
---- snip ----
# opening /usr/local/lib/X11/app-defaults/UXTerm
        *VT100.font:    -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646-1
---- snip ----
# opening /usr/local/lib/X11/app-defaults/KOI8RXTerm
        *VT100.font:    -misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-koi8-r
---- snip ---- 

Font-files used:
---- snip ----
        /usr/local/share/fonts/misc/6x13.pcf.gz
        -> UXTerm*VT100.font
        -> XTerm*VT100.utf8Fonts.font
---- snip ----

No font-files missing

Packages providing font-files:

font-adobe-75dpi-1.0.3_4
        /usr/local/share/fonts/75dpi/courR24.pcf.gz
        /usr/local/share/fonts/75dpi/helvB12-ISO8859-1.pcf.gz
font-misc-misc-1.1.2_4
        /usr/local/share/fonts/misc/10x20-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/10x20-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/10x20.pcf.gz
        /usr/local/share/fonts/misc/5x7-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/5x8-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/5x8.pcf.gz
        /usr/local/share/fonts/misc/6x10-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/6x13-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/6x13-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/6x13.pcf.gz
        /usr/local/share/fonts/misc/7x13-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/7x14-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/7x14.pcf.gz
        /usr/local/share/fonts/misc/8x13-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/8x13-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/8x13.pcf.gz
        /usr/local/share/fonts/misc/9x15-ISO8859-1.pcf.gz
        /usr/local/share/fonts/misc/9x18-KOI8-R.pcf.gz
        /usr/local/share/fonts/misc/9x18.pcf.gz
        /usr/local/share/fonts/misc/nil2.pcf.gz

Appendix

Useful Commands and Examples for Exploring Hardware

% sudo dmidecode | wc -l
     975

% sudo dmidecode | grep "Version: ThinkPad"
      Version: ThinkPad T14s Gen 3

% sudo dmidecode | grep "SKU Number: LENOVO"
      SKU Number: LENOVO_MT_21BR_BU_Think_FM_ThinkPad T14s Gen 3

% sudo dmidecode | sed -n 608,616p
System Information
      Manufacturer: LENOVO
      Product Name: 21BR000NUS
      Version: ThinkPad T14s Gen 3
      Serial Number: [redacted]
      UUID: [redacted]
      Wake-up Type: Power Switch
      SKU Number: LENOVO_MT_21BR_BU_Think_FM_ThinkPad T14s Gen 3
      Family: ThinkPad T14s Gen 3

% sudo dmidecode | grep Intel | grep Version
      Version: 12th Gen Intel(R) Core(TM) i7-1280P

% sudo dmidecode | sed -n 517,521p
Processor Information
      Socket Designation: U3E1
      Type: Central Processor
      Family: Core i7
      Manufacturer: Intel(R) Corporation

% sudo dmidecode | grep i7 | grep Version
        Version: 12th Gen Intel(R) Core(TM) i7-1280P

% sysctl hw.physmem
hw.physmem: 34007212032

% printf %s\\n "34359738368 / 1024 / 1024" | bc
32768
 
% printf %s\\n "34359738368 / 1024 / 1024 / 1024" | bc
32

% dmesg | grep "real memory"
real memory  = 34359738368 (32768 MB)

% pciconf -lv | grep -B3 display
vgapci0@pci0:0:2:0:	class=0x030000 rev=0x0c hdr=0x00 vendor=0x8086 device=0x46a6 subvendor=0x17aa subdevice=0x22ee
    vendor     = 'Intel Corporation'
    device     = 'Alder Lake-P GT2 [Iris Xe Graphics]'
    class      = display
 
% xdpyinfo | grep "number of screens"
number of screens:    1

% xdpyinfo | grep -B2 resolution
screen #0:
  dimensions:    1920x1200 pixels (294x184 millimeters)
  resolution:    166x166 dots per inch

% ls /dev/backlight/
backlight0              intel_backlight0

Useful Tools for Using and Exploring Fonts

X Tools for X Core Fonts - For XLFD (aka: Bitmapped fonts) - xlsfonts, xfontsel, xfd

XLFD: X Logical Font Description (as opposed to Fontconfig and FreeType libraries).

If on your FreeBSD system these three packages (xfontsel, xlsfonts, xfd) were not installed when you installed the X (xorg) metaport and other X (xorg) -related metaports and ports, you’ll need to install them.

To list X (xorg) and X (xorg) -related metaports and ports:

% pkg info | grep ^xorg-
xorg-7.7_3                   X.Org complete distribution metaport
xorg-apps-7.7_4              X.org apps meta-port
xorg-docs-1.7.3,1            X.org documentation files
xorg-drivers-7.7_7           X.org drivers meta-port
xorg-fonts-7.7_1             X.org fonts meta-port
xorg-fonts-100dpi-7.7        X.Org 100dpi bitmap fonts
xorg-fonts-75dpi-7.7         X.Org 75dpi bitmap fonts
xorg-fonts-cyrillic-7.7      X.Org Cyrillic bitmap fonts
xorg-fonts-miscbitmaps-7.7   X.Org miscellaneous bitmap fonts
xorg-fonts-truetype-7.7_1    X.Org TrueType fonts
xorg-fonts-type1-7.7         X.Org Type1 fonts
xorg-libraries-7.7_6         X.org libraries meta-port
xorg-server-21.1.18,1        X.Org X server and related programs

On my system they were not installed so I had to install them.

xlsfonts

% pkg search xlsfonts
xlsfonts-1.0.8    Server font list displayer for X

% sudo pkg install xlsfonts

% xlsfonts -h
xlsfonts: unrecognized argument -h

usage:  xlsfonts [-options] [-fn pattern]
where options include:
 -l[l[l]]             give long info about each font
 -m                   give character min and max bounds
 -C                   force columns
 -1                   force single column
 -u                   keep output unsorted
 -o                   use OpenFont/QueryFont instead of ListFonts
 -w width             maximum width for multiple columns
 -n columns           number of columns if multi column
 -display displayname X server to contact
 -d displayname       (alias for -display displayname)
 -v                   print program version

NOTE: xlsfonts(1) deals only with XLFD 14-part names.

Chapter Fonts of The Linux Cookbook (Second Edition, by Michael Stutz) has a table describing the meaning of each field of X font names in XLFD (X Logical Font Description):

X Fonts - The Linux Cookbook, Second Edition, by Michael Stutz

% xlsfonts | wc -l
   23232

% xlsfonts "*" | wc -l
   23232

When the searched font doesn’t exist on the system:

% xlsfonts "mono"
xlsfonts: pattern "mono" unmatched

When there is a match for the given pattern:

% xlsfonts "*mono*" | wc -l
    6962

% xlsfonts "*mono*" | head
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-ascii-0
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-cns11643-1
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-cns11643-2
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-cns11643-3
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-gb18030.2000-0
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-gb2312.1980-0
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-iso10646-1
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-iso8859-1
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-jisx0201.1976-0
-adobe-noto sans mono cjk jp-bold-r-normal--0-0-0-0-p-0-jisx0208.1983-0

It’s case insensitive:

% xlsfonts -fn "*fixed*" | wc -l
    1014
 
% xlsfonts -fn "*Fixed*" | wc -l
    1014
 
% xlsfonts -fn "*FIXED*" | wc -l
    1014

% xlsfonts | wc -l
   23232

% xlsfonts | grep -i monospaced | wc -l
       0
 
% xlsfonts | grep -i monospace | wc -l
       0

% xlsfonts | grep -i fixed | wc -l
    1014

When searched for the Fixed (typeface) - aka misc-fixed fonts:

% xlsfonts -fn "*fixed*" | grep -i misc | wc -l
     970
 
% xlsfonts -fn "*fixed*" | grep -v misc | wc -l
      44

% xlsfonts -fn "*misc-fixed*" | wc -l
     970

% xlsfonts -fn "*misc-fixed*" | grep -i "\-Misc\-Fixed\-Medium\-R\-Normal\-\-7\-70\-75\-75\-C\-50\-ISO10646\-1"
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
 
% xlsfonts -fn "*misc-fixed*" | grep -n -i "\-Misc\-Fixed\-Medium\-R\-Normal\-\-7\-70\-75\-75\-C\-50\-ISO10646\-1"
758:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
759:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

Or:

% xlsfonts -fn "*misc-fixed*" | grep -i -- "-Misc-Fixed-Medium-R-Normal--7-70-75-75-C-50-ISO10646-1"
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

% xlsfonts -fn "*misc-fixed*" | grep -n -i -- "-Misc-Fixed-Medium-R-Normal--7-70-75-75-C-50-ISO10646-1"
758:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
759:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

% xlsfonts -fn "*-Misc-Fixed-Medium-R-Normal--7-70-75-75-C-50-ISO10646-1*"
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

You don’t have to use the -fn option:

% xlsfonts "*-Misc-Fixed-Medium-R-Normal--7-70-75-75-C-50-ISO10646-1*"
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

% xlsfonts "*misc-fixed*" | grep -n -i "\-Misc\-Fixed\-Medium\-R\-Normal\-\-7\-70\-75\-75\-C\-50\-ISO10646\-1"
758:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1
759:-misc-fixed-medium-r-normal--7-70-75-75-c-50-iso10646-1

xfontsel

% pkg search --regex ^xfontsel
xfontsel-1.1.1    Point and click selection of X11 font names

$ pkg search --regex --full ^xfontsel | sed -n '/Description/,$p'
Description    :
This package contains xfontsel, an application which provides a simple way to
display fonts known to your X server.

% sudo pkg install xfontsel

% xfontsel -help
usage:  xfontsel [-options ...] -fn font

where options include:
    -display dpy           X server to contact
    -geometry geom         size and location of window
    -pattern fontspec      font name pattern to match against
    -print                 print selected font name on exit
    -sample string         sample text to use for 1-byte fonts
    -sample16 string       sample text to use for 2-byte fonts
    -sampleUCS string      sample text to use for ISO10646 fonts
    -scaled                use scaled instances of fonts
plus any standard toolkit options

NOTE: xfontsel(1) deals only with XLFD 14-part names.

To work with only a subset of the fonts, specify -pattern option followed by a partially or fully qualified font name; e.g., -pattern "*medium*" will select that subset of fonts which contain the string medium somewhere in their font name.

When the searched font doesn’t exist on the system:

$ xfontsel -fn nonexistingfont
Warning: Cannot convert string "nonexistingfont" to type FontStruct

$ xfontsel -fn mono
Warning: Cannot convert string "mono" to type FontStruct

% xfontsel -pattern 'mono' -print

#  The  xfontsel(1)  window displayed:
#    no names match

% xfontsel -pattern '*mono*' -print
        
#  On my system, the  xfontsel(1)  window displayed:
#    12 names match

#  After quitting xfontsel(1):
-*-b612 mono-*-*-*-*-*-*-*-*-*-*-*-*$ 

xfd

% sudo pkg install xfd

% pkg info xfd
---- snip ----
Comment        : Display all characters in an X font
---- snip ----
Description    :
This package contains xfd, an applications used for displying all
characters in an X font.

NOTE: In addition to -fn option (which specifies the core X server side font to be displayed), the xfd(1) utility also supports -fa option (which specifies an Xft font to be displayed).

% xfd -fa gallant

#   xfd(1) loaded Noto Sans-12:style=Regular
#   WHY?
#   This is why:

% fc-match
NotoSans-Regular.ttf: "Noto Sans" "Regular"

% fc-match gallant
NotoSans-Regular.ttf: "Noto Sans" "Regular"

% xfd -fn fixed

Loaded:

-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1

% xfontsel -print -fn "-Misc-Fixed-Medium-R-SemiCondensed--13-120-75-75-C-60-ISO8859-1"

Output:

-*-*-*-*-*-*-*-*-*-*-*-*-*-*%

% xfontsel -print -fn fixed

Output:

-*-*-*-*-*-*-*-*-*-*-*-*-*-*%

Fontconfig Tools (fc-list, fc-match, fc-conflist) - For OpenType, TrueType Fonts

Print a list of all the configuration files processed by Fontconfig.

% fc-conflist

The output is a ‘-‘ or ‘+’ depending on whether the file is ignored or processed, a space, the file’s path, a colon and space, and the description from the file or ‘No description’ if none is present.

The order of files looks like how fontconfig actually processes them except one containing <include> element.

% fc-list | wc -l
    1895

% sudo pkg install xscreensaver

% fc-list | wc -l
    1900

% fc-list | grep -i gallant
/usr/local/share/fonts/xscreensaver/gallant12x22.ttf: gallant12x22:style=Medium

% xfd -fa gallant12x22

#   xfd(1) loaded the correct font, that is:
#     gallant12x22-12:style=Medium

% xfd -fn gallant12x22
Warning: Cannot convert string "gallant12x22" to type FontStruct
xfd:  no font to display

% fc-list | wc -l
    1895

% fc-list :scalable=true:spacing=mono:family | wc -l
     175

% fc-list :scalable=true:spacing=mono:family | less
---- snip ----

% fc-list :scalable=true:spacing=mono:family | grep mono | wc -l
      60

% fc-list :scalable=true:spacing=mono:family | grep mono | less
---- snip ----

% fc-match | wc -l
       1

% fc-match
NotoSans-Regular.ttf: "Noto Sans" "Regular"

% fc-match SomeFont
NotoSans-Regular.ttf: "Noto Sans" "Regular"
 
% fc-match "Some Font"
NotoSans-Regular.ttf: "Noto Sans" "Regular"

% fc-match 0xProto
0xProto-Regular.otf: "0xProto" "Regular"
 
% fc-match 0xPROTO
0xProto-Regular.otf: "0xProto" "Regular"

% fc-match '*0xProto*'
NotoSans-Regular.ttf: "Noto Sans" "Regular"
 
% fc-match "*0xProto*"
NotoSans-Regular.ttf: "Noto Sans" "Regular"

% fc-list | grep 0xProto
/home/dusko/.fonts/0xProto-Regular.otf: 0xProto:style=Regular
/home/dusko/.fonts/0xProto-Regular.ttf: 0xProto:style=Regular

% find ~/.fonts -iname '*0xProto*'
/home/dusko/.fonts/0xProto-Regular.otf
/home/dusko/.fonts/0xProto-Regular.ttf

% fc-list | grep -i 0xProto
/home/dusko/.fonts/0xProto-Regular.otf: 0xProto:style=Regular
/home/dusko/.fonts/0xProto-Regular.ttf: 0xProto:style=Regular

% fc-list -v 0xProto | grep -i file
        file: "/home/dusko/.fonts/0xProto-Regular.ttf"(s)
        file: "/home/dusko/.fonts/0xProto-Regular.otf"(s)

To get detailed information about a font; for example, about 0xProto font:

% fc-list -v 0xProto | wc -l
      88
 
% fc-list -v 0xProto | grep postscriptname
        postscriptname: "0xProto-Regular"(s)
        postscriptname: "0xProto-Regular"(s)

% fc-match
NotoSans-Regular.ttf: "Noto Sans" "Regular"
 
% fc-list | grep "NotoSans-Regular.ttf"
/usr/local/share/fonts/noto/NotoSans-Regular.ttf: Noto Sans:style=Regular

% find /usr/local/share/fonts -iname '*Noto*' | wc -l
     366

% find /usr/local/share/fonts -iname '*Noto*' 
/usr/local/share/fonts/noto
/usr/local/share/fonts/noto/NotoSerifDisplay-BlackItalic.ttf
/usr/local/share/fonts/noto/NotoSerifCJKsc-ExtraLight.otf
---- snip ----
/usr/local/share/fonts/noto/NotoSans-BoldItalic.ttf
/usr/local/share/fonts/noto/NotoSans-SemiCondensedExtraLightItalic.ttf
/usr/local/share/fonts/noto/NotoSans-BlackItalic.ttf

Additional Fontconfig Tools

% man fonts-conf

Useful X Tools - Generic, General

To display the start of the cut buffer: xprop -root -len 100 CUT_BUFFER0

Glossary / Acronyms / Terms [TODO]

(Often used interchangeably) X.Org Server - X - X11 - Xorg: X.Org Foundation implementation of the X Window System (X11) display server
- So, X.Org Server (X): implementation of the X Window System (X11) display server
  - X Window System = X11
  - X11 = protocol, the core protocol
  - X.Org Server = X

References:

X Window System - Wikipedia:

X Window System (X11, or simply X) is a windowing system for bitmap displays, common on Unix-like operating systems.
Windowing system - Wikipedia:

The X Window System was first released in 1984 and is historically the main windowing system for Unix and Unix-like operating systems. The core protocol has been at version 11 since 1987, hence it commonly being known as “X11”. The current reference implementation of the X11 protocol is the X.Org Server, which provides the display server and some ancillary components.

[ . . . ]

The main component of any windowing system is usually called the display server, although alternative terms such as window server are also in use.
Xorg - Arch Wiki

X.Org Server - commonly referred to as simply X - is the X.Org Foundation implementation of the X Window System (X11) display server, and it is the most popular display server among Linux users.

For the alternative and successor, see Wayland.
XLFD = X Logical Font Description
Type 1, TrueType, OpenType/CFF = scalable fonts

FAQ

How do misc-fixed fonts look like?

Answer: On my FreeBSD 14 system:

% xfontsel -print

For fndry select misc. For fmly select fixed. Click ‘quit’.

Output:

-misc-fixed-*-*-*-*-*-*-*-*-*-*-*-*%

% xlsfonts | wc -l
   23234

% xlsfonts "*-misc-fixed*" | wc -l
     970

On my system, there are 970 fonts in the misc-fixed collection of fonts.

Now, you can dig deeper, and start filtering out, until you find a font or a set of fonts that you like.

% xlsfonts "*-misc-fixed*" | less

% xlsfonts "*-misc-fixed-medium-r-normal*" | wc -l
     454

% xlsfonts "*-misc-fixed-medium-r-normal*" | less

% xlsfonts "*-misc-fixed-medium-r-normal--20*" | wc -l
      34
 
% xlsfonts "*-misc-fixed-medium-r-normal--20*" | less

% xfontsel -pattern "-misc-fixed-medium-r-normal--20-200-75-75-c-100-iso10646-1" 

Returned “6 names match”.

Then with xfd(1):

% xfd -fn "-misc-fixed-medium-r-normal--20-200-75-75-c-100-iso10646-1"

Similarly:

% xfd -fn "*-misc-fixed-medium-r-normal--20-*"

will display:

-Misc-Fixed-Medium-R-Normal--20-200-75-75-C-100-ISO8859-1

and

% xfd -fn "-misc-fixed-medium-r-normal--*-*-*-*-*-*-iso10646-1"

will display:

-Misc-Fixed-Medium-R-Normal--20-200-75-75-C-100-ISO10646-1

% xterm -fn "-Misc-Fixed-Medium-R-Normal--20-200-75-75-C-100-ISO10646-1"

To display the point size of the fixed font being used:

% xprop -font fixed POINT_SIZE
POINT_SIZE = 120

DevOps for the Desparate with FreeBSD [WIP]

Wed, 09 Apr 2025 03:13:06 +0000

Stop bhyve from loading
On FreeBSD 14.x: Package vagrant not working - Install Vagrant from source
vagrant mutate bhyve not working - use vagrant with VirtualBox
[Solved] Virtualbox-ose-6.1.5 fails to start any type of guest VM in 14.1 release

added vboxdrv_load="YES" line to /boot/loader.conf

Did you also load the module or rebooted the system? It’s not dynamic, the modules in /boot/loader.conf are only loaded when the system boots.

the issue was vmm loading up as well due to the vm_dir line being in /etc/rc.conf

Right. sysutils/vm-bhyve automatically loads it if it’s enabled. Unfortunately the two virtualization layers don’t play nice with each other.

Dusko Pijetlovic

Replicate FVWM3's 9 Desks in Wayland GNOME on RHEL 10.2

Fix 9 Static Workspaces

Set Keyboard Shortcuts to Switch Directly to Each Desk

Move a Window to a Specific Workspace (Optional)

FvwmPager Equivalent - Visual Pager

Install GNOME Shell Extension: “Workspace Indicator”

Remaining Things Worth Configuring

Export Dash to Panel’s Settings

FreeBSD 15 ZFS, RHEL 10, Windows 11 Triple Boot [UEFI GPT]

References

How to Scroll in VT (Virtual Terminal) on FreeBSD and Linux

FreeBSD: Scrollback in VT - Scroll Lock Key

If Keyboard doesn’t have Scroll Lock Key

Alternative - Remap Keys (Key Remapping)

Linux: Software Scrollback was Removed in version 5.9 of the Kernel

Alternatives - Use a Terminal Multiplexer or less(1) or KMSCon

References

X11 DPI Scaling Guide

X11 DPI, Xft, X Server DPI, and Scaling

TL;DR

What DPI should I use on this laptop?

What DPI should I use on an external monitor?

1. Check or Compute Physical DPI (from EDID)

2. Check X Server DPI (rarely meaningful)

3. Check Logical DPI (Read X Resources)

Set Logical DPI (Recommended Workflow)

3a. To set logical DPI temporary - during the current X session

3b. To set logical DPI permanently

3c. To set X server DPI (requires restart) - rarely meaningful

4. Recommended Flexible Workflow

5. Understanding DPI Differences

6. Toolkit and Application Notes (Short)

Xterm

GTK

Qt5/Qt6 (e.g. KeePassXC, ReText, etc.)

7. Recommended X11 Workflow (Non‑DE)

Best overall workflow for FVWM3 + FreeBSD

8. High-Level Rules

9. Q&A

10. Terminology: PPI vs DPI vs Pixel Pitch

11. Examples

11a. Compute Physical DPI

(11b) X Server DPI

(11c) Logical DPI

12. Toolkit Analyzers - xdpi and qtdpi

Resources and References

Footnotes

X11 DPI Reference

X11 DPI & Font Scaling: Essential Reference

TL;DR

1. Core Terms

2. What Each Command Shows

3. Commands

4. DPI Formulas

5. Examples

6. Changing DPI

Change logical DPI (affects fonts/UI in modern apps)

Change X server DPI (rare, requires restart)

7. Q&A

8. Additional Answers for FreeBSD + FVWM3 Environment

Compiling and Building X11 Program on FreeBSD

Xlib (aka libX11) - X Window System Protocol Client Library

How to Build xdpi

Step 1 - Get the source code

Step 2 - Check prerequisites

Step 3 - Build (preferred and alternatives)

Step 4 - Install

Step 5 - Run

Step 6. Short summary

How to Build qtdpi

Resources

Footnotes

HOWTO Change Themes and Colours in GTK Applications

References

ASCII/Unicode Control Characters (^L in Terminal)

What is ^L in Output on Terminal?

hexdump Format Strings

Caret Notation

Footnotes