Creating a Unique Look - How to Add Custom Fonts to Next JS

Table of Contents

1. Introduction
2. Understanding Next JS and Custom Fonts
3. Preparing to Add Custom Fonts to Next JS
4. Steps to Add Custom Fonts to Next JS
   • 1. Adding the font files to the public directory
   • 2. Creating or updating the CSS file
   • 3. Importing the CSS file into the _app.js file
   • 4. Applying the custom font to elements through CSS rules
5. Troubleshooting Common Issues
6. Best Practices for Using Custom Fonts in Next JS
7. Conclusion

Introduction

In today's digital age, websites are more than just information repositories; they are brand ambassadors. A website’s aesthetic and usability play a crucial role in its success, and custom fonts are a significant part of this equation. Fonts can define the character of a website, enhance readability, and make your brand instantly recognizable. Next JS, a powerful JavaScript framework for building fast and scalable web applications, makes it easier to integrate custom fonts, allowing you to give your site a unique look that stands out.

This blog will take you through everything you need to know about adding custom fonts to your Next JS project. From understanding what Next JS and custom fonts are to troubleshooting common issues, this guide covers all the bases. So, whether you're a beginner or an experienced developer, by the end of this post, you’ll be well-equipped to add custom fonts to your Next JS projects.

Understanding Next JS and Custom Fonts

Next JS is a React-based framework that simplifies the process of building server-side rendered and static websites. Unlike traditional front-end frameworks, Next JS offers features like server-side rendering (SSR), static site generation (SSG), and API routes right out of the box. These features are essential for creating fast, SEO-friendly websites that deliver content efficiently to users.

Custom fonts are fonts that are not included in the standard list of web-safe fonts. They are typically used to give a website a unique look and feel. Custom fonts can be downloaded from sources like Google Fonts, Adobe Fonts, or Font Squirrel, and they can significantly enhance the user experience by improving readability and reinforcing brand identity.

Incorporating custom fonts in a Next JS project involves several steps, from choosing the right font to ensuring it loads correctly across all devices and browsers. The process might seem complex at first, but it’s quite manageable once you understand the basics of how Next JS handles styles and assets.

Preparing to Add Custom Fonts to Next JS

Before you start adding custom fonts to your Next JS project, there are a few prerequisites you need to check:

1. Node.js and npm: Make sure that Node.js and npm (Node Package Manager) are installed on your system. These tools are essential for creating and managing Next JS projects. You can download them from the official Node.js website.

2. Setting up a Next JS project: If you don’t already have a Next JS project, you’ll need to create one. This can be done quickly by running the following command in your terminal:

   npx create-next-app@latest my-<a href="/blog/building-a-high-performance-ecommerce-store-with-nextjs">nextjs</a>-app
   

   Replace my-nextjs-app with your desired project name. Once the project is created, navigate into the project directory using:

   cd my-nextjs-app
   

3. Choosing and downloading custom fonts: The next step is to choose the custom fonts you want to use. Fonts can be downloaded from various online sources like Google Fonts, Adobe Fonts, or Font Squirrel. Make sure to download the font files in WOFF, WOFF2, or TTF formats, as these are the most widely supported in web browsers.

Steps to Add Custom Fonts to Next JS

Adding custom fonts to Next JS involves several steps. Each step plays a crucial role in ensuring that the fonts are correctly loaded and applied to your web application. Let’s break down these steps in detail.

1. Adding the Font Files to the Public Directory

First, you need to place your font files in a location where they can be accessed by your Next JS application. The recommended approach is to use the public directory within your project.

1. Create a folder named fonts inside the public directory:

   mkdir public/fonts
   

2. Move your downloaded font files into this folder. For example, if you downloaded a font called MyCustomFont.woff2, you should place it in public/fonts/MyCustomFont.woff2.

By placing the fonts in the public directory, they become accessible at the URL /fonts/MyCustomFont.woff2. This URL will be used later when defining the font in your CSS.

2. Creating or Updating the CSS File

