Source: https://www.hype-stack.dev/stacks/nextjs-alternative

# Next.js Alternatives 2026: Five Frameworks, or No Framework

> Most lists answer "which other framework". For an application behind a login there is a second question underneath:
> whether the server and the client need to be one program at all.

Next.js is the default way to start a React project, and for a lot of projects the default is correct. It gives you
file-based routing, server rendering, and API endpoints in one codebase with one deploy. Many libraries and hosting
guides document a Next.js setup first.

People searching for a nextjs alternative usually have one of two doubts. The App Router and Server Components added a
server and client split inside every page, with caching rules to learn on top. And the smoothest hosting path runs
through Vercel, the company that builds the framework, which some teams read as a dependency they did not choose.

Both doubts are reasonable, and neither means you should leave.

## Where Next.js wins

**Content and marketing sites.** If most pages are public and need to arrive as HTML for search engines and link
previews, server rendering is the feature you are paying for. A blog, a docs site, a storefront, or a landing page with
thousands of indexed URLs is the case Next.js was shaped around.

**Teams already on Vercel.** Preview deploys per pull request, image handling, and edge delivery come configured.
Replacing the framework means rebuilding that workflow.

**Hiring and ecosystem.** It is the React framework a new hire is most likely to have used, and the one a third-party
SDK is most likely to have an example for.

**One deploy.** UI and server code ship together. For a small team that means one pipeline and one thing to roll back.

If your project is mostly public content, stop here and use it. The rest of this page is for the reader building an
application: sessions, a database, billing, screens nobody sees without logging in.

## The framework alternatives

Next js alternatives split into two groups: other full-stack React frameworks, and frameworks that leave React behind.

**What else is out there**

- **React Router, in framework mode** Where Remix ended up. Routes own loaders and actions, data loading follows the URL, and it deploys to a plain Node server as readily as to a platform. The closest swap if you like the full-stack model and dislike Server Components.
- **TanStack Start** A full-stack framework built on TanStack Router, with server functions and server rendering added to a router whose params and search state are typed. Younger than Next.js, with a smaller ecosystem.
- **Astro** Content first. Pages render to HTML and ship little JavaScript unless you opt a component in, and those components can be React. Strong for marketing sites and docs, a poor fit for a dashboard that is interactive on every screen.
- **SvelteKit and Nuxt** The equivalent full-stack frameworks for Svelte and Vue. Both are mature. Choosing either means leaving React, so the cost is your component library and your team's habits.

_None of these involve us. If one of them fits, it fits._

Comparisons like "tanstack start vs nextjs" or "next js vs sveltekit" ask the same thing: which framework should render
my pages and run my server code together. For TanStack Start the difference is checkable in its own comparison docs:
React Server Components are experimental and opt-in there and the core model in the App Router, server rendering can be
turned off per route, and the build runs on Vite or Rsbuild where Next.js uses Turbopack. The lists tend to skip a
different question.

## What actually changes if you leave Next.js

The framework choice is the easy part. What takes the time is the list of things Next.js was doing for you. This is the
inventory from TanStack's migration guide, and most of it applies to any move to a Vite-based stack.

|  | In Next.js | After the move |
| --- | --- | --- |
| Links | next/link | The router's own Link. In TanStack Router, params are typed: to="/posts/$slug". |
| Images | No direct replacement. A plain img, or Unpic with an image service you pick. | next/image, with the built-in optimizer |
| Fonts | next/font | Fontsource, or self-hosted files with @font-face. |
| API code | app/api/hello/route.ts | A server route in TanStack Start, or an endpoint on a separate API server. |
| Mutations | Server functions or API calls. Not a drop-in: forms behave differently without JavaScript. | Server Actions and revalidatePath |
| Page metadata | The Metadata API | A head config on each route, and the sitemap becomes a server route. |
| Middleware | middleware.ts | No one-to-one mapping. Move the checks into route guards or the API server. |
| Public environment variables | NEXT_PUBLIC_ and process.env | On Vite, VITE_ and globalThis._importMeta_.env. |

Teams that have published their moves report the same pattern: large pull requests, a working app at the end, and at
least one surprise in a library written for Next.js. Translation is a common one, because next-intl has no drop-in
equivalent. Budget for that part, and do not expect the move alone to fix slow pages. If the complaint is local dev
speed, it is worth measuring first, since reports of big improvements are mostly first-party anecdotes from teams who
were already moving.

## The option the lists skip: no full-stack framework

A logged-in application does not need server rendering for search engines, because a crawler is not signing in. That
removes the main reason to couple the UI to a server runtime. What is left is an older and plainer shape: an API server
that speaks HTTP, and a React client with a router that calls it.

In practice that is two programs. A backend (Hono, Fastify, Express, or anything else) owns the database, auth, and
business rules. A single-page React app, built by Vite into static files, owns the screens. They meet at a URL.

