next-themes

What is next-themes?

The next-themes package is a utility for managing themes in Next.js applications. It provides a simple and efficient way to implement dark mode, light mode, and custom themes with minimal configuration.

What are next-themes's main functionalities?

Theme Provider

The ThemeProvider component wraps your application and provides the context for theme management. The `attribute` prop specifies how the theme is applied, such as using a class or data attribute.

```jsx
import { ThemeProvider } from 'next-themes';

function MyApp({ Component, pageProps }) {
  return (
    <ThemeProvider attribute="class">
      <Component {...pageProps} />
    </ThemeProvider>
  );
}

export default MyApp;
```

Use Theme Hook

The `useTheme` hook allows you to access and manipulate the current theme. You can use it to create theme switchers or to apply theme-specific logic in your components.

```jsx
import { useTheme } from 'next-themes';

function ThemeSwitcher() {
  const { theme, setTheme } = useTheme();

  return (
    <div>
      <button onClick={() => setTheme('light')}>Light Mode</button>
      <button onClick={() => setTheme('dark')}>Dark Mode</button>
      <button onClick={() => setTheme('system')}>System Default</button>
    </div>
  );
}
```

Custom Themes

You can define custom themes and pass them to the ThemeProvider. This allows you to have more control over the appearance of your application and to create unique themes beyond just light and dark modes.

```jsx
import { ThemeProvider } from 'next-themes';

const customThemes = {
  light: {
    background: '#ffffff',
    color: '#000000'
  },
  dark: {
    background: '#000000',
    color: '#ffffff'
  }
};

function MyApp({ Component, pageProps }) {
  return (
    <ThemeProvider themes={customThemes} attribute="class">
      <Component {...pageProps} />
    </ThemeProvider>
  );
}

export default MyApp;
```

Other packages similar to next-themes

styled-components

Styled-components is a library for React and React Native that allows you to use component-level styles in your application. It supports theming through its ThemeProvider, but it is more focused on styling components rather than managing global themes.

emotion

Emotion is a library designed for writing CSS styles with JavaScript. It provides powerful and flexible theming capabilities through its ThemeProvider and useTheme hook, similar to next-themes, but it is also more focused on styling components.

tailwindcss

Tailwind CSS is a utility-first CSS framework that can be used to create custom themes. While it does not provide a built-in theme management system like next-themes, it allows you to define custom themes using configuration files and utility classes.

README

next-themes

An abstraction for themes in your Next.js app.

• ✅ Perfect dark mode in 2 lines of code
• ✅ System setting with prefers-color-scheme
• ✅ No flash on load (both SSR and SSG)
• ✅ Sync theme across tabs and windows
• ✅ Disable flashing when changing themes
• ✅ Force pages to specific themes
• ✅ Class or data attribute selector
• ✅ useTheme hook

Check out the Live Example to try it for yourself.

Install

$ npm install next-themes
# or
$ yarn add next-themes

Use

You'll need a Custom App to use next-themes. The simplest _app looks like this:

// pages/_app.js

function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />
}

export default MyApp

Adding dark mode support takes 2 lines of code:

import { ThemeProvider } from 'next-themes'

function MyApp({ Component, pageProps }) {
  return (
    <ThemeProvider>
      <Component {...pageProps} />
    </ThemeProvider>
  )
}

export default MyApp

That's it, your Next.js app fully supports dark mode, including System preference with prefers-color-scheme. The theme is also immediately synced between tabs. By default, next-themes modifies the data-theme attribute on the html element, which you can easily use to style your app:

:root {
  /* Your default theme */
  --background: white;
  --foreground: black;
}

[data-theme='dark'] {
  --background: black;
  --foreground: white;
}

useTheme

Your UI will need to know the current theme and be able to change it. The useTheme hook provides theme information:

const ThemeChanger = () => {
  const { theme, setTheme } = useTheme()

  return (
    <div>
      The current theme is: {theme}
      <button onClick={() => setTheme('light')}>Light Mode</button>
      <button onClick={() => setTheme('dark')}>Dark Mode</button>
    </div>
  )
}

API

Let's dig into the details.

ThemeProvider

All your theme configuration is passed to ThemeProvider.

• storageKey = 'theme': Key used to store theme setting in localStorage
• defaultTheme = 'light': Default theme name
• forcedTheme: Forced theme name for the current page (does not modify saved theme settings)
• enableSystem = true: Whether to switch between dark and light based on prefers-color-scheme
• disableTransitionOnChange = false: Optionally disable all CSS transitions when switching themes (example)
• themes = ['light', 'dark']: List of theme names
• attribute = 'data-theme': HTML attribute modified based on the active theme
  • accepts class and data-* (meaning any data attribute, data-mode, data-color, etc.) (example)
• value: Optional mapping of theme name to attribute value
  • value is an object where key is the theme name and value is the attribute value (example)

useTheme

useTheme takes no parameters, but returns:

