Nuxt 4.5 - Vite 8, Rspack 2, SSR Streaming, and the Road to Nuxt 5
Nuxt 4.5 is the biggest release in a while - Vite 8, an Rsbuild-powered Rspack 2 builder, experimental SSR streaming, stable error codes, and a pile of groundwork for Nuxt 5. Here's what actually matters, what to test before upgrading, and why the Nuxt 3 clock is about to run out.
When I migrated this blog to Nuxt 4, I wrote that the Nuxt team had made painless upgrades their brand. Nuxt 4.5, released on July 18, 2026, is the release where they cash that in: three major dependency bumps at once (Vite 8, Rspack 2, unhead v3), an experimental SSR streaming mode I've wanted for years, and — the part that made me sit up — an explicit statement that the team's focus now shifts to stabilising Nuxt 5. Daniel Roe called it their biggest release in a while, and for once that's not release-notes inflation.
Here's what's in it, what I'd turn on today, and what the timeline to Nuxt 5 actually looks like.
The Two Dates That Matter
Before the features, the calendar — because this release is as much a roadmap signal as a feature drop:
- Nuxt 3 end-of-life: July 31, 2026. That's eleven days after this release. A final maintenance patch (v3.21.9) ships alongside 4.5 with backported fixes, but the headline upgrades (Vite 8, Rspack 2, unhead v3) are v4-only. If you're still running Nuxt 3 in production, the migration you've been postponing is now overdue, not optional — my Nuxt 4 migration guide covers the whole path, and it's genuinely a morning of work for most apps.
- Nuxt 5 is next. No release date yet, but the team says outright that with 4.5 shipped, their focus turns to stabilising v5 and building compatibility utilities. You can already opt into v5 breaking changes today with
future.compatibilityVersion: 5in your config — the same preview mechanism that made the 3→4 upgrade so boring (in the best sense).
A big chunk of 4.5 is deliberately invisible: core dependencies moved to their latest majors, the framework's own build switched to tsdown, and a stable build-output contract landed — all plumbing to shrink the gap between v4 and v5 so the next major is a small step instead of a cliff.
Vite 8 — Faster Cold Starts, Check Your Plugins
Nuxt now runs on Vite 8, with the latest Rolldown-powered internals and noticeably faster cold starts. For most apps this is a transparent upgrade — this blog didn't need a single config change.
The caveat: Vite 8 is a real major version. If you have custom Vite plugins, a hand-tuned vite.config, or ecosystem plugins that pin a Vite version, skim the Vite migration guide before shipping this to production. In my experience the failures are loud (build errors), not subtle, so a CI run usually tells you everything.
Rspack 2 — Now Rsbuild All the Way Down
If you use builder: 'rspack', this is the meatiest part of the release. Nuxt moved to Rspack 2 and rebuilt the whole builder on top of @rsbuild/core. The public surface is unchanged — same builder: 'rspack' opt-in, same rspack:* hooks — but internally the dev server now runs in middleware mode via Rsbuild, replacing the old webpack-dev-middleware setup, and a Rspack-specific Vue loader fixes SSR scoped-style ids.
The team kept the builder named rspack so nothing breaks, but this is clearly the foundation for first-class Rsbuild support. If you have custom Rspack config, review it after upgrading — the internals under your feet changed.
SSR Streaming — The One I'm Excited About
This is the feature I'll be testing first. With experimental.ssrStreaming: true, Nuxt stops buffering the entire rendered page before responding. Instead it flushes the HTML shell — <head>, styles, preload hints, entry scripts — immediately, then streams the body as Vue renders it:
export default defineNuxtConfig({
experimental: {
ssrStreaming: true,
},
})
Why this matters: TTFB is the floor under every other loading metric. The browser can't discover your CSS, fonts, or hero image until the first bytes arrive — I've measured exactly this chain on real projects in my Core Web Vitals deep dive. Streaming lets the browser start that work while the server is still rendering, which on slow backends or data-heavy pages is a genuinely large win.
The design is more thought-through than most experimental flags:
- Bots get buffered HTML automatically. Crawlers receive fully-rendered pages, so SEO is unaffected — and you can tune the bot detection with your own
botRegex. - Incompatible routes fall back safely. Routes with
redirect,cache,isr,swr, orssr: falserules automatically use the buffered renderer. - Nothing fails silently. In dev, Nuxt logs a warning naming any response mutation that got dropped.
The one thing you must understand before enabling it: streaming commits the HTTP status and headers with the first byte. Anything that mutates the response after rendering starts — a setResponseStatus() inside <script setup>, a cookie write mid-render — can't reach the client anymore. Audit those patterns first, then turn it on for content-heavy routes and measure.
Stable Error Codes — Small Feature, Big Quality-of-Life
Nuxt errors and warnings now carry stable codes like NUXT_E1001, each with an inline why and a concrete fix, and the complex ones link to dedicated docs pages. The classic "composable called outside a Nuxt context" — the error every Nuxt developer has googled at least once — is now NUXT_E1001 with the context rules and runWithContext() fix right there.
This sounds minor until you think about what it does for tooling: stable codes are greppable, bookmarkable, and — relevant to how I work these days — much easier for AI coding agents to resolve deterministically. An agent that hits NUXT_E1001 can look up the exact fix instead of pattern-matching on prose that changes between versions. The verbose text is stripped from production builds, so there's no bundle cost.
The Smaller Wins Worth Knowing
enabledforuseFetch/useAsyncData— gate fetching on a reactive precondition. Whileenabledis false, nothing fires (initial fetch,refresh(), watch triggers), and flipping it mid-flight cancels the request without clearing existing data. The "don't search until the user typed 3 characters" pattern no longer needs a manualwatch. This slots neatly into the reactive-key model I covered in the Nuxt 4 guide.useLayoutcomposable — a reactive, read-only answer to "which layout is this page using?". Previously you got to spelunk through route meta.- Named views — multiple
<NuxtPage>outlets per parent, filled via achild@sidebar.vuefilename convention. Vue Router supported this forever; now file-based routing does too. - Prefetch control for custom
<NuxtLink>slots — the slot now exposesprefetch,prefetched, andshouldPrefetch, so custom link markup can wire up prefetching properly instead of losing it. experimental.prefetchPreloadTags— when prefetching a link, Nuxt forwards the destination page's preload hints into the current document as low-priority prefetches. The next page's hero image starts downloading before the user clicks. Off by default; worth a spin on image-heavy sites.- Shared file watcher —
experimental: { watcher: 'builder' }piggy-backs on Vite's chokidar instance instead of running a second watcher. Less memory, fewer file handles; becomes the default in v5. - Free performance — faster dev startup, the island-renderer chunk skipped entirely when you use no islands, and plugin handling tree-shaken out of production builds. No opt-in needed.
Before You Upgrade — The Three Things to Check
The upgrade itself is one command:
npx nuxt upgrade --dedupe
The --dedupe matters more than usual this release — three major dependency bumps ride along, and a deduplicated lockfile is how you avoid two Vite versions fighting each other. My checklist:
- Vite 8 — custom plugins and
vite.configtweaks against the migration guide. - Rspack 2 — only if you use
builder: 'rspack'; the internals are Rsbuild now. - unhead v3 —
useHeadtypes got stricter. If you hit type errors after upgrading, they're almost always genuine issues the looser v2 types let slide, not regressions. Runtime behaviour is compatible for the vast majority of apps.
For this blog the whole thing was: run the command, run the type check, done. Your mileage scales with how much custom build config you carry.
My Take
Nuxt 4.5 is two releases in one. On the surface it's a strong feature release — SSR streaming alone justifies the version bump for anyone fighting TTFB. Underneath, it's the Nuxt 5 on-ramp: dependency majors landed early, breaking changes previewable behind compatibilityVersion: 5, and a team openly telling you where their attention goes next.
The pattern is the same one that made Nuxt 4 a non-event to adopt, and it's the right way to run a framework: majors should be boring because everything risky shipped incrementally beforehand. If you're on Nuxt 4, upgrade now and start testing streaming. If you're still on Nuxt 3 — the support window closes on July 31. That's not a drill anymore.
If you're planning the jump — whether it's Nuxt 3 to 4 under deadline pressure or preparing a headless storefront for Nuxt 5 — I've done these migrations on production apps and I'm happy to take a look at yours.
Useful References
- Official Nuxt 4.5 announcement — the full release post by Daniel Roe
- Nuxt Upgrade Guide — including
compatibilityVersion: 5 - SSR Streaming docs — fallback rules and caveats
- Vite 8 migration guide — check custom plugins before upgrading
Enjoyed this?
Get new posts as they land.
Keep reading
Debugging LCP on a Real Site - A Case Study on marcofaul.de
A first-person walkthrough of fixing LCP on this very site - a JS reveal animation gating first paint, a font preload that held rendering hostage, a 5.8s image CDN cold start, and the measurement noise that almost sent me chasing ghosts.
Migrating to Nuxt 4 - The New app/ Directory, Smarter Data Fetching, and a Painless Upgrade
Nuxt 4 is here. Learn the new app/ directory structure, improved useFetch/useAsyncData, the path-alias gotcha, and how to upgrade safely with codemods.
Shopware Frontends - Building a Composable Storefront with Vue and Nuxt
Shopware Frontends is the official way to build headless storefronts on Shopware 6. Learn the Vue Starter Template, Nuxt layers, composables, and the Store API architecture.