|  | Separate API and client | Next.js |
| --- | --- | --- |
| Mental model | Every component runs in the browser. Every route handler runs on the server. No file is both. | Server and client components in one tree, with rules about what may cross the boundary. |
| Public page rendering | Client rendered. Public pages arrive as an empty shell until JavaScript runs. | Server rendered HTML, which is what search and link previews want. |
| Who can call the server | Anything that speaks HTTP: the web app, a mobile app, a browser extension, a partner. | The web app first. A second consumer needs route handlers written as a deliberate public API. |
| Deploys | Two of them, plus CORS and cookie settings that must agree across two origins. | One. |
| Hosting | Static files on any web server, and one Node process next to a database. | Smoothest on Vercel. Self-hosting as a Node server is documented and takes more of your own setup. |
| Types across the boundary | Server code is imported directly, so types come with it. | Not free. You need a typed client, a schema, or codegen to get them back. |

The last row used to decide the matter, because splitting client and server meant hand-written fetch calls and response
types that drifted. Several tools now close that gap (tRPC, OpenAPI codegen, Hono's inferred client types), which is why
the split is worth considering again.

## How Hype Stack is built, as one example of the split

The template is a monorepo with a Hono backend in `apps/backend` and a React 19 single-page app in `apps/frontend`,
routed by TanStack Router. The [Hono Prisma starter walkthrough](/stacks/hono-prisma-starter) gets that backend running
in three commands. Types cross the HTTP boundary without a build step. Routes are validated with Zod, the
function `registerRoutes` returns a typed Hono app, and `apps/frontend/src/api/sdk.ts` builds a HyperFetch client from
that return type:

```ts
export const sdk = createSdk<typeof client, ApiRoutesSdk>(client);
```

Rename a field in a Zod schema and the frontend stops compiling. No OpenAPI file sits in between. The Expo app in
`apps/mobile` uses the same SDK against the same API, which is what keeping the server a plain HTTP service buys.

The backend is a long-lived Node process, so it holds WebSockets and a Prisma connection pool open, and the cron
scheduler and the Postgres-backed task queue run inside it. The frontend is a Vite build with no server of its own, and
each app deploys independently from its own Dockerfile, so restarting the API does not rebuild the UI. The
[cron expression generator](/tools/cron-expression-generator) explains a schedule in plain English before you add a job.

The move from the table above is smaller here than it looks, because most rows disappear rather than translate. Server
Actions become ordinary endpoints with a typed client, and there is no metadata API or image optimizer to replace on
screens behind a login.

The core template is free and MIT licensed. For an app with accounts and payments, the starting point is the Better
Studio template, which composes an auth starter, a layout, and a billing pack. Those packs are paid, and the CLI copies
them into your repository as source.

## What this shape does not give you

Server rendering. The frontend is a client-rendered SPA, and the docs describe no SSR mode for it. Better Studio
includes a marketing landing page, but it renders in the browser like every other route. If organic search on public
pages is how you plan to get customers, put those pages somewhere that renders HTML. Astro or Next.js on your root
domain with the app on a subdomain is a common arrangement, and that site is yours to build and host.

Two deploys have their own failure modes. `VITE_API_BASE_URL` is baked into the frontend bundle at build time, so
pointing a built frontend at a different API means rebuilding it. And the backend's `FRONTEND_URL` has to match the
deployed site exactly, because CORS, auth callbacks, and email links all read it. A staging frontend talking to a
production API fails in ways that do not look like a config error at first.

The template also ships no API rate limiting, so you write that for your own routes. The auth and billing packs lean on
other companies' services: WorkOS or Better Auth for identity, Stripe for payments. The hosted ones carry their own
accounts and their own bills. The product itself, meaning your tables, endpoints, and screens, is yours to write.

## Which one fits

**What is most of your project?**

- **Public pages:** Stay on Next.js, or look at Astro.
  - Search traffic and link previews depend on server-rendered HTML
  - One deploy and a large ecosystem are worth more than a simpler mental model
- **An app, in one codebase:** React Router or TanStack Start.
  - You want loaders, server functions, and SSR without Server Components
  - The web app is the only consumer of your server code for now
- **An app, with an API:** A separate typed backend and an SPA.
  - A mobile app, an extension, or a partner will call the same endpoints
  - You want WebSockets and background jobs in a process you control
  - You accept two deploys and no server rendering

If the third branch describes you, the sections below show the template running and the exact packs it installs.



Two specific alternatives in depth:
[Create T3 App Alternative with a Backend Included](/stacks/create-t3-app-alternative) and
[Next.js Supabase Boilerplate Alternative](/stacks/nextjs-supabase-boilerplate). If the backend was Supabase rather than
Next.js, [Supabase Alternatives](/stacks/supabase-alternatives) covers that half.
