CSS Unicode-Range and Font Fallback: Fixing Missing Glyphs in Web Fonts
UnicodeCSSWeb FontsTypographyFrontend DevelopmentPerformance

CSS Unicode-Range and Font Fallback: Fixing Missing Glyphs in Web Fonts

UUnicode Live Editorial Team
2026-11-16
8 min read

Use CSS unicode-range, font subsets, and fallback checks to fix missing glyphs and load the right web font for each script.

CSS unicode-range lets you assign different web-font files to different parts of the Unicode space. This reusable checklist explains how to build script-aware font stacks, diagnose missing glyphs and unexpected fallback, and verify that subsetting has not removed characters your interface needs.

Overview

A web font does not necessarily contain every character in a typeface. To improve loading performance, teams commonly publish subsets: one file for Latin, another for Cyrillic, another for Arabic, and so on. CSS @font-face rules can describe the characters covered by each file with unicode-range.

When the browser encounters text, it considers the declared font faces, their Unicode ranges, the requested style and weight, and the actual glyphs available in each downloaded file. If a face cannot render a character, the browser can continue through the fallback list. A missing-glyph box, often called a tofu box, usually means that no usable font in the effective stack contains the required glyph.

The key distinction is that unicode-range describes an intended coverage range; it does not create glyphs or repair an incomplete font file. A subset generator can omit a character even when the CSS range appears to include it. Conversely, a broad range can cause a browser to select a file that does not contain every character in that range, leaving fallback to do the remaining work.

For related debugging, see the guides to Unicode code points and UTF-8/UTF-16 and Unicode escapes in HTML, CSS, JavaScript, and JSON. Those distinctions matter when you inspect a character copied from application data and need to identify what the browser is actually rendering.

Basic pattern

@font-face {
  font-family: "Example Sans";
  src: url("/fonts/example-sans-latin.woff2") format("woff2");
  font-weight: 400 700;
  font-style: normal;
  font-display: swap;
  unicode-range: U+0000-00FF, U+0131, U+0152-0153;
}

:root {
  --ui-font: "Example Sans", system-ui, sans-serif;
}

body {
  font-family: var(--ui-font);
}

Use one family name across the subsets. The ranges tell the browser when a particular file is eligible; the fallback stack supplies alternatives for characters that remain unsupported.

Reference table: common CSS Unicode ranges

These are practical starting points, not complete language definitions. Unicode blocks often contain punctuation, symbols, combining marks, or characters used by more than one script. Choose ranges according to the text your product actually displays, and confirm coverage in the font files.

Use caseExample unicode-rangeNotes
Latin and common punctuationU+0000-00FF, U+0100-024F, U+1E00-1EFF, U+2000-206F, U+20ACUseful for many Western and Central European interfaces, but language coverage varies.
CyrillicU+0400-04FF, U+0500-052F, U+2DE0-2DFF, U+A640-A69FConsider extended Cyrillic characters when supporting more than basic Russian or Ukrainian text.
GreekU+0370-03FF, U+1F00-1FFFThe second range includes Greek extended characters and is relevant to accented text.
ArabicU+0600-06FF, U+0750-077F, U+08A0-08FFArabic shaping and right-to-left layout require more than selecting a range; test joining, marks, and direction.
HebrewU+0590-05FF, U+FB1D-FB4FTest niqqud and bidirectional text if your interface displays vocalized content.
CJK and related punctuationU+2E80-2EFF, U+3000-303F, U+3040-30FF, U+3400-4DBF, U+4E00-9FFF, U+F900-FAFFThis can be a large subset. Separate Japanese, Simplified Chinese, or Traditional Chinese coverage where the chosen font provides language-specific forms.
General symbols and technical marksU+2000-206F, U+2070-209F, U+2100-214F, U+2190-21FF, U+2200-22FFUseful for punctuation, arrows, mathematical operators, and letterlike symbols, but inspect actual glyph design.
Emoji and pictographsU+1F300-1FAFFEmoji are often better handled by a platform color-emoji fallback. Sequences can use multiple code points and variation selectors.

Do not assume that one range equals one writing system. Combining marks may be stored in a different block from their base letters, and emoji sequences may contain variation selectors or zero-width joiners. The guide to emoji sequences and variation selectors is useful when an emoji looks incomplete even though the main pictograph is covered.

Checklist by scenario

When adding a new script or locale

  1. List representative content, not just the alphabet. Include uppercase and lowercase letters, accents, punctuation, currency signs, numerals, combining marks, and real product strings.
  2. Identify the characters and code points in that content. A Unicode-aware text inspector or a small script can reveal characters that are easy to miss when reviewing visually.
  3. Generate a subset from the representative content or an explicit character set. Avoid relying on a language label alone when the product includes names, user-generated text, or mixed-script data.
  4. Declare a matching unicode-range and keep the family, style, and weight descriptors consistent across subset files.
  5. Test normal text, headings, labels, form controls, placeholders, generated content, and error messages. Font failures often appear in content that is not included in the primary visual review.

