npm / nuxt
nuxt
What changed in nuxt 3 to 4, from its official release notes, upgrade guides and advisories. Sources checked 2026-10-18.
34 breaking27 security11 deprecations150 new APIs and options18 performance55 behavior and defaults22 tooling186 fixes and other
See which of these apply to your code, ranked, in your agent:
npx @unstale/cli initnuxt 4450 changes
Breaking changes 29
Routing is case-sensitive by default in compatibility version 5.
Under the Nuxt 5 compatibility defaults, clearNuxtState resets state to defaults.
Typed route data now checks validated body, query and headers more tightly, including whether a request body is required.
The internal error route is served only during an error render and can no longer be reached from outside.
Nuxt CLI v4 requires Node.js v22.21+, v24.11+ or v26+.
This release requires Node.js ^22.22.3 || ^24.15.0 || >=26.0.0.
The Nuxt CLI v4 drops nuxt init; project creation is supported through npm create nuxt@latest.
The nuxt/server sendRedirect helper returns the response rather than sending it.
Server-only head composables are no longer auto-imported under the Nuxt 5 compatibility defaults.
Removed setResponseHeader from nuxt/server; developers using this export must use an alternative.
Removed setResponseHeaders from nuxt/server; developers using this export must use an alternative.
A template that never finishes compiling now fails the build instead of exiting successfully.
Removed toNuxtRequestEvent from nuxt/server; developers using this export must use an alternative.
Non-object island props are rejected.
Rejects a top-level as prop for islands.
With compatibilityVersion 5, keyed function source is required.
For custom slots, Nuxt no longer attaches prefetch handlers automatically; the slot exposes prefetch, prefetched, and shouldPrefetch so applications can wire them up.
Nuxt upgrades to Rspack 2 and uses Rsbuild-based internals, so custom Rspack configuration may need review.
Nuxt upgrades to unhead v3; useHead has tighter types, and promise input, deprecated in v2, is no longer supported.
Nuxt migrates to unhead v3, which may introduce breaking type changes from stricter useHead typing.
Nuxt migrates to Vite 8; custom Vite plugins and configuration may need review against the Vite migration guide.
Rejects script-capable protocols in href values.
Validates protocols before reload and rejects cross-origin paths.
Requires a loopback host when same-origin signals are missing.
Middleware now runs for page islands.
Nuxt upgrades to vue-router v5 and removes its dependency on unplugin-vue-router; apps using unplugin-vue-router directly can remove it.
Query strings are no longer decoded in the SSR context URL.
noUncheckedIndexedAccess is enabled in the Nitro server TypeScript config, improving type safety but potentially surfacing new server-code type errors.
mergeModels is no longer auto-imported.
Security 25
Payload URLs are parsed as origin-relative paths, preventing paths such as //x/_payload.json from serving the wrong payload.
Nuxt dev server discloses project root and workspace UUID via the Chrome DevTools workspace endpoint
Nuxt route rules silently dropped for mixed-case paths, bypassing appMiddleware auth gates (incomplete fix for CVE-2026-53721)
Nuxt runtime payload cache discloses another user's SSR data across users and to unauthenticated clients
Nuxt: Server-Side Remote Code Execution via Runtime Template Injection in Nuxt Server Island Props
Nuxt: Unauthenticated CPU exhaustion parsing and hashing the Nuxt island endpoint body before hash validation
Nuxt: Unauthenticated out-of-memory crash via unbounded v-for expansion in island rendering
Nuxt: Unauthorized Component Instantiation via Server Island Props
Restricts the workspace endpoint to local requests.
Cross-site scripting via <NoScript> slot content in Nuxt's head components
Rejects prototype-chain keys in the island registry.
Applies an isScriptProtocol guard to the open option.
Blocks open redirects caused by path normalization.
Nuxt: Dev server discloses project absolute path and persistent workspace UUID via
/.well-known/appspecific/com.chrome.devtools.jsonNuxt dev server vite-node IPC socket is world-connectable on Linux
Nuxt: Reflected XSS in
<NuxtLink>via unsanitisedjavascript:ordata:URLNuxt: Route-rule middleware bypass via case-sensitivity mismatch between vue-router and the routeRules matcher
Nuxt: URL-handling weaknesses in
navigateToandreloadNuxtApp: SSR open redirect, client-side script execution via theopenoption, and protocol-relative bypass inreloadNuxtAppEscapes props in server-rendered output.
Island request hashes are validated against props.
Nuxt:
__nuxt_islandendpoint does not bind responses to request props, enabling shared-cache poisoningNuxt: Reflected XSS in
navigateTo()external redirectNuxt's route middleware is not enforced when rendering
.server.vuepages via/__nuxt_island/page_*Cookie decoding now handles unsafe number parsing.
HTML is escaped in the development error page stack trace.
Deprecations 9
Top-level options duplicated by
nitro.*are deprecated.Nuxt warns when a public/ file shadows an application route.
Nuxt warns when a parent page lacks NuxtPage.
statusCode remains supported but is deprecated in favor of status ahead of v5.
statusMessage remains supported but is deprecated in favor of statusText ahead of v5.
Deprecates ImportPresetWithDeprecation.
The schema configResolved hook is deprecated.
The schema extend hook is deprecated.
The extendConfig hook is deprecated.
New APIs and options 144
Accepts a map of handler variants per server API, allowing one module to support Nuxt 4 and Nuxt 5.
Accepts a map of plugin variants per server API, allowing one module to support Nuxt 4 and Nuxt 5.
The createUseFetch and createUseAsyncData factories accept addons that can declare call-site options, adjust merged options, wrap handlers with middleware, and extend composable return values.
Accepts a map of handler variants per server API, allowing one module to support Nuxt 4 and Nuxt 5.
addServerImportsgains server variant support.Types in
app/typesare auto-imported.Adds Nuxt-owned augmentable server types that modules can extend through @nuxt/schema.
Nuxt adds the
appSecretconfiguration option.Case-sensitive routing is available behind the Nuxt 5 compatibility flag, matching Nitro.
createUseAsyncDatanow supports addons.createUseFetchnow supports addons.Adds an API for comparing two Nuxt config loads.
Adds an API to check for and offer to install optional dependencies with the user's package manager.
An experimental option enables early return after
navigateTo.Modules can now set experimental.asyncContext.
Modules can now set
experimental.asyncContext.Enables build-time static page-route matching so unmatched requests can return 404 without creating the Vue app or running plugins and middleware.
An experimental early 404 behavior is added for unmatched page routes.
Enables serializable definePageMeta keys to be extracted at build time.
Renders error.vue in the same request after a server render fails, preserving already-set headers and cookies and avoiding a second Nitro middleware and route-rules pass.
Makes navigateTo in script setup short-circuit the rest of setup, so redirects and 404s do not throw on missing data.
Client-side payload extraction is newly available behind the Nuxt 5 compatibility flag.
Prerenders error pages as real HTML, such as 404.html or pages for specified status codes, instead of an empty SPA shell.
An experimental pure Vite server mode is added.
Enables the rebuilt typed fetch behavior in Nuxt 4; it is opt-in because of small type-inference changes and a rewrite needed for hand-written ServerRoutes augmentations.
Typed $fetch is newly available behind the Nuxt 5 compatibility flag.
Rejects typed fetch calls to paths that do not exist instead of typing their return values as unknown.
Automatically excludes data fetched within hydrate-never component trees from the payload.
Typed pages are newly available behind the Nuxt 5 compatibility flag.
Exports $Fetch from nuxt/app.
Nuxt exports the
$Fetchtype.nuxt/serveradds helpers for forwarded URLs, cookies, and route rules.Setting compatibilityVersion to 5 enables the Nuxt 5 defaults together; each default can also be enabled or disabled individually.
Adds an API to obtain an install command using the user's package manager.
Adds an API for module logic that explicitly needs to know the installed Nitro version.
getRequestIPis now available fromnuxt/server.getRouterParamis now available fromnuxt/server.getRouterParamsis now available fromnuxt/server.getValidatedQueryis now available fromnuxt/server.handleCorsis now available fromnuxt/server.Adds an API for module logic that explicitly needs to check the installed Nitro version.
An isomorphic typed-fetch mode types pages as GET routes, allowing type-safe $fetch calls from the Vue renderer.
Lets module authors declare server API compatibility when Nuxt cannot infer it from a file's imports.
Adds a hook used by Nuxt CLI v4 to show per-module setup time as it happens.
Nuxt Kit adds the
module:beforehook.Adds a hook used by Nuxt CLI v4 to show per-module setup time as it happens.
Nuxt Kit adds the
module:donehook.A new command talks to the running server using the Nuxt CLI lock file.
Adds documentation search from the CLI using a query.
Adds a takeover option that lets a preview server replace a running preview server.
A new server-only import source provides portable, web-standard server utilities typed against Nuxt’s RequestEvent, so server code need not import h3 or nitropack.
Response headers are set through event.res.headers when using the new server runtime.
A new
nuxt/serverentry point provides portable server code and server helpers.A new command talks to the running server using the Nuxt CLI lock file.
Adds an augmentable NuxtPageMeta type for typing NuxtPage.meta.
An augmentable
NuxtPageMetainterface is provided forNuxtPage.meta.Adds Nuxt-owned augmentable server types that modules can extend through @nuxt/schema.
Adds an API for observing changes between two config loads.
Adds a top-level alias for nitro.prerender.
A top-level
prerenderalias is added fornitro.prerender.readValidatedBodyis now available fromnuxt/server.Nuxt Kit adds
resolveServerVariantfor resolving server variants.Nuxt adds a root application secret, configured through NUXT_APP_SECRET, from which modules and server features can derive purpose-specific secrets.
Async data gains a
serializeoption to keep it out of the payload.Adds @nuxt/vite-server as an experimental server builder selectable with the vite shorthand; Nitro remains the default.
nuxt/serveraddsserverFetchfor server-side fetching.Adds Nuxt-owned augmentable server types that modules can extend through @nuxt/schema.
Adds Nuxt-owned augmentable server types that modules can extend through @nuxt/schema.
Session utilities are now available from
nuxt/server.Adds ShallowRef to the Vue auto-import preset.
The Vue preset adds the
ShallowReftype.Templates can declare what changes invalidate them, avoiding unnecessary regeneration.
Adds per-context overrides for the app tsconfig.
Adds per-context overrides for the server tsconfig.
useAppConfigis now available fromnuxt/server.useAppConfigis now available fromnuxt/server.The serialize option accepts false to keep data out of the __NUXT_DATA__ payload.
The serialize option accepts false to keep data out of the __NUXT_DATA__ payload.
useLayoutis exported.useLoadingIndicatoris exported.useRequestHeaderis exported.nuxt/serveraddsuseServerHooks.Session helpers in nuxt/server seal sessions into a cookie, avoiding the need to configure server-side storage.
Adds host-aware prompts, status messages, and in-progress tasks, rendered by the CLI dev panel when available.
Adding the vapor attribute to script setup opts an individual component or page into Vapor mode.
Nuxt adds support for Vue Vapor.
Server code now has import.meta.test defined.
Adds vue.optionsApi and disables it for Nuxt v5 and later.
Nuxt Kit supports the allowImportingTsExtensions option.
AsyncData gains an enabled option.
Setting the watcher to builder lets Nuxt reuse Vite's watcher, reducing memory use and file handles; it becomes the default with compatibilityVersion 5.
getIslandHash is now exposed alongside improved island and key hashing.
getIslandHash is exposed, alongside hashKey, with improved hashing for keys.
hashKey is now exposed alongside improved island and key hashing.
hashKey is exposed, alongside getIslandHash, with improved hashing for keys.
head.push is added for client-side use.
The environment name is exposed on import.meta.
Sibling page files can use the name@view.vue convention to render into named NuxtPage outlets.
Named views are supported through a filename convention.
A new CLI command uninstalls a module and cleans up its configuration.
The --checker option lets developers force vue-tsc or Golar for type-checking.
NuxtLink prefetch props are exposed in its custom slot.
Routes can opt out of SSR streaming with streaming: false.
Tracing channels are supported for SSR events.
Experimental SSR streaming is available.
Nuxt Kit adds updateAppConfig, a utility for module authors.
useFetch gains support for the enabled option.
A composable is added for accessing the resolved route layout.
Adds the PackagePreset type to addImportsSources.
Page composables are now exported from this import path.
Create custom useAsyncData instances with default options, using the same pattern as createUseFetch.
Create custom useFetch instances with default options; object defaults are overridden by usage options, while a function gives full control over merging.
Pass props to layouts through the layout property in definePageMeta; layout props are typed for autocomplete and type-checking.
Enable this experimental option to normalize page component names to match route names.
The 'client' mode inlines the full payload in the initial HTML while still generating _payload.json for client-side navigation.
Profile build phases, modules, and bundler plugins, with timing, RSS, and heap data written to trace, JSON, and CPU profile reports.
Print timing breakdowns to the console for more detailed build profiling.
Add the NuxtAnnouncer component to the app for accessibility announcements.
NuxtLink.useLink now accepts refs as inputs.
Announce dynamic in-page changes to assistive technology with polite and assertive messages.
Set refresh to extend a cookie's expiration when its value is assigned again, even if the value has not changed.
Define view transition types in Nuxt's experimental view transitions support to use different styles for different navigation patterns.
Allows specifying moduleDependencies by meta.name.
Adds status and statusText getters to NuxtError.
Module authors can pass async functions that construct Vite plugins, enabling lazy loading when plugins are needed.
Module authors can pass async functions that construct webpack plugins, enabling lazy loading when plugins are needed.
Route rules can set layouts directly with appLayout, allowing centralized layout management without scattering definePageMeta calls across pages.
A module inherited from a Nuxt layer can be disabled by setting its options to false.
The Nuxt kit exports a type representing the Nuxt major version.
A new import alias targets the server directory and prevents server code from being imported in client or shared contexts.
setPageLayout accepts a second parameter for passing props to the selected layout.
The status property is introduced as the Web API naming-convention replacement for statusCode.
The statusText property is introduced as the Web API naming-convention replacement for statusMessage.
Components can specify a declarationPath.
Extracts useAsyncData and useLazyAsyncData handlers into separate chunks; for prerendered sites, handlers can be tree-shaken from the client bundle.
Enables experimental TypeScript plugin support through the @dxup/nuxt module for navigation and other Nuxt-specific editor features.
Enables opt-in use of the Vite Environment API, which can improve development performance and eliminate edge case bugs.
Setting this option to 5 opts into breaking changes planned for Nuxt v5; the notes recommend using it only for testing.
NuxtLink accepts object-format href values.
Adds a numeric prop for relative time.
Adds a relativeStyle prop for relative time.
resolveModule accepts an extensions option.
Adds the setGlobalHead utility.
Handlers receive an AbortController signal, and refresh or execute accept a signal to cancel pending requests.
Performance 16
The portable event's web view is built on first access, improving performance when it is not needed.
Typed fetch is rebuilt using a route tree, reducing TypeScript resolution cost and avoiding instantiation-limit errors as route counts grow.
Internal links render as plain <a> elements without useLink, computed values, or reactive state, making server rendering faster.
Parses the cookie header once per request, or once per client microtask, rather than on every call; SSR cookie values set in a plugin can be read later in a page.
Scans are reused for unchanged structures to improve performance.
Unchanged generated files are no longer rewritten, reducing unnecessary file-system work.
Prefetch hints are omitted for chunks that are never hydrated.
Island renders are deduplicated during prerendering.
Unneeded plugin handling is tree-shaken from production builds.
Concurrent callers sharing a key now deduplicate
getCachedDatacalls.Skips the key watcher when the key is static.
Route generation now uses unrouting; dev server changes are up to 28x faster when pages are not added or removed, and generation is no longer sensitive to page file ordering.
An in-memory LRU payload cache can serve _payload.json requests without triggering a full re-render.
The nuxt:ssr-styles plugin is significantly faster.
Route rules are compiled into a client chunk using rou3, removing radix3 from the client bundle and eliminating app manifest fetches.
Renderer dependencies are precomputed at build time.
Behavior and default changes 52
A default value is now provided for this experimental option.
Component directories support grouping folders.
Can now be used at the top level of setup().
Scopes dev error reports for remote peers and keeps the dev error channel out of production builds.
Error rendering keeps headers and cookies set by the failed render and avoids a second pass through Nitro middleware and route rules.
The builder watcher mode is among the Nuxt 5 defaults available through the compatibility flag.
Generated tsconfigs no longer include baseUrl under the Nuxt 5 compatibility defaults.
A (group)/ folder in components/ is excluded from the generated component name.
The modulepreload polyfill is no longer inlined in UI templates.
Normalized page names are among the Nuxt 5 defaults available through the compatibility flag.
Now has an explicit public API.
Prefetches server-page islands; prefetch hints are throttled and prioritized, with scheduled work deduplicated, concurrency-limited, and cancelled when navigating away.
When the router has no route for a target such as a public/ PDF, the link falls through to a full-page load, so external is no longer required.
Readonly cookies are no longer written on the client.
Redirect route rules return a meta-refresh body.
nuxt/serverhandlers receive a portable event.Types in
server/typesare auto-imported.typedPagesis enabled whencompatibilityVersionis 5.Becomes the shared baseline for all four generated tsconfigs.
The expires option now accepts a function for dynamic expiration values.
useCookiesupports a dynamicexpiresvalue.Links inside islands now use client-side navigation.
The islands transform now supports the Options API in v-for.
Revalidates cached route payloads instead of using force-cache.
Converts inline route rules exactly or drops them with a warning.
Client components now render inside nested server components.
Nuxt now honors the system HTTP_PROXY environment variable in the builder environment.
Nuxt now honors the system HTTPS_PROXY environment variable in the builder environment.
Build and runtime warnings and errors now carry stable codes, explanations, and suggested fixes; production output retains the code while omitting verbose guidance.
The nitro-server package statically re-exports h3 named symbols.
Inlines CSS for non-island children of server components.
Nuxt reads
.envbefore resolving the Nuxt schema.Head DOM updates are deferred until the page transition finishes.
Allows passing arrays of objects as props.
Allows passing arrays of objects as props.
Rspack and webpack emit styles.mjs when inline styles are off.
Reset state to its initial value instead of clearing it to undefined.
Visibility prefetching is disabled in development to prevent Vite from unnecessarily discovering dependencies and reloading.
Payloads are no longer extracted when ssr is false.
The default ignore list now includes direnv and vendor.
Changes in server/ are watched for the builder:watch hook.
allowArbitraryExtensions is enabled by default in the TypeScript configuration.
The development error overlay can be dragged and minimized; its position and minimized state persist across page reloads.
Payload extraction works in development mode with nitro.static enabled or for pages with isr, swr, prerender or cache route rules.
The inlineStyles feature now works with webpack and rspack builders as well as Vite, enabling critical CSS inlining across these bundlers.
Payload extraction now works with ISR, SWR and cache routeRules, allowing client navigation to use cached payloads and reducing API calls.
Module dependencies can now be specified as an async function.
Starts the error overlay minimized based on the status code.
Uses directory paths in moduleEntryPaths.
Uses rolldown replace only during builds.
During development, Nuxt displays both the custom error page and a toggleable technical error overlay.
Component auto-imports are supported as arguments of h().
Tooling 20
The
nuxtdev server handler variant is now typed.$fetchanduseFetchare typed from generated server routes.Development now warns when a route rendered with noScripts relies on client-side JavaScript.
The recommended upgrade command is
npx nuxt upgrade --dedupe, which refreshes the lockfile and pulls in the latest Nuxt dependencies, including Nuxt CLI v4.Nuxt CLI v4 adds an interactive terminal UI, richer startup and reload diagnostics, and a CLI-level error channel that also streams build progress and app logs.
Development now warns when a page's payload exceeds 100 kB.
Development SSR errors now show mapped stack traces and source code frames in an overlay or standalone error page, with the same report printed in the terminal.
$fetchanduseFetchare typed from generated server routes.Route params defined with definePageMeta now have generated types.
Requires a loopback peer for the chrome devtools workspace endpoint.
Watches external component directories during development.
Types auto-imported $fetch with Nitro's $Fetch type.
Nuxt and Vite reuse the Vite watcher via experimental.watcher.
The dev server now reloads when local layer nuxt.config files change.
A nuxt/* build output contract is introduced across the listed build and schema packages.
This package is now an optional peer dependency, so it is not required in every installation.
Import protection errors now include suggestions and a trace showing where a problematic import originated.
When Vite discovers dependencies at runtime, Nuxt provides a copy-pasteable config snippet for pre-bundling them and warns about unresolvable entries at startup.
Layer server directories are now included in tsconfig.server.json.
Test files now support TypeScript path aliases.
Fixes and other changes 155
AnyFetchPath is re-exported for emitted server route types.
Module directories with a dot in their name are no longer excluded from the app tsconfig.
String and array values for appMiddleware are normalized.
Restoring a deferred prerendered route now preserves its middleware layout.
The dev SSR entry is warmed up from a Nitro plugin.
Module dependencies are resolved from the module that declares them.
Error state is preserved on aborted or cancelled navigation.
H3 and Nitro presets are disabled only when nitroAutoImports is off.
nuxt/app now resolves to the app's runtime.
Response headers are now passed to render:response listeners.
Rooted paths are resolved through the URL parser.
Router parameters are read from the path matched by h3.
Scroll offset is fixed for IDs starting with numbers.
Server route rules match case-insensitively unless routing is sensitive.
The configured SPA loading template location is respected.
Dependencies under absolute transpile directories are no longer inlined.
Server island head now follows useHeadSafe rules.
Types reachable from async data composables are now exported.
Accepts any
baseURLwhen the fetch response type is named.Nuxt dev server handlers receive a
RequestEvent.Handler paths match across both Nitro majors.
Each development server handler is registered once.
The global
$fetchis typed with Nuxt'sTypedFetch.Vite detects the enclosing string delimiter when processing inline style URLs.
The configured
outDiris used as the public directory for non-SSR environments.Object types now align with JSON, improving type compatibility for serialized data.
Its types now allow
falseas an accepted value.Dependency scanning no longer aborts on virtual imports in installed packages.
Vite now matches optimizer messages from Vite 8.1 and later for dependency hints.
The schema ignores the
.wranglerdirectory.Works consistently across Nitro versions; a server tsconfig and versioned route config types are generated automatically.
Works consistently across Nitro versions; a server tsconfig and versioned route config types are generated automatically.
Works consistently across Nitro versions; a server tsconfig and versioned route config types are generated automatically.
Types and augmentations placed in app/types/ are included in the appropriate generated tsconfig.
CookieOptionsremains compatible with cookie serialize options.Early 404 handling is disabled for page paths that cannot be decoded.
Error causes are preserved in development.
No longer produces blank remounts.
Matches vue-router path encoding, preserves percent-encoding in server redirects, and applies baseURL with open.
navigateToappliesbaseURLwhen called withopen.targetis optional when callingnavigateTowithopen.navigateTonow matches vue-router path encoding and preserves percent-encoding in server redirects.Pages rendered with noScripts retain non-script resource hints and have their styles attached correctly.
Hydrated nuxt-client markup is stripped from cached island HTML.
The nuxt/server createError helper takes status and statusText.
A page transition no longer starts when there is no page to leave.
Unmatched public asset paths are served during client-side navigation.
Scoped styles now apply to server component slots.
Types and augmentations placed in server/types/ are included in the appropriate generated tsconfig.
No longer warns when called before Nitro exists.
Fixes awaited hydration resolving with unfetched data, makes awaited lazy async data resolve immediately, and fixes generic type parameter resolution.
Forwards request headers.
useRequestFetchforwards request headers.Handle interrupted and skipped navigations.
The asyncData status is settled when execution bails.
Payloads for components with underscores in their keys are now serialized correctly.
Preview mode is checked again after a prerendered page hydrates.
Route rules are matched against decoded paths.
Adds the .mts file extension to the resolver.
Preserves a trailing slash in the href when unset.
Ignores custom name or path when reusing an existing page.
Rejects the reserved template island prop when the runtime compiler is enabled.
Prevents cache cross-pollution when a reactive key changes.
Preserves method inference when an explicit method is provided.
Returns the global route when called in a detached effect scope.
Per-page keepalive set through definePageMeta is now respected.
$fetch is now auto-imported in user code, fixing edge cases with top-level $fetch.create under Rolldown's output format.
The builder environment now honors HTTP proxy environment variables.
Destination preload hints are forwarded when links are prefetched.
Getter values for body are now unwrapped in useFetch.
Uses a shorter socket name on macOS, with a temporary-directory fallback, to address an issue running the dev server.
The findPath function now respects its type option.
Avoids filtering out directories whose names share a prefix with an allowed directory.
Handles a missing payload in the chunkError listener.
Runs getCachedData again after the initial fetch.
Assigns noSSR before deciding whether to extract the payload.
Prevents a server-only page island from recursing through <NuxtPage>.
Propagates factory types for useFetch and useAsyncData.
Closes the Vite dev server when Nuxt closes.
Errors that occur while fetching the app manifest are now handled.
Component-less parent routes are rendered during client-side navigation.
Deduplicated calls in JSX blocks are matched correctly.
Props are preserved when navigating to a different page with the same path.
The SSR module cache is invalidated when modules are invalidated through plugin hooks.
The legacy
tsconfig.jsonnow respectstsConfig.exclude.The key is updated even when watch is false, so callers receive the current key without enabling watching.
Properties are now marked readonly, preventing mutation through the returned type.
Auto-import handling now supports string presets.
Vite clientServer resolution is fixed when ssr is false.
Avoids redundant CSS links when entry styles are inlined and only treats CSS as inlined when styles are emitted.
Inlines CSS imported from non-Vue JavaScript modules.
Corrects island transforms for server pages and deep mode.
Prevents recursive rendering deadlocks during prerender.
The
serverHandlersarray is preserved afternitro:config.Corrects the payload route rule for
/whenssr: trueoverrides it.Suspense is only force-remounted after its first resolve.
Server-side
useFetchnow respects factoryfetchandbaseURLoptions.Avoids an any return type in vue:setup.
Clears a cached rejected promise.
Fixes alternating execution in navigation mode.
Filters key enumeration by the useState prefix.
Components with attributes are stripped in production builds.
Handles TypeScript type assertions on member-expression callees in the parser.
Resolves layer aliases in CSS files.
Bridges @nuxt/schema augmentations into nuxt/schema.
Skips a cached vnode when its suspense is unmounted.
Preserves falsy prop values when serializing the data attribute.
Invokes the user-supplied error handler when suppressing render errors.
Keeps _route in sync when navigating up the route tree.
Re-encodes the URL to match vue-router.
Corrects the key type.
Prevents in-flight requests from overwriting async data after it has been cleared.
Corrects the type of the cache option.
Fixes FormData body hashing in the deduplication key.
Uses factory-resolved options consistently.
Cookie expiration timeouts now work correctly for long-lived cookies.
Navigation from an error page to external protocols is now allowed.
Explicit prerender routes are now always injected into the prerender queue.
State reset functionality now restores the initial value instead of clearing it to undefined.
Vite and webpack dev servers use node.res to send 403 and 404 responses.
Preserves middleware error status in the 404 fallback.
Restores backwards compatibility for the #app barrel export in keyed functions.
Manifest files are cached to preserve buildId.
Resolves import mapping conflicts for packages outside rootDir.
Prevents CSS flickering in dev mode after configuration changes.
Custom routes are tracked and re-added during HMR.
Fatal errors preserve error.message.
Hash links are focused after navigation.
Keeps the vnode when leaving a deeper nested route.
NuxtError now extends the Error type.
Calls deferHydration done when NuxtPage unmounts.
Handles invalid datetime values.
Nitro path encoding is aligned with vue-router.
A view transition is not started when there is no route.
Async data properties are now reactive when used with the Options API.
Head component tag deduplication now uses the key attribute for proper deduplication.
Client-side pathname decoding now handles non-ASCII route aliases.
NuxtPage now re-renders when a nested NuxtLayout has layouts explicitly disabled.
Suspense is force-remounted when navigating after a pending state.
callOnce is re-executed during HMR.
Module dependencies are typed and respected by metadata name, and are handled by installModule.
Nuxt syncs the internal route before calling the page:finish hook.
The pretty error handler is no longer shown when testing.
The watch callback resolves after a reactive key changes.
Deduplicated async data executions return the latest promise.
Removes abort signal event listeners after rendering.
Cleans up an event listener with the cleanup signal.
Removes the iframe border from the Nuxt error overlay.
Applies optimizeDeps configuration before other plugins.
Corrects the warning shown for a prefetch/noPrefetch conflict.
Processes prerender routes on pages:resolved.
Respects layer priority order when scanning components.
Respects the Vite proxy in development middleware.
Arrays in app config are handled correctly during HMR.
Redirects based on routeRules preserve the URL hash.
nuxt 353 changes
Breaking changes 5
The endpoint is gated to local requests.
The open option now rejects script-capable protocols and path-normalization open redirects, preventing unsafe navigation.
Route rules now match case-insensitively, mirroring vue-router.
declarationPath is removed from component directories.
Native attributes can no longer shadow NuxtLink props.
Security 2
Cookie decoding no longer performs unsafe number parsing.
Nuxt is protected against a resolved Nuxt module subpath.
Deprecations 2
The configResolved hook is deprecated.
The extend hook is deprecated.
New APIs and options 6
Use status in place of the deprecated statusCode property when creating errors.
Use statusText in place of the deprecated statusMessage property when creating errors.
installModule accepts moduleDependencies.
Adds experimental support for TypeScript plugins.
useAsyncData adds an abortController option.
Adds the ability to enable the Vite environment API.
Performance 2
Cache layer roots and short-circuit relative isIgnored checks to improve performance.
AsyncData handlers are extracted to chunks.
Behavior and default changes 3
CSS is now inlined for lazy components imported from
#components.Middleware runs for page islands.
In development, the youch error page is displayed with the user error page.
Tooling 2
These declarations are ignored.
Builders can augment types.
Fixes and other changes 31
Normalizes slashes in the build assets directory setting.
Preserves query parameters during cached payload extraction.
Updates the client URL to match SSR after a fatal middleware error.
Removes the development error overlay when the error is cleared.
Reloads the real page module on HMR.
Generates layout types even when the pages module is disabled.
Does not apply scroll behaviour after a subsequent navigation.
Synchronizes layout meta during middleware on SSR.
The fallback tag name is now validated.
Server page CSS is extracted when
inlineStylesis disabled.Concurrent calls in the built-in router now apply the latest navigation.
page:startnow finishes beforepage:finishstarts.Plugin navigation is preserved during app boot.
Teardown now detaches the in-flight promise.
The error type now matches the runtime behavior.
Rspack and webpack require a loopback host when same-origin signals are missing.
Props passed to setPageLayout are preserved during same-path navigation.
Freeze head explicitly during the island plugin phase.
Only consider CSS inlined when styles are actually emitted.
Correct the payload route rule for
/whenssr: trueoverrides it.Clears a cached rejected promise and fixes alternating execution in navigation mode.
Rspack and webpack now respect the configured
testoption.NuxtError now has status and statusText getters and correctly extends the Error type.
Unicode paths in the prerender header are encoded.
Nuxt v3 will continue receiving security updates and critical bug fix releases through July 31, 2026.
Generated references for component declaration items are made valid.
Module dependencies are typed and respected by metadata name.
The root route is preserved in the isPrerendered check.
Cleanup is safe when loadNuxtConfig is called concurrently.
Prerender and Nitro flags are preserved in webpack and rspack server builds.
The shortPath property is added back.