Fast Refresh is a Next.js feature that gives you instantaneous feedback on edits made to your React components. Fast Refresh is enabled by default in all Next.js applications on 9.4 or newer. With Next.js Fast Refresh enabled, most edits should be visible within a second, without losing component state.
theme.jswill update both components.
If you make a syntax error during development, you can fix it and save the file again. The error will disappear automatically, so you won't need to reload the app. You will not lose component state.
If you make a mistake that leads to a runtime error inside your component, you'll be greeted with a contextual overlay. Fixing the error will automatically dismiss the overlay, without reloading the app.
Component state will be retained if the error did not occur during rendering. If the error did occur during rendering, React will remount your application using the updated code.
If you have error boundaries in your app (which is a good idea for graceful failures in production), they will retry rendering on the next edit after a rendering error. This means having an error boundary can prevent you from always getting reset to the root app state. However, keep in mind that error boundaries shouldn't be too granular. They are used by React in production, and should always be designed intentionally.
Fast Refresh tries to preserve local React state in the component you're editing, but only if it's safe to do so. Here's a few reasons why you might see local state being reset on every edit to a file:
higherOrderComponent(WrappedComponent). If the returned component is a class, state will be reset.
As more of your codebase moves to function components and Hooks, you can expect state to be preserved in more cases.
// @refresh resetanywhere in the file you're editing. This directive is local to the file, and instructs Fast Refresh to remount components defined in that file on every edit.
debugger;into the components you edit during development.
When possible, Fast Refresh attempts to preserve the state of your component
between edits. In particular,
useRef preserve their previous
values as long as you don't change their arguments or the order of the Hook
Hooks with dependencies—such as
always update during Fast Refresh. Their list of dependencies will be ignored
while Fast Refresh is happening.
For example, when you edit
useMemo(() => x * 2, [x]) to
useMemo(() => x * 10, [x]), it will re-run even though
x (the dependency)
has not changed. If React didn't do that, your edit wouldn't reflect on the
Sometimes, this can lead to unexpected results. For example, even a
with an empty array of dependencies would still re-run once during Fast Refresh.
However, writing code resilient to occasional re-running of
useEffect is a good practice even
without Fast Refresh. It will make it easier for you to introduce new dependencies to it later on
and it's enforced by React Strict Mode,
which we highly recommend enabling.