← Back to blog

Oct 27, 2026 · 8 min read

Next.js 16: Cache Components, Turbopack by Default, and What Actually Changed

Next.js 16 shipped with Turbopack as the default bundler, a new Cache Components model, and several breaking changes. Here's what matters and what to do about it.

Next.jsReactWeb Development

Next.js 16 arrived in late 2025, and it's a bigger release than the version number suggests. The bundler changed, the caching model changed, and several APIs were removed. If you're on Next.js 15, here's what you need to know before upgrading.

Turbopack is now the default

This is the biggest change. Starting with Next.js 16, Turbopack is the default bundler for both next dev and next build. You no longer need the --turbopack flag.

Turbopack is an incremental bundler written in Rust. In practice, this means:

  • 5-10x faster Fast Refresh during development. Changes show up almost instantly.
  • 2-5x faster production builds. For larger apps, this cuts CI time noticeably.
  • Persistent caching (beta). Build results are cached to disk between runs, so incremental builds are faster.

If your project has a custom webpack configuration, next build will now fail by default to prevent misconfiguration. You have three options: migrate your webpack config to Turbopack-compatible options, run next build --turbopack to ignore the webpack config, or use next build --webpack to opt out and keep using webpack.

For most projects, the migration is straightforward. The main gotcha is custom webpack loaders, which need Turbopack equivalents. If you have a complex webpack setup, test the build before committing to the upgrade.

Cache Components: a new caching model

The caching story in Next.js has been a source of confusion since the App Router shipped. Next.js 16 introduces Cache Components, a new model built on Partial Pre-Rendering (PPR) and the "use cache" directive.

The key change: caching is now opt-in, not opt-out. In the App Router's original model, caching was implicit and you had to opt out with no-store or revalidate. In Cache Components, all dynamic code runs at request time by default, and you explicitly mark what should be cached with "use cache".

// This runs on every request
export default async function Page() {
  const data = await fetch('/api/data');
  return <div>{data}</div>;
}

// This is cached
"use cache"
export async function getCachedData() {
  const data = await fetch('/api/slow-data');
  return data;
}

The compiler automatically generates cache keys wherever "use cache" is used. You can cache pages, components, and functions. The API also includes updateTag() and a refined revalidateTag() for cache invalidation.

If you're using the experimental PPR from Next.js 15 canaries, you need to migrate. The experimental.ppr flag and the experimental_ppr segment config are gone. Use cacheComponents: true in your next config instead.

React Compiler is stable

The React Compiler, which automatically memoizes components and eliminates most manual useMemo and useCallback, is now stable in Next.js 16. You can enable it with:

const nextConfig = {
  reactCompiler: true,
};

In practice, this means you can write components without worrying about memoization and get the same render performance. The compiler figures out what's reactive and what's not. For existing codebases with lots of manual memoization, this is a simplification, not just a performance improvement.

Proxy replaces middleware

Middleware is now proxy.ts. The name change reflects a clarification: this layer is for network-level concerns (routing, redirects, headers), not application logic. If you have existing middleware that does auth checks or data fetching, the recommendation is to move that logic into server components or server actions.

The API is similar, but the mental model is different. Think of proxy.ts as something that runs at the edge before your application code, not as a place to put business logic.

Breaking changes worth knowing

Async params. Route params and searchParams are now always Promises. You must await them:

// Before (Next.js 15)
export default function Page({ params }) {
  return <div>{params.slug}</div>;
}

// After (Next.js 16)
export default async function Page({ params }) {
  const { slug } = await params;
  return <div>{slug}</div>;
}

next/image defaults changed. The default quality and formats have been updated. Test your images after upgrading.

AMP support removed. The built-in AMP components and codemods are gone. If you were using AMP (which most projects weren't), you'll need a custom solution.

Minimum TypeScript version is 5.1.0. If you're on an older TypeScript, upgrade first.

Should you upgrade?

If you're on Next.js 15, yes, but test carefully. The Turbopack switch and the async params change are the two most likely to cause issues. Run your test suite, check your build, and pay attention to image rendering.

If you're on Next.js 14 or earlier, upgrade to 15 first, fix any issues, then go to 16. Skipping versions makes the migration harder.

The Cache Components model is the most significant long-term change. It's a cleaner mental model than the App Router's original caching, and it aligns better with how developers actually think about caching. But it's a migration, not a drop-in change. Plan for it separately from the version upgrade.

The bottom line

Next.js 16 is a release where the framework grew up in a few specific ways. Turbopack being default means the tooling is finally fast enough to not think about. Cache Components means the caching model is finally explicit. The React Compiler means manual memoization is finally optional.

None of these are revolutionary on their own, but together they remove a lot of the friction that made Next.js feel heavy. If you've been waiting for a release to upgrade to, this is a good one.

Need help applying this?

Schedule call →