• theme: Active theme name
• setTheme(name): Function to update the theme
• forcedTheme: Forced page theme or falsy. If forcedTheme is set, you should disable any theme switching UI
• resolvedTheme: If enableSystem is true and the active theme is "system", this returns whether the system preference resolved to "dark" or "light". Otherwise, identical to theme
• systemTheme: If enableSystem is true, represents the System theme preference ("dark" or "light"), regardless what the active theme is
• themes: The list of themes passed to ThemeProvider (with "system" appended, if enableSystem is true)

Not too bad, right? Let's see how to use these properties with examples:

Examples

The Live Example shows next-themes in action, with dark, light, system themes and pages with forced themes.

Use System preference by default

The defaultTheme is "light". If you want to respect the System preference instead, set it to "system":

<ThemeProvider defaultTheme="system">

Ignore System preference

If you don't want a System theme, disable it via enableSystem:

<ThemeProvider enableSystem={false}>

Class instead of data attribute

If your Next.js app uses a class to style the page based on the theme, change the attribute prop to class:

<ThemeProvider attribute="class">

Now, setting the theme to "dark" will set class="dark" on the html element.

Force page to a theme

Let's say your cool new marketing page is dark mode only. The page should always use the dark theme, and changing the theme should have no effect. To force a theme on your Next.js pages, simply set a variable on the page component:

// pages/awesome-page.js

const Page = () => { ... }
Page.theme = 'dark'
export default Page

In your _app, read the variable and pass it to ThemeProvider:

function MyApp({ Component, pageProps }) {
  return (
    <ThemeProvider forcedTheme={Component.theme || null}>
      <Component {...pageProps} />
    </ThemeProvider>
  )
}

Done! Your page is always dark theme (regardless of user preference), and calling setTheme from useTheme is now a no-op. However, you should make sure to disable any of your UI that would normally change the theme:

const { forcedTheme } = useTheme()

// Theme is forced, we shouldn't allow user to change the theme
const disabled = !!forcedTheme

Disable transitions on theme change

I wrote about this technique here. We can forcefully disable all CSS transitions before the theme is changed, and re-enable them immediately afterwards. This ensures your UI with different transition durations won't feel inconsistent when changing the theme.

To enable this behavior, pass the disableTransitionOnChange prop:

<ThemeProvider disableTransitionOnChange>

Differing DOM attribute and theme name

The name of the active theme is used as both the localStorage value and the value of the DOM attribute. If the theme name is "pink", localStorage will contain theme=pink and the DOM will be data-theme="pink". You cannot modify the localStorage value, but you can modify the DOM value.

If we want the DOM to instead render data-theme="my-pink-theme" when the theme is "pink", pass the value prop:

<ThemeProvider value={{ pink: 'my-pink-theme' }}>

Done! To be extra clear, this affects only the DOM. Here's how all the values will look:

const { theme } = useTheme()
// => "pink"

localStorage.get('theme')
// => "pink"

document.documentElement.getAttribute('data-theme')
// => "my-pink-theme"

More than light and dark mode

next-themes is designed to support any number of themes! Simply pass a list of themes:

<ThemeProvider themes={['pink', 'red', 'blue']}>

Note! When you pass themes, the default set of themes ("light" and "dark") are overridden. Make sure you include those if you still want your light and dark themes:

<ThemeProvider themes={['pink', 'red', 'blue', 'light', 'dark']}>

Without CSS variables

This library does not rely on your theme styling using CSS variables. You can hard-code the values in your CSS, and everything will work as expected (without any flashing):

html,
body {
  color: #000;
  background: #fff;
}

[data-theme='dark'],
[data-theme='dark'] body {
  color: #fff;
  background: #000;
}

Discussion

The Flash

ThemeProvider automatically injects a script into next/head to update the html element with the correct attributes before the rest of your page loads. This means the page will not flash under any circumstances, including forced themes, system theme, multiple themes, and incognito. No noflash.js required.

FAQ

---

Why is my page still flashing?

In Next.js dev mode, the page may still flash. When you build your app in production mode, there will be no flashing.

---

Do I need to use CSS variables with this library?

Nope. See the example.

---

Can I set the class or data attribute on the body or another element?

Nope. If you have a good reason for supporting this feature, please open an issue.

---

Can I use this package with Gatsby or CRA?

Nope.

---

Is the injected script minified?

Yes, using Terser.

---

Why is resolvedTheme necessary?

When supporting the System theme preference, you want to make sure that's reflected in your UI. This means your buttons, selects, dropdowns, or whatever you use to indicate the current theme should say "System" when the System theme preference is active.

If we didn't distinguish between theme and resolvedTheme, the UI would show "Dark" or "Light", when it should really be "System".

resolvedTheme is then useful for modifying behavior or styles at runtime:

const { resolvedTheme } = useTheme()

<div style={{ color: resolvedTheme === 'dark' ? white : black }}>

If we didn't have resolvedTheme and only used theme, you'd lose information about the state of your UI (you would only know the theme is "system", and not what it resolved to).