I write Nuxt more than anything else on the frontend. This site is Nuxt, and so is nuxt-telegram-auth, the Telegram login module I maintain. I've also built internal tools in React and Next.js at a previous job. So this Nuxt vs Next comparison comes from someone who prefers one side and has used both, and I'll try to be fair to the one I use less.

The short version: both are full-stack meta-frameworks that render on the server, route from the file system and deploy almost anywhere. Most of the difference comes from Vue vs React, and from how much each one makes you think about caching.

Which versions does this Nuxt vs Next comparison cover?

At the time of writing, the latest releases on npm are Nuxt 4.6.4 (2 November 2026) and Next.js 16.4.6 (9 November 2026). Everything below is about those lines.

A few context points worth knowing before you pick:

  • Nuxt 3 reached end of life on 31 July 2026, according to the Nuxt 4.6 release post. New projects should start on Nuxt 4. This site still runs Nuxt 3.11 with Nuxt Content v2, so I'm one of the people who owes an upgrade.
  • Nuxt 5 has no release date yet. The 4.6 post says most Nuxt 5 defaults are already available behind future.compatibilityVersion: 5, and that Nuxt 5 moves to Nitro v3 and h3 v2.
  • Next.js 16 (October 2025) made Turbopack the default bundler, renamed middleware.ts to proxy.ts, made params and cookies() async, and introduced Cache Components. Next.js 16.2 added a stable Adapter API for deploying to other platforms.
  • NuxtLabs, the company behind Nuxt and Nitro, joined Vercel in July 2025. Both frameworks now have core team members at the same company. The announcement says Nuxt and Nitro stay independent, MIT-licensed projects with open governance.

How do the rendering modes compare?

Nuxt renders universally by default: the server sends HTML, then Vue hydrates it in the browser. You can switch the whole app to client-side rendering with ssr: false, or mix modes per route with route rules. The rendering docs list prerender, swr, isr, ssr, headers, redirect, proxy, cors, noScripts and appMiddleware as route rule options.

This is the real config from this site:

// nuxt.config.ts
routeRules: {
  "/": { prerender: true },
  "/blog": { prerender: true },
  "/posts/**": { prerender: true },
  "/projects": { isr: 86400 },
  // ...
},
nitro: {
  prerender: {
    crawlLinks: true,
    routes: ["/", "/blog" /* and the other entry pages */],
  },
},

Posts are static HTML built at deploy time. /projects calls the GitHub API, so it's rendered on demand and cached on the CDN for a day. Nuxt's docs say isr needs a platform with CDN caching, currently Netlify or Vercel. On other hosts, swr gives you a similar cache inside the Nitro server.

Next.js works at the component level instead. Components in the App Router are React Server Components unless you mark a file with "use client". A route with no dynamic APIs is prerendered at build time automatically. With Cache Components turned on (cacheComponents: true in next.config.ts), caching becomes opt-in through the "use cache" directive, and Partial Prerendering lets one page have a static shell with dynamic parts streamed in through Suspense.

The same "GitHub repos, refreshed once a day" page in Next.js 16:

// app/projects/page.tsx
import { cacheLife } from "next/cache";

export default async function ProjectsPage() {
  "use cache";
  cacheLife("days");

  const res = await fetch(
    "https://api.github.com/users/halitsever/repos?per_page=100",
  );
  const repos: { name: string; html_url: string }[] = await res.json();

  return (
    <ul>
      {repos.map((repo) => (
        <li key={repo.name}>
          <a href={repo.html_url}>{repo.name}</a>
        </li>
      ))}
    </ul>
  );
}

My take: Nuxt's route rules are easier to reason about because the caching decision lives in one file, per URL. Next's model is more powerful when a single page mixes cached and per-user content, but you have to know which parts of your tree are server, client, cached or dynamic. Next has changed its caching defaults more than once (implicit caching in the early App Router, opt-in with Cache Components now), so older tutorials can be wrong.

Nuxt has server-only components too (.server.vue files, rendered as islands), but most Nuxt code is ordinary Vue components that render on the server and hydrate on the client.

