← Blog
#React#Next.js#TypeScript#TanStack#Frontend

React in 2026: Framework Options Beyond Next.js

webhani·

A Medium article titled "Goodbye Next.js? My New React Stack for 2026" has been making the rounds. It's not just clickbait — the State of JS 2025 survey (published February 2026) found that 17% of Next.js users hold negative opinions, with comments like "Next complexity has gotten absurd."

Meanwhile, React 19.2 shipped the React Compiler as stable, and "TypeScript has won" is now treated as settled fact, not a prediction. The React ecosystem has matured to the point where Next.js is no longer the default-without-thinking choice.

What the React Compiler Changes

The single biggest developer experience improvement in React 19.2 is automatic memoization. Before, preventing unnecessary re-renders required manually placing useMemo, useCallback, and React.memo throughout your component tree.

// Before: manual memoization required
const PostList = React.memo(({ posts, onSelect }) => {
  const sortedPosts = useMemo(
    () => [...posts].sort((a, b) => b.date - a.date),
    [posts]
  );
  const handleSelect = useCallback(
    (id: string) => onSelect(id),
    [onSelect]
  );
  return sortedPosts.map(p => (
    <Post key={p.id} post={p} onSelect={handleSelect} />
  ));
});
// After: compiler handles optimization automatically
const PostList = ({ posts, onSelect }: Props) => {
  const sortedPosts = [...posts].sort((a, b) => b.date - a.date);
  const handleSelect = (id: string) => onSelect(id);
  return sortedPosts.map(p => (
    <Post key={p.id} post={p} onSelect={handleSelect} />
  ));
};

The compiler performs static analysis to determine where memoization is needed and inserts it automatically. Code gets cleaner, and you eliminate the class of bugs caused by missing or incorrect dependency arrays.

TypeScript Is Now a Given

The Nuxt core team leader's quote — "TypeScript has won, not as a bundler but as a language" — describes where we are. next.config.ts (TypeScript config files) is now standard:

import type { NextConfig } from 'next';
 
const config: NextConfig = {
  experimental: {
    reactCompiler: true,
  },
  images: {
    formats: ['image/avif', 'image/webp'],
    deviceSizes: [640, 750, 828, 1080, 1200, 1920],
  },
};
 
export default config;

Type checking and autocompletion now extend to configuration files. A small thing that adds up over time.

Alternatives Worth Knowing

TanStack Start

TanStack Start provides full-stack TypeScript with a notably more explicit API than Next.js App Router. The type-safe routing is its strongest feature:

import { createFileRoute } from '@tanstack/react-router';
 
export const Route = createFileRoute('/posts/$postId')({
  loader: async ({ params }) => fetchPost(params.postId),
  component: PostPage,
});
 
function PostPage() {
  const post = Route.useLoaderData(); // fully typed, no extra declarations
  return (
    <article>
      <h1>{post.title}</h1>
      <div>{post.content}</div>
    </article>
  );
}

The loader/component contract is explicit. No magic around how data flows from server to component.

React Router v7

React Router v7 merged with Remix to become a full-stack framework. It uses Vite and keeps the clean loader/action pattern Remix established:

// app/routes/posts.$id.tsx
import type { Route } from "./+types/posts.$id";
 
export async function loader({ params }: Route.LoaderArgs) {
  const post = await getPost(params.id);
  if (!post) throw new Response("Not found", { status: 404 });
  return { post };
}
 
export default function Post({ loaderData }: Route.ComponentProps) {
  return <article>{loaderData.post.content}</article>;
}

The types for loaderData are inferred from the loader return type — you don't declare them separately.

Plain Vite + React (SPA mode)

If you have a separate backend API and don't need SSR, the simplest stack is Vite + React + React Router in SPA mode:

npm create vite@latest my-app -- --template react-ts
cd my-app && npm install react-router

No build complexity, fast dev server, deploys to any static host. For many internal tools and dashboards, this is all you need.

Choosing a Framework

Stick with Next.js when:

  • React Server Components and the data-fetching model genuinely help your use case
  • You're deploying to Vercel and want maximum platform integration
  • Your team knows App Router and the switching cost is real

Look at alternatives when:

  • You have a separate API and the frontend is effectively a SPA
  • You're spending meaningful time debugging Next.js caching behavior
  • You need to deploy to non-Vercel infrastructure with optimal performance
  • You're starting a new project and want to evaluate the tradeoffs fresh

Bottom Line

React Compiler being stable is the most practically useful React update in years — it reduces boilerplate without changing how you write components. TypeScript in config files is table stakes now.

The interesting shift in 2026 is that TanStack Start and React Router v7 are legitimate production frameworks, not "Next.js alternatives." If you're starting a new React project, evaluating all three and choosing based on actual requirements is the right approach — not defaulting to Next.js because it was the obvious choice in 2023.

← Back to Blog