A guide to elementary OS font rendering and hinting

Text on elementary OS can look crisp on one display and soft or uneven on another. The cause is rarely a single faulty setting. Font selection, screen resolution, scaling, antialiasing and hinting all shape the final pixels, and each layer responds differently to the hardware and applications you use.

Understanding that pipeline makes troubleshooting much easier. An application asks the desktop for a particular font and weight. The text system then matches that request, arranges the characters and passes the glyph outlines to the rasteriser, which converts them into the shapes visible on screen.

Hinting adjusts those outlines to align with the display’s pixel grid. It can make small text sharper, although aggressive hinting may distort letterforms. Antialiasing then smooths the edges, while display scaling determines how much of the interface fits on the screen.

The best settings are therefore practical rather than universal. They should suit your monitor, viewing environment, eyesight and typical applications. Australian working habits also matter, from the prevalence of standard-definition office monitors to the need to handle fonts used in locally produced documents.

How elementary OS turns fonts into readable text

When an elementary OS application draws a label, it normally asks GTK and Pango for a family, style, size and weight. Fontconfig matches that request against the fonts installed on the system. It also handles aliases and fallback rules, allowing an unavailable commercial font to be replaced with a compatible one.

Pango performs the text layout and shaping work, including complex script handling. Cairo and FreeType then convert the resulting outlines into pixels. This division matters because changing a font file does not alter the rasterisation method, while changing a rendering option does not change the characters stored inside the font.

A request for a bold weight might also involve a separate bold file, a variable font or a synthesised weight. Synthetic bold can look uneven because the renderer thickens an ordinary face rather than using a designed bold master. Inspecting the actual matched font is therefore more reliable than assuming the application followed its request exactly.

Font rendering affects the whole desktop, but the results vary by application. A browser may use one backend, an Electron application another, and a terminal emulator often provides its own font controls. The underlying font may be identical while the edges of its letters still look different.

Choosing a family that suits Australian reading

Many elementary OS installations include Noto Sans, DejaVu Sans, Liberation Sans and other open-source families. The available defaults can differ between releases and installed packages, so it is worth checking rather than relying on a screenshot from an earlier version. Noto Sans is a broad, legible option for interfaces, while DejaVu Sans provides another familiar sans-serif appearance.

Australian offices frequently exchange documents containing Arial, Times New Roman, Calibri or Cambria. Metric-compatible substitutes such as Liberation Sans, Liberation Serif, Carlito and Caladea can preserve line breaks and page layouts, although their letter shapes remain different. Fontconfig commonly handles these substitutions when the named fonts are absent. This is particularly useful for A4 documents produced by schools, councils and small businesses.

Font licensing is another local consideration. Australian organisations may have licensed fonts installed only on particular workstations, while home users often have a more limited collection. Copying a commercial font between machines without the appropriate licence can create legal problems. Open alternatives avoid this issue and make it easier to reproduce a document’s appearance on another elementary OS system.

Lighting also changes which weights look comfortable. A window-facing desk in Perth or Darwin can place a screen in strong daylight, while evening use in Melbourne or Sydney may favour a face with slightly heavier strokes. Australian English conventions, including “colour”, “favourite” and “licence”, should also be checked in the font’s glyph set. Community discussion tends to use an encouraging “have a go” attitude, but a practical font test is the quickest way to determine whether a setting is sorted.

Hinting and antialiasing controls

Hinting tells the rasteriser how outlines should meet the pixel grid. With hintnone, outlines remain mathematically smooth and the font is scaled without grid-fitting. hintslight applies minimal correction and generally provides a useful compromise. hintmedium and hintfull alter stems and horizontal features more strongly, which can improve very small text but may make larger lettering look heavier or uneven.

Antialiasing calculates intermediate shades along a glyph’s edge. Grayscale antialiasing uses pixels with equal red, green and blue values. Subpixel antialiasing varies those values across neighbouring pixels, often producing sharper vertical stems at standard scaling. This technique can show coloured fringes on some displays and may look inconsistent when the interface is transparent or scaled fractionally.

Fontconfig exposes these controls through properties such as hinting, hintstyle, antialias, rgba and lcdfilter. Some versions of elementary OS provide access to a useful subset in the settings interface, while other combinations require a local Fontconfig file. A user file in ~/.config/fontconfig/fonts.conf is preferable to changing the system-wide configuration because it can be removed or replaced without affecting other users.

A reasonable starting point is light hinting with antialiasing enabled on a standard 96 DPI monitor. Subpixel rendering can then be compared with grayscale rendering at the same size. On a high-density display, grayscale antialiasing and minimal hinting often preserve smooth outlines, while hintfull is worth trying only when small interface labels consistently appear indistinct.

Matching text to DPI and display scaling

A 24-inch 1920-by-1080 monitor remains common in the Australian consumer and office market. At that size, a typical resolution produces close to 96 effective DPI, so fonts designed for desktop interfaces remain around their intended pixel dimensions. A 13-inch laptop at 2560-by-1600 offers far more pixels per inch, changing the balance between hinting and smooth outlines.

Display scaling changes the relationship between interface units and physical pixels. Integer scaling produces clean results because each logical pixel maps neatly to the display grid. Fractional scaling can provide more flexibility, but some applications may render through pathways that produce softer text. This is particularly noticeable when a GTK application, browser and terminal are shown side by side.

The scale control should be chosen in the system display settings rather than through an arbitrary monitor override. X11 and Wayland handle scaling differently, and changing one session’s settings does not necessarily repair another. Browser zoom and an editor’s interface zoom can improve individual applications without making the entire desktop larger, which is often the more practical solution when only one program feels cramped.

Font size remains separate from screen scale. Increasing the system text size can make menus and controls easier to read while preserving the amount of information visible. For prolonged reading, a 12-point body size may be more comfortable than 11 points, but applications with dense tables may need a smaller adjustment. Test the actual text rather than selecting a value solely from its number.

A controlled test for a dependable final setting

Begin with a baseline. Open the document, browser page or application you use most, keep its zoom at 100 per cent, and read several paragraphs containing familiar words. A second sample with small interface labels is useful because large prose can look acceptable while navigation text remains faint. Take a screenshot so the result can be compared after each change.

Fontconfig can reveal what the desktop has actually selected. The command fc-match "sans-serif" shows the current match for the generic sans-serif family, while fc-match "Arial" reveals whether Arial or a substitute has been chosen. fc-list lists installed fonts and their locations, and the Font Viewer application provides a convenient visual comparison when it is available.

Before changing Fontconfig, back up any existing user file. A minimal local configuration can begin with the following values, after which fc-cache -f rebuilds the cache:

<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
<fontconfig>
  <match target="font">
    <edit name="hinting" mode="assign">
      <bool>true</bool>
    </edit>
    <edit name="hintstyle" mode="assign">
      <const>hintslight</const>
    </edit>
    <edit name="antialias" mode="assign">
      <bool>true</bool>
    </edit>
  </match>
</fontconfig>

Test one variable at a time, restarting affected applications or logging out after a Fontconfig change. If the result worsens, restore the previous file and rebuild the cache. Keep the setting that makes the most-used text easiest to read across your browser, editor and terminal, since consistency across those applications matters more than an isolated perfect sample. Open your most-used document, set its zoom to 100 per cent, and read one full page before making another change.