Next, you need to define the custom font in a CSS file. This file can either be a new CSS file specifically for fonts or an existing global CSS file.

1. If you don’t already have a global CSS file, create one in the styles directory:

   touch styles/globals.css
   

2. Open the globals.css file and use the @font-face rule to define your custom font:

   @font-face {
     font-family: "MyCustomFont";
     src: url("/fonts/MyCustomFont.woff2") format("woff2"), url("/fonts/MyCustomFont.woff")
         format("woff");
     font-weight: normal;
     font-style: normal;
   }
   

   Replace MyCustomFont with the actual name of your font and ensure the src URLs match the paths where your font files are located.

3. Importing the CSS File into the _app.js File

To ensure that your custom font is applied across your entire Next JS application, you need to import the CSS file into your _app.js file.

1. Open the _app.js file located in the pages directory:

   import "../styles/globals.css";
   
   function MyApp({ Component, pageProps }) {
     return <Component {...pageProps} />;
   }
   
   export default MyApp;
   

2. Add the import statement for your global CSS file at the top of the _app.js file:

   import "../styles/globals.css";
   

This ensures that the custom fonts are loaded for every page in your application.

4. Applying the Custom Font to Elements through CSS Rules

Finally, you can apply the custom font to different elements on your website using CSS.

1. In your globals.css or any other relevant CSS file, you can set the custom font as the default font for your website:

   body {
     font-family: "MyCustomFont", sans-serif;
   }
   

   This will apply MyCustomFont to all text on your website. You can also apply the font to specific elements or classes as needed.

By following these steps, you have successfully added a custom font to your Next JS project. The process involves moving font files, defining them in CSS, and ensuring they are applied globally across your application.

Troubleshooting Common Issues

Adding custom fonts to Next JS is usually straightforward, but sometimes things don’t go as planned. Here are some common issues you might encounter and how to resolve them.

1. Fonts not displaying correctly: If your fonts are not showing up as expected, double-check the @font-face declarations in your CSS. Make sure the src paths are correct and the font files are in the right format (WOFF, WOFF2, TTF).

2. CORS issues: If your fonts are being blocked due to Cross-Origin Resource Sharing (CORS) issues, you may need to adjust your server configuration to allow font files to be served with the correct headers. Alternatively, ensure that the fonts are served from the same domain as your Next JS application to avoid CORS problems.

3. Performance issues: Loading large font files can slow down your website. Optimize your fonts by using the WOFF2 format, which is compressed and designed for faster loading. Also, consider using font-display: swap in your @font-face rule to improve perceived load times by displaying fallback fonts until the custom font is fully loaded.

Best Practices for Using Custom Fonts in Next JS

Using custom fonts effectively in Next JS requires more than just adding them to your project. Here are some best practices to ensure your fonts look great and perform well:

1. Optimize font loading: Always use the WOFF2 format where possible, as it provides the best compression and performance. Additionally, use font-display: swap; to ensure text remains visible while the custom font loads.

2. Use fallback fonts: Always specify fallback fonts in your CSS. This ensures that if the custom font fails to load, your website will still display text using a similar system font, maintaining usability.

3. Ensure accessibility: Choose fonts that are legible and accessible to all users. Avoid overly decorative fonts for body text, and always test your website to ensure that the custom fonts do not impair readability or accessibility.

4. Manage font weight and styles: Load only the font weights and styles you need to minimize file sizes and improve load times. For example, if you only need regular and bold text, don’t load extra weights like light or extra bold.

Conclusion

Custom fonts are a powerful tool for creating a unique and memorable web experience. By following the steps outlined in this blog, you can easily add custom fonts to your Next JS projects, enhancing both the aesthetic appeal and the user experience of your website. Remember to keep best practices in mind, such as optimizing font loading and ensuring accessibility, to create the best possible user experience.

Experiment with different fonts to find the perfect match for your brand, and take advantage of Next JS’s powerful features to deliver fast, beautiful, and accessible web applications.

Interested in learning more? Contact us today.