When characters show in the wrong font

  1. Inspect the character in DevTools and check the rendered-font or font-related panel. This helps distinguish the intended web font from a system fallback.
  2. Compare the requested font-family, font-weight, font-style, and font-stretch with the descriptors in every relevant @font-face rule.
  3. Check whether the character falls inside the declared range. If it does not, fallback is expected; if it does, inspect the actual font file for the glyph.
  4. Review the computed fallback order. A symbol font placed before the text font can produce unexpected shapes, while an emoji-capable fallback may be desirable for pictographs.

When using a variable font

Keep the Unicode ranges separate from weight and style decisions. A variable font may declare a weight interval such as font-weight: 300 700, but it still needs the glyph coverage required by each range. If multiple variable-font files are used for different scripts, make their family and axis descriptors compatible, then test intermediate weights and italic or oblique styles. A subset that contains only the regular upright instance will not automatically provide a matching italic or bold design.

When a font subset was regenerated

Compare the new file with the previous file before deployment. Confirm that the subsetter preserved required glyphs, kerning or shaping data, variation axes, and the formats your delivery pipeline serves. Clear or version font URLs so an old CSS file cannot point to a new file with different coverage, and use a network panel to verify that the expected file is requested.

What to double-check

  • Ranges and files agree. Inspect the font's cmap coverage with a font inspection utility or a controlled test page. CSS cannot add a missing glyph.
  • Combining marks are included. Accented text may use precomposed characters in one string and a base character plus combining mark in another. Test both forms where relevant; normalization can affect what you see in data.
  • Fallback order is intentional. Put the primary family first, then appropriate script or symbol fallbacks, then a generic family such as sans-serif or serif.
  • Right-to-left behavior is tested separately. Font selection does not replace correct direction, isolation, shaping, or layout rules. Consult the bidirectional text debugging guide for mixed RTL and LTR content.
  • Generated content is included. Icons, quotation marks, bullets, badges, and CSS content values can use code points absent from the subset created from page text.
  • Font loading is observable. Check failed requests, MIME and response issues, caching, cross-origin configuration where applicable, and whether the browser is applying the intended face after loading.
  • Format delivery is deliberate. WOFF2 is a common web delivery choice, but verify the formats and feature support required by your browser support policy rather than copying an old template unchanged.

Common mistakes

Using a huge range as a guarantee

U+0000-10FFFF says that a face is eligible for the whole Unicode space; it does not mean the file contains every character. Broad declarations can also make debugging harder. Prefer ranges that reflect the subset and let fallback handle content outside it.

Splitting by script without accounting for shared characters

Latin punctuation, currency signs, combining marks, and symbols may be shared by several locales. Decide which subset owns common characters, or include them where needed. A missing quote mark can make an otherwise correct script appear to have a font problem.

Assuming a font-family name forces one file

Several @font-face rules can use the same family name. Selection also considers descriptors and Unicode coverage. If a rule has the wrong weight or style, the browser may synthesize styling or use a different face than expected.

Treating emoji as ordinary text glyphs

Emoji can consist of sequences, presentation selectors, skin-tone modifiers, or joined components. A monochrome web font may cover individual code points but still not produce the expected emoji presentation. Test complete sequences and provide a sensible emoji fallback.

Testing only one browser or one operating system

Fallback fonts and shaping engines differ across platforms. Test at least one environment with the intended web font and one environment where system fallback is likely. Include slow-loading and failed-font scenarios so the interface remains readable during loading.

When to revisit

Keep this checklist with your typography and localization workflow. Revisit it whenever you add a language, redesign headings or controls, change a font family, introduce a variable font, regenerate subsets, alter browser support targets, or begin a new seasonal content cycle with different names and symbols.

A practical review can be short:

  1. Refresh the representative character set with current product content.
  2. Regenerate or inspect subsets and compare their code-point coverage.
  3. Check every @font-face range against its file and descriptors.
  4. Run a page containing Latin, Cyrillic, Greek, Arabic, Hebrew, CJK, symbols, combining marks, and emoji where relevant.
  5. Inspect rendered fonts and network requests in DevTools, then test a failed-font fallback path.
  6. Record any intentional exceptions, such as platform emoji fallback or a locale-specific CJK font.

When a character is missing, start with the character itself: identify its code point or sequence, verify the selected face, inspect the file's cmap coverage, and only then change the CSS range. That order prevents a declaration change from masking a subset-generation or fallback-order problem.

Related Topics

#Unicode#CSS#Web Fonts#Typography#Frontend Development#Performance
U

Unicode Live Editorial Team

Technical Editor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.