How is routing different?

Both route from the file system. The names differ more than the ideas.

What you wantNuxt 4Next.js 16 (App Router)
A page at /aboutapp/pages/about.vueapp/about/page.tsx
A dynamic routeapp/pages/posts/[slug].vueapp/posts/[slug]/page.tsx
A catch-all routeapp/pages/posts/[...slug].vueapp/posts/[...slug]/page.tsx
A shared layoutapp/layouts/blog.vue plus definePageMeta({ layout: "blog" })app/posts/layout.tsx, nested by folder
Code before a routeapp/middleware/*.ts (route middleware)proxy.ts (runs on the server, before routing)
An API endpointserver/api/hello.get.tsapp/api/hello/route.ts
Reading the sluguseRoute().params.slugconst { slug } = await params

Next.js nests layouts by folder, so a layout wraps everything below it automatically. Nuxt picks a named layout per page, which I find easier when a few pages need a different shell, as on this site where the home page uses one layout and posts use another.

Next.js also has route groups, parallel routes and intercepting routes built into the folder conventions, for layouts like a modal that has its own URL. If your app is built around those patterns, that's a real point for Next.

How does data fetching compare?

Here is the same blog post page in both, with a 404 for a missing post and the title and description set from the data.

Nuxt:

<!-- app/pages/posts/[slug].vue -->
<script setup lang="ts">
const route = useRoute();
const { data: post } = await useFetch(`/api/posts/${route.params.slug}`);

if (!post.value) {
  throw createError({ statusCode: 404, statusMessage: "Post not found" });
}

useSeoMeta({
  title: post.value.title,
  description: post.value.description,
});
</script>

<template>
  <article>
    <h1>{{ post?.title }}</h1>
    <div v-html="post?.html" />
  </article>
</template>

useFetch runs on the server during SSR and sends the result to the browser in the payload, so the client doesn't fetch it a second time during hydration. The data fetching docs explain the split: useFetch and useAsyncData for data a page needs on load, plain $fetch for things like form submissions.

Next.js:

// app/posts/[slug]/page.tsx
import type { Metadata } from "next";
import { notFound } from "next/navigation";
import { cache } from "react";

type Props = { params: Promise<{ slug: string }> };

const getPost = cache(async (slug: string) => {
  const res = await fetch(`https://api.example.com/posts/${slug}`);
  if (!res.ok) return null;
  return res.json() as Promise<{ title: string; description: string; html: string }>;
});

export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const { slug } = await params;
  const post = await getPost(slug);
  return { title: post?.title, description: post?.description };
}

export default async function PostPage({ params }: Props) {
  const { slug } = await params;
  const post = await getPost(slug);
  if (!post) notFound();

  return (
    <article>
      <h1>{post.title}</h1>
      <div dangerouslySetInnerHTML={{ __html: post.html }} />
    </article>
  );
}

In Next.js the component itself is async and fetches on the server. There's no hook or payload, and the component sends no JavaScript of its own to the browser. The cost is that metadata lives in a separate generateMetadata function, and you wrap the fetch in React's cache so both calls share one request.

For writes, Next.js has Server Functions ("use server"), which you can call from a form or a client component without writing an API route. Nuxt does this with an endpoint in server/api/ and a $fetch call. Nuxt 4.6 added typed $fetch checked against each handler's body, query and headers (opt-in on Nuxt 4, default in Nuxt 5), which closes some of the type-safety gap.

Which ecosystem is bigger?

React's, by a wide margin. In the week before I wrote this, npm counted about 275 million downloads for react and 27 million for vue, and about 99 million for next against 3.6 million for nuxt. Download counts include CI installs, so read them as an order of magnitude. Almost every UI library, auth provider and SDK ships React examples first. It's easier to hire React developers.

Nuxt's advantage is its module system. A module hooks into the build, adds auto-imported composables and components, registers server routes and extends the config, all from one line in nuxt.config.ts. Installing my Telegram login module is:

npx nuxi module add nuxt-telegram-auth

That gives you a <TelegramLoginButton /> component, a useTelegramSession() composable, server-side session checks and page protection through definePageMeta({ telegramAuth: true }). In Next.js the same feature is usually a package plus code you wire yourself: a route handler, a provider component, a check in proxy.ts. That's more flexible, but you write more glue code.

Nuxt also auto-imports Vue APIs, composables and components. Some people dislike the magic. I like not writing import lines for ref and computed on every file.

How do you deploy Nuxt and Next?

Nuxt builds through Nitro. nuxt build gives you a Node server in .output/ that runs with node .output/server/index.mjs. Set NITRO_PRESET or nitro.preset and the same app builds for other targets instead. nuxt generate prerenders everything into static files. This site deploys to Vercel with zero configuration, and the isr rule above maps to Vercel's own cache.

Next.js runs as a Node server with next start, in Docker, or as a static export. The self-hosting guide says ISR and the cache work out of the box for a single next start instance with a persistent disk. Several instances or serverless functions need a custom cache handler (Redis or similar), a shared Server Functions encryption key and a deployment ID to avoid version skew. On Vercel you get all of that without thinking about it. Elsewhere, the stable Adapter API and OpenNext are making it easier, but it's still more setup than Nitro.

If you plan to self-host on a plain VPS or in containers, Nuxt is the simpler of the two. If you're on Vercel, both are first-class. I wrote about deploying an Express app on Vercel a while ago if you need a backend next to either one.

Nuxt vs Next: the comparison table

Nuxt 4.6Next.js 16.4
UI libraryVue 3React 19
Default renderingUniversal SSR with hydrationReact Server Components, static when possible
Per-route renderingrouteRules in nuxt.config.tsPer component: "use cache", Suspense, dynamic APIs
ISRisr route rule on Vercel and NetlifyBuilt in, needs a shared cache handler on multiple instances
Routingpages/ with named layoutsapp/ folders with nested layouts
Data fetchinguseFetch, useAsyncData, $fetchAsync Server Components, Server Functions
Server APIserver/api/ on NitroRoute handlers in app/**/route.ts
ExtendingNuxt modulesnpm packages and manual wiring
BundlerVite by defaultTurbopack by default
Self-hostingNode output and Nitro presetsnext start, Docker, static export, adapters

