Turbopack has always made a very deliberate trade: cache aggressively in memory so that recompiles scale with the size of your change, not the size of your app. The cost of that trade has been visible in every Activity Monitor screenshot from a long dev session — multi-gigabyte next dev processes sitting next to an IDE, a typechecker, a linter, and increasingly a coding agent, all fighting for the same RAM.
With Next.js 16.3, announced June 29, 2026, the Turbopack team spends the release paying that cost down. The headline numbers: dev server memory usage down as much as 90% on large apps, production builds up to 5.5× faster with a persisted cache, and an experimental Rust port of the React Compiler that removes one of the last Babel-shaped bottlenecks in the pipeline.
Here's what changed, and what's worth turning on.
Memory eviction: the cache no longer hoards every route
The biggest single improvement is architectural. Since Next.js 16.1, Turbopack has been able to persist its cache to the filesystem for next dev. In 16.3, that persistence layer unlocks something new: because cached results are safe on disk, Turbopack can now evict them from memory.
That sounds mundane, but it fixes the failure mode every developer on a large Next.js app knows. In previous versions, the in-memory cache held onto every route you visited during a dev session. Browse 50 routes over a workday and the dev server's memory grew monotonically — nothing was ever released. With eviction, memory usage stays bounded to what you're actively working on, and cold results are cheap to restore from disk.
Vercel's published measurements after compiling 50 routes: the vercel.com dashboard dev server dropped from 21.5 GB to about 2 GB (~90% smaller), and nextjs.org dropped from 4,600 MB to 840 MB (~82% smaller). The team is careful to note there's no universal percentage — results depend on route graph size, how much of it you touch, and how long the session runs. But directionally, long-running sessions on big apps are exactly where the win lands.
Both memory eviction and the dev filesystem cache are on by default in 16.3 — you upgrade and get it. If you're debugging cache behavior and need to rule it out, the escape hatch is:
// next.config.ts
const nextConfig = {
experimental: {
turbopackMemoryEviction: false, // default is 'full'
},
};
The rest of the reduction came from unglamorous work — compressing internal data structures and dropping data as soon as it's no longer needed — which is usually a good sign for how the numbers hold up outside benchmarks.
The persistent cache comes to next build
The same filesystem cache that has been speeding up dev sessions since 16.1 is now available for production builds. After months of hardening on Vercel's own sites, next build can read previously computed compilation results from disk and only compile what changed.
The published benchmarks span a useful range: nextjs.org builds ~2.3× faster with a warm cache (21s → 9.2s), vercel.com's home route ~1.4× faster (66s → 46s), and vercel.com/geist ~5.5× faster (30s → 5.5s). The spread is the interesting part — the more of your build is unchanged content (docs, marketing pages, a design system), the closer you get to the 5.5× end.
Unlike the dev-mode cache, this one is opt-in:
// next.config.ts
const nextConfig = {
experimental: {
turbopackFileSystemCacheForBuild: true,
},
};
The practical unlock is CI. Persist the generated .next directory between runs — most CI providers have a cache step for exactly this — and Turbopack picks the entries up at the start of the next build. For teams shipping many small PRs a day, this compounds: every merge stops paying the cold-compile tax on the 95% of the app that didn't change.
A Rust React Compiler, no Babel required
Next.js has shipped stable React Compiler support since 16.0, but until now enabling it meant running a Babel transform — and on large apps, that JS-bound step could measurably slow builds. The React team recently published a native Rust port of the compiler, and 16.3 integrates it into Turbopack as an experimental option.
Early tests against large apps like v0 showed compilation wins of 20–50%. Enabling it is two flags:
// next.config.ts
const nextConfig = {
reactCompiler: true, // enable the React Compiler (stable)
experimental: {
turbopackRustReactCompiler: true, // use the Rust port instead of Babel
},
};
If you'd been holding off on the React Compiler because of build-time cost, this is the moment to re-run that evaluation. The reactCompiler docs cover opt-in configuration if you want to roll it out per-directory rather than app-wide.
import.meta.glob lands in Turbopack
A quality-of-life addition with real architectural uses: Turbopack now supports the Vite-compatible import.meta.glob API.
const posts = import.meta.glob('./posts/*.mdx');
for (const path in posts) {
const post = await posts[path]();
}
Each match is lazy by default (an async function that loads the module); pass eager: true to import everything up front. Named imports, multiple and negative patterns, query strings for loaders, and generated TypeScript types are all supported.
Two things make this more than a convenience. First, it's wired into Turbopack's file watcher — add or remove a matching file and dev mode recompiles, so content-driven pages (blog posts, product entries, docs) stay in sync without a manual registry. Second, it closes a portability gap: libraries that relied on import.meta.glob were effectively Vite-only. One caveat — it's a Turbopack feature, so it won't work in apps built with the --webpack fallback.
The smaller wins add up too
The release also includes a set of less headline-friendly improvements worth knowing about. HMR subscription tracking was streamlined — collapsing multiple chunk subscriptions into one cut dev server cold start by over 15% on complex apps. The Turbopack runtime now ships WebAssembly, worker, and top-level-async loading code only to routes that use those features, trimming runtime size for everyone else. Monorepos get an experimental turbopackLocalPostcssConfig option that resolves the PostCSS config nearest each CSS file instead of forcing one root config. And the compatibility list rolls up the 16.2 patch line: correct import.meta.url file URLs on Windows, chunk fetch retries, module-sync export condition support, and CSS HMR fixes in Safari.
Takeaways
The theme of this release is that Turbopack's caching architecture is starting to pay dividends beyond raw compile speed. Concretely: upgrade to 16.3 and you get memory eviction for free — long dev sessions on large apps should stop ballooning. Turn on turbopackFileSystemCacheForBuild and cache .next in CI; content-heavy sites see the biggest rebuild wins. If build time was your reason for skipping the React Compiler, benchmark the Rust port — 20–50% compile improvement changes that math. And if you're migrating from Vite or maintaining content-driven routes, import.meta.glob removes a real papercut.
None of this requires code changes to your application — which is exactly what you want from a bundler release. The full details are in the official announcement.