Nuxt vs Remix

Code splitting per route and prefetching are automatic, but Vue runtime ships on every page. Not lean by default.

SSR-first delivery ships HTML immediately and route-based code splitting keeps per-page payloads lean. The full React runtime ships on every page with no selective hydration model.

Achievable and common in production but not automatic. SSR removes render-blocking and @nuxt/image helps LCP, but intentional optimization is required to hit green consistently.

SSR-first delivery helps LCP and reduces layout shift versus pure SPAs. Full React hydration overhead means marketing pages require extra effort to match Astro scores.

Vue runtime (~34kb min+gzip) ships on every page. Server-only components and NuxtIsland reduce bundle size but require opt-in - the default is a fully hydrated Vue page.

Automatic route-based code splitting works well. No island-style selective hydration to strip JS from content-only routes. Every route hydrates with React by default.

The cli produces a working project in under a minute with TypeScript configured by default. Nuxt DevTools are included. Slightly more opinionated than others.

The cli spins up a Vite-powered project in under two minutes. Three available modes add minor friction for developers who just want to start an app.

Best-in-class for the Vue ecosystem. Auto-generated types for routes, typed responses, and auto-imported composables with full inference via Volar.

Best-in-class per-route type inference. The Vite plugin auto-generates typed loader and action interfaces, no manual interface definitions needed. Ahead of Next.js on route-level type safety.

Vite-based cold starts are fast but auto-import resolution and module system add overhead on larger projects. Changes to composables or config can trigger slow full reloads.

Vite-based and fast on small projects. Confirmed GitHub issues report 30-40 second page renders on larger codebases, the Babel compiler in the plugin is the root cause.

A persistent weak spot. SSR hydration mismatch errors surface as generic Vue warnings. Module conflicts produce cryptic build errors. Nuxt DevTools help at runtime but build-time errors remain hard.

Route-level error boundaries catch errors cleanly with full stack traces in dev. In production, errors are sanitized and swallowed silently unless you implement custom error exports.

nuxt generate with route crawling and per-route prerender works well for content sites. Dynamic routes requiring runtime data need explicit enumeration.

Added in v7 via the prerender config. Returns an array of URLs to pre-render at build time. Functional but manual, no automatic static path detection from file-system conventions.

Nitro is genuinely excellent - streaming SSR, edge rendering, server middleware, and runtime-agnostic output for Node, Bun, Deno, Cloudflare Workers, and Vercel Edge.

SSR is the core of the framework. Loaders run server-side before render, data arrives with initial HTML, and edge deployment via Cloudflare Workers is a first-class documented path.

The routeRules API in nuxt.config.ts is best-in-class. Individual routes can be prerendered, cached, SSR-disabled, or redirected all in one config file.

SSR with per-route static pre-rendering via prerender config and clientLoader for CSR opt-outs. SSR is a global flag, not fully isolated per route without workarounds.

Strong ecosystem via Strapi, Storyblok, Sanity and Contentful modules, and the first-party Nuxt Content module with MDC syntax and built-in search.

All major headless CMSes work via loaders. No official CMS adapter ecosystem comparable to Next.js. Integration requires standard fetch code in loaders, functional but more manual.

Nuxt Content includes live reload for local dev. Headless CMS preview modes are documented but require manual setup. Storyblok has the best Nuxt-specific preview integration.

No built-in draft or preview mode equivalent to Next.js. CMS vendors document Next.js preview integrations primarily, React Router v7 is largely undocumented for preview workflows.

File-based routing via pages/, nested layouts, dynamic and catch-all segments, and NuxtLink prefetching are all solid. definePageMeta enables per-page middleware and layout rules.

Nested routing is the defining architectural feature. URL-driven loaders, parallel data loading across sibling routes, deferred loading with Await, and resource routes are all built in.

useFetch, useAsyncData, and $fetch handle SSR/CSR data with deduplication and payload serialization. The mental model takes time to internalize but the implementations are solid.

The loader and action model is the cleanest server-data abstraction in the React ecosystem. Colocated with routes, parallel by default, and testable in isolation using web standard Request and Response.

The server/api/ directory powered by Nitro is excellent. Typed handlers, all HTTP methods via filename convention, and edge function deployment are all first-class.

Resource routes handle JSON, file uploads, and webhooks cleanly. More boilerplate than Next.js Route Handlers for complex APIs, no built-in type-safe RPC layer.

Auto-imports, composables, and Nuxt Layers architecture scale well with teams. Auto-import magic can make it harder to trace where functions come from on large projects.

Colocated loader, action, and component per route scales well; each route is a self-contained module. Teams must make more architectural decisions than in Next.js App Router.

Nuxt 2 to Nuxt 3 was a near-complete rewrite requiring different store, module API, and rendering engine. Within Nuxt 3 minor releases upgrades are smooth.

The Remix to React Router merger caused community churn and the upcoming React-free Remix v3 adds uncertainty.

Vue templates are readable but Nuxt auto-imports, the `#imports` virtual module, and server/ conventions require framework knowledge to navigate confidently.

Loaders and actions are explicit and route files map to URLs clearly. Three available modes and the convergence with Remix mean older docs may describe a different API.

Nitro presets cover Node, Bun, Deno, Cloudflare Workers/Pages, Vercel Edge, Netlify, AWS Lambda, Azure Functions, Render, and Railway. The most complete adapter system of any meta-framework.

First-class adapters for Cloudflare Workers, Vercel, Netlify, AWS, Fastly, Deno Deploy, and Node. Cloudflare lists React Router v7 as a primary supported framework.

Vite-based production builds are fast. Type generation and Nitro bundling add overhead compared to plain Vite. A medium project typically builds in 30-90 seconds.

Vite-based production builds complete in 30-90 seconds for medium projects. The Babel dev plugin creates a gap between dev iteration speed and production build speed.

Cloudflare Workers support via Nitro enables near-zero cost at scale for edge-rendered pages. Vue runtime size can approach the 1MB Workers script limit on feature-heavy apps.

Edge-first design via Cloudflare Workers means low cost at scale. Full SSG deployment to CDN is supported. Competitive with Next.js and better than always-on Node server deployments.

Capable with nuxt generate and @nuxt/image but Vue runtime overhead and required optimization work puts it behind Astro for content-first sites. Well-suited when complex interactivity is needed.

Technically capable but the wrong tool. Full React bundle on every page, no preview mode, and no CMS vendor support for preview workflows.

Strong choice for complex interactive Vue applications. Full-stack via server/api/, Vue 3 composition API, Pinia, and hybrid rendering make it excellent for SaaS and dashboard products.

Purpose-built for data-heavy interactive applications. The loader and action model, nested routing, progressive enhancement, and edge deployment combine to make this the strongest React option for app work.

Vue's Proxy-based reactivity system is excellent for complex UIs. The composable provides SSR-safe shared state. Minor footguns around accidental reactivity loss for developers new to Vue.

Progressive enhancement is a first-class design principle, forms work without JS and useFetcher enables optimistic UI. Achieving full progressive enhancement requires discipline and is not enforced.