When would I pick Nuxt, and when Next?

I'd pick Nuxt when the team knows Vue, when the site is content-heavy or mostly static with a few dynamic routes, or when it will be self-hosted. Its config-driven rendering and the module system save time on the boring parts. I used it for this site, and before that for a real-time order-tracking dashboard at work.

I'd pick Next.js when the team knows React, when you need a specific React library or design system, or when a page mixes static and per-user content in ways Server Components handle well. If you're hiring and need many developers quickly, React's larger pool matters.

If you already know one of them well, that usually outweighs everything in the table. Both are good enough that you won't hit a ceiling on a normal product.

I've also written up the Nuxt SEO setup on this site with the real config, and a post on embedding a Metabase dashboard in a Nuxt app. If you need someone to build or upgrade a Nuxt app, see hire.

FAQ

Is Nuxt better than Next?

Neither is better in general. Nuxt is the better fit for Vue teams and for sites where per-route rendering rules are enough. Next.js fits React teams and apps that lean on Server Components.

Is Nuxt the Vue version of Next.js?

It started with the same idea, server-rendered apps with file-based routing, and still fills that role for Vue. The two have since gone their own ways: Nuxt around Nitro and modules, Next.js around React Server Components.

Does Nuxt support ISR?

Yes, through the isr route rule. It uses the CDN cache, which Nuxt's docs say works on Netlify and Vercel. On other hosts, swr caches responses inside the Nitro server.

Which is faster, Nuxt or Next?

Neither framework is faster in every case. Speed comes from how much you prerender, how much JavaScript you send and where you cache. Both can serve fully static pages from a CDN, and that will be fast in either.

Does Vercel own Nuxt?

No. NuxtLabs, the company behind Nuxt and Nitro, joined Vercel in July 2025, and the announcement says both stay independent, MIT-licensed open source projects.