# CSS @font-face and Font Loading: Web Font Syntax and Best Practices

Source: https://devdocs10.com/articles/css/css-font-face  
By Murat Bo · Published 2026-08-30 · DevDocs10 (https://devdocs10.com)

CSS `@font-face` lets you use custom fonts on a web page by defining where a font file lives and what family name CSS should use for it. Understanding font loading helps you avoid invisible text, broken fallbacks, and slow page rendering.

> **Quick answer:** Use `@font-face` to register a font family, point `src` to one or more font files, and then apply that family with `font-family`. Add `font-display` to control how text behaves while the font loads.

> **Difficulty:** Beginner
>
> **You'll understand this better if you know:** basic CSS selectors, the `font-family` property, and how browsers load external resources.

## 1. What Is CSS @font-face and Font Loading?

`@font-face` is a CSS at-rule that defines a downloadable font and gives it a name you can use in your styles. Font loading is the process the browser follows to fetch that font file, decide when to use it, and switch text to the custom font if it becomes available.

- It connects a font file to a CSS family name.
- It lets you use fonts that are not installed on the user’s device.
- It supports multiple font formats and fallback behavior.
- It works with browser loading strategies such as `font-display`.

In practice, `@font-face` is what makes branded typography, icon fonts, and custom readable text possible on the web.

## 2. Why CSS @font-face and Font Loading Matter

Fonts affect both design and performance. A well-configured web font can make a site more readable and consistent, but a poorly configured one can cause slow loading, layout shifts, or invisible text.

Good font loading matters because:

- Users expect text to appear quickly, even on slow connections.
- Fallback fonts must be readable if the custom font fails or loads late.
- Large font files can increase page weight and delay rendering.
- Proper loading behavior reduces jarring changes when fonts swap in.

You should use `@font-face` when you need a font that is not reliably installed on user devices, and you should avoid it when the default system font stack already meets your design and performance goals.

## 3. Basic Syntax

The simplest `@font-face` rule defines a family name, points to a font file, and optionally declares the font’s weight or style. Once defined, you can use the family name anywhere else in your CSS.

### Minimal example

This example registers one font file and uses it in the page body.

```css
@font-face {
  font-family: "Aster";
  src: url("/fonts/aster.woff2") format("woff2");
  font-display: swap;
}

body {
  font-family: "Aster", Arial, sans-serif;
}
```

`font-family` gives the font a CSS name, `src` points to the file, and `font-display: swap` tells the browser to show fallback text first and replace it when the font is ready.

## 4. Step-by-Step Examples

### Example 1: Loading a regular text font

Use this pattern for body text or headings when you have a single font file for one weight and style.

```css
@font-face {
  font-family: "Merriweather Custom";
  src: url("/fonts/merriweather-regular.woff2") format("woff2");
  font-weight: 400;
  font-style: normal;
  font-display: swap;
}

h1, p {
  font-family: "Merriweather Custom", Georgia, serif;
}
```

This tells the browser that the font file represents normal weight 400. If later you request bold text, the browser may synthesize or fall back unless you define a bold face too.

### Example 2: Providing multiple font files for different weights

Real typography often needs more than one file. Here, the same family name is reused for two different weights.

```css
@font-face {
  font-family: "Source Sans Pro Custom";
  src: url("/fonts/source-sans-400.woff2") format("woff2");
  font-weight: 400;
}

@font-face {
  font-family: "Source Sans Pro Custom";
  src: url("/fonts/source-sans-700.woff2") format("woff2");
  font-weight: 700;
}

strong {
  font-family: "Source Sans Pro Custom", Arial, sans-serif;
  font-weight: 700;
}
```

Because each font file is matched with its weight, the browser can render bold text with the correct glyphs instead of faking bold.

### Example 3: Using local fonts when available

You can ask the browser to use an installed font first, then fall back to a downloaded file if needed.

```css
@font-face {
  font-family: "Inter UI";
  src: local("Inter"),
       url("/fonts/inter.woff2") format("woff2");
  font-display: optional;
}
```

This can reduce network requests, but only use it when you trust the local font name and want that exact installed version.

### Example 4: Defining a variable font

Variable fonts can cover a range of weights or styles with a single file. That can simplify your CSS and reduce the number of requests.

```css
@font-face {
  font-family: "Flex Sans";
  src: url("/fonts/flex-sans-variable.woff2") format("woff2");
  font-weight: 100 900;
  font-style: normal;
}

h2 {
  font-family: "Flex Sans", sans-serif;
  font-weight: 650;
}
```

The browser interpolates the exact weight you request as long as it falls within the declared range.

## 5. Practical Use Cases

`@font-face` is useful whenever a site needs typography that users cannot be expected to have installed already.

- Brand websites that need a custom headline font.
- Documentation sites that need consistent body text across platforms.
- Landing pages where typography is part of the visual identity.
- Content-rich applications that need a readable fallback strategy while fonts load.
- Multilingual sites that need separate font files for different writing systems.

It is also useful for font subsets, where you serve only the characters needed for a particular language or page.

## 6. Common Mistakes

### Mistake 1: Declaring a font file but using the wrong family name

The name inside `@font-face` is the name you must use later in `font-family`. If those names do not match exactly, the browser will fall back to another font.

**Problem:** This CSS defines one family name but tries to use a different one on the page, so the custom font never applies.

```css
@font-face {
  font-family: "Nova Text";
  src: url("/fonts/nova-text.woff2") format("woff2");
}

p {
  font-family: "NovaText", serif;
}
```

**Fix:** Use the exact registered family name when you apply the font.

```css
@font-face {
  font-family: "Nova Text";
  src: url("/fonts/nova-text.woff2") format("woff2");
}

p {
  font-family: "Nova Text", serif;
}
```

The corrected version works because the browser can match the declared face to the requested family name.

### Mistake 2: Forgetting weight and style matching

If you only define one face and request a different weight or italic style, the browser may simulate the result or choose a fallback face. That often looks inconsistent.

**Problem:** The CSS asks for bold italic text, but the font face only declares a normal 400 style, so the browser cannot match the request precisely.

```css
@font-face {
  font-family: "Atlas";
  src: url("/fonts/atlas-regular.woff2") format("woff2");
  font-weight: 400;
}

em {
  font-family: "Atlas", sans-serif;
  font-weight: 700;
  font-style: italic;
}
```

**Fix:** Declare additional faces for each weight and style you plan to use.

```css
@font-face {
  font-family: "Atlas";
  src: url("/fonts/atlas-regular.woff2") format("woff2");
  font-weight: 400;
  font-style: normal;
}

@font-face {
  font-family: "Atlas";
  src: url("/fonts/atlas-bold-italic.woff2") format("woff2");
  font-weight: 700;
  font-style: italic;
}
```

The browser can now match both the normal and bold italic versions correctly.

### Mistake 3: Serving unsupported or inefficient font formats first

Browsers prefer modern formats such as `woff2`. If you rely on older formats only, or put them before the modern file, you can increase load time or fail to get the best compression.

**Problem:** The rule points only to an older file, which may be larger and less efficient than a modern `woff2` file.

```css
@font-face {
  font-family: "Metro";
  src: url("/fonts/metro.ttf");
}
```

**Fix:** Prefer `woff2` first and add a fallback format only when you need broader support.

```css
@font-face {
  font-family: "Metro";
  src: url("/fonts/metro.woff2") format("woff2"),
       url("/fonts/metro.woff") format("woff");
}
```

The corrected version gives the browser a smaller, more efficient file first.

## 7. Best Practices

### Practice 1: Always define a reliable fallback stack

Custom fonts can fail to load because of network issues, blocked requests, or unsupported formats. A fallback stack keeps the page readable.

```css
body {
  font-family: "Aster", system-ui, sans-serif;
}
```

This matters because text should remain usable even if the custom font never appears.

### Practice 2: Use `woff2` whenever possible

`woff2` is widely supported and usually smaller than older formats, which means faster downloads and better performance.

```css
@font-face {
  font-family: "Content Sans";
  src: url("/fonts/content-sans.woff2") format("woff2");
}
```

Use older formats only when you truly need compatibility with older browsers.

### Practice 3: Match weight and style explicitly

Declaring `font-weight` and `font-style` in the face helps the browser choose the right file instead of simulating styles.

```css
@font-face {
  font-family: "Nova";
  src: url("/fonts/nova-italic.woff2") format("woff2");
  font-weight: 400;
  font-style: italic;
}
```

This reduces visual inconsistencies and makes typography behave predictably.

## 8. Limitations and Edge Cases

- Font files are network resources, so they can be delayed by slow connections or blocked by server settings.
- Different browsers may use different font loading timing, which can change when text swaps in.
- Fonts referenced from another origin can fail if the server does not allow cross-origin access.
- Some font names exist locally on a device but refer to different versions, which can make `local()` unpredictable.
- Using too many weights and styles increases file count and page weight.
- Variable fonts reduce file count, but not every browser or workflow handles them equally well.

**Warning:** A font request that fails because of cross-origin restrictions or a missing file is not just a design issue; it can also slow rendering or trigger an unexpected fallback font.

## 9. Practical Mini Project

Here is a small but complete example of a page that loads one custom font for headings and uses a sensible fallback stack for body text.

```css
@font-face {
  font-family: "Civic Headline";
  src: url("/fonts/civic-headline.woff2") format("woff2");
  font-weight: 700;
  font-style: normal;
  font-display: swap;
}

body {
  font-family: system-ui, sans-serif;
  line-height: 1.6;
  margin: 0;
  padding: 2rem;
}

h1, h2 {
  font-family: "Civic Headline", Georgia, serif;
  font-weight: 700;
}

p {
  max-width: 65ch;
}
```

This example keeps the page readable before the custom font arrives, then applies the heading font once it is loaded.

## 10. Key Points

- `@font-face` registers a downloadable font and gives it a CSS family name.
- `src` can point to font files, local fonts, or multiple sources in priority order.
- `font-display` controls how text behaves while the font is loading.
- Matching `font-weight` and `font-style` helps the browser select the right face.
- Good fallback fonts are essential for readable, resilient pages.
- `woff2` is usually the best default font format for modern web use.

## 11. Practice Exercise

- Create an `@font-face` rule for a font named `"Article Sans"`.
- Load a regular weight font file and a bold font file.
- Apply the family to headings and body text with fallbacks.
- Add `font-display` so text remains visible while fonts load.

**Expected output:** A page where headings use the custom font, bold text appears with the correct weight, and the page stays readable if the font is slow or missing.

**Hint:** Define one face per weight, then reuse the same family name in your element styles.

```css
@font-face {
  font-family: "Article Sans";
  src: url("/fonts/article-sans-regular.woff2") format("woff2");
  font-weight: 400;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: "Article Sans";
  src: url("/fonts/article-sans-bold.woff2") format("woff2");
  font-weight: 700;
  font-style: normal;
  font-display: swap;
}

body {
  font-family: "Article Sans", system-ui, sans-serif;
}

h1, h2 {
  font-family: "Article Sans", Georgia, serif;
  font-weight: 700;
}
```

The solution works because the browser has a complete set of faces to match normal and bold text while keeping readable fallbacks in place.

## 12. Final Summary

CSS `@font-face` is the standard way to load custom fonts on the web. It lets you map font files to a family name, define weights and styles, and control how the browser behaves during loading.

The most important habits are simple: use accurate family names, provide fallback stacks, prefer `woff2`, and declare weight and style information for each face you actually use. Those choices make your typography more reliable and your pages faster.

If you want to go further, the next topics to learn are font subsetting, variable fonts, and performance-focused `font-display` strategies.

## Browser Support

| Feature | Status | Chrome | Edge | Firefox | Safari | Safari iOS |
| --- | --- | --- | --- | --- | --- | --- |
| @font-face | Widely available since Mar 2019 | 36+ | 14+ | 39+ | 10+ | 10+ |

Data: web-features 3.43.0 (MDN Baseline).