cheapstack
RSSBrowse stacks
framework / 04 — updated may 2026

Remixby react router team · shopify

The web-platform React framework. Now technically part of React Router 7, with the Remix ergonomics merged in. Less marketed than Next.js, more portable, more form-friendly — and increasingly the answer when you want React without the Vercel-shaped opinions.

languageTypeScript-first
runtimeNode · Cloudflare · Bun · Deno
renderingSSR · SSG · CSR · hybrid
nowmerged into React Router 7
Skip to verdictSee pricing →
verdict.txt — frameworks/remix.mdhonest
$cat verdict.txt

Pick Remix (or React Router 7 in framework mode) if you want a React metaframework whose mental model is the web platform — forms, fetch, nested routes, progressive enhancement — and portability matters more than RSC-style streaming.

Updated May 2026read the full reasoning →
verdict / bull case + bear case

Why we picked it — and why we might not

Remixis the default React framework in 2026 not because it’s the smallest or the simplest, but because it’s the one with the least friction across the widest set of problems — provided your problem is shaped like a React product on Vercel.

The bull case is straightforward. App Router, Server Components, and Server Actions collapse what used to be three layers (page, API route, client fetcher) into one mental model. The Vercel deploy story is unmatched — push to git, get a preview URL, promote on click. The ecosystem is the largest in React: every auth provider, every database client, every UI library has a first-class Remix example, and the AI assistants understand Remix better than they understand any other framework. For a team that’s already on React, choosing Remix means choosing the path with the most documentation, the most third-party integrations, and the most worked examples.

The bear case is also real. The cache model is the most complex in the ecosystem; newcomers fight it before they understand it, and “wait, is this server or client?” is a permanent confusion for the first month. Bundle size meaningfully exceeds Astro and SvelteKit — fine if you’re using RSC, pure overhead if you’re not. Lock-in is medium-strength: ISR-on-demand, image optimization, and middleware all bind tighter to Vercel-style hosts than to a generic Node server. Self-hosting works, but you trade deploy ergonomics for it.

For most product teams the calculus comes out in Remix’s favor, but the failure modes are specific and worth naming. If your app is a SPA, Vite + React Router ships less code. If your site is content-first, Astro is a better fit. If you need a pure backend, Hono or Fastify are the right answer. The honest summary: Remix is the right default, not the right answer in every case.

scoreboard / at a glance

At a glance

One row per dimension. The value is what Remixgives you; the note is the editorial framing — the quiet caveat that the marketing page won’t mention.

Routing
file-system · nested · with parallel data loadingNested routes load their data in parallel — measurably faster TTFB than waterfall fetching.
Data loading
loader() per route · type-safe with useLoaderDataEach route has its own loader; nesting parallelizes them. Cleaner than client-side fetch chains.
Mutations
actions + Form (progressive enhancement)Form-based mutations work without JS. Add JS, the form upgrades to a fetcher. The same code handles both.
Rendering
SSR by default · SSG via prerender · streamingNo React Server Components — everything is regular React with server data via loaders. Simpler model.
Hosting fit
Vercel · Cloudflare · Netlify · Node · Deno · BunMore adapters than Next.js. The framework was built around the assumption it should run anywhere.
Bundle size
smaller than Next.js · larger than SvelteKit / AstroReact-shaped means React-sized bundles. Remix doesn't ship more than Next.js; it doesn't ship less either.
Forms / mutations
first-class · best in the React ecosystemIf your app is form-and-mutation heavy (CRUD admin, dashboard, multi-step flows), Remix is the right answer.
Ecosystem
smaller than Next.js · React libs all workAll React libraries work. Remix-specific patterns and helpers are smaller than Next.js's.
Lock-in
low · runs anywhere with a JS runtimeNo platform-specific features — no ISR, no Vercel-specific image optimization, no proprietary cache.
Framework age
5 years · React Router 7 (Nov 2024)Mature; merged into React Router 7 to consolidate the React routing story. Use 'framework mode' for the Remix experience.
pricing / three scenarios

Pricing at three scales

Three receipts at three traffic shapes. Numbers are illustrative — list-tier prices from May 2026, rounded to the dollar. Nothing here is invented; actual bills will vary with usage shape.

hobby.txt — 1k MAU · weekend projectmonthly
line itemdetailcost
HostingCloudflare Pages — freefree
DatabaseTurso free tierfree
TOTAL · monthlyfree/mo
>Remix on Cloudflare Pages is free at hobby scale. The Workers-style adapter pairs naturally with Remix's fetch-everywhere philosophy.
side-project.txt — 10k MAU · steady traffic · paying customersmonthly
line itemdetailcost
HostingCloudflare Pages — freefree
DatabaseTurso Scaler$9
BandwidthCF Pages — unlimited freefree
TOTAL · monthly$9/mo
>Cheaper than Next.js because Cloudflare Pages stays free at this scale. Remix's adapter model means picking the cheapest credible host doesn't cost you platform features.
scale.txt — 100k MAU · production · multi-regionmonthly
line itemdetailcost
HostingCloudflare Pages · global edgefree
BandwidthCF Pages · unlimited freefree
DatabaseTurso Production · 8 replicas$29
WorkersCF Workers paid$5
TOTAL · monthly$34/mo
>Same Cloudflare-Pages economics as SvelteKit and Astro at scale — the bill basically doesn't move with traffic. Remix's portability means you can pick the cheapest host, not the most-marketed one.
features / deep dives

Feature by feature

Six rows. The body describes how the feature works in 2026; the honest tradeoff is the part the docs won’t tell you. Skim the bold lines if you’re in a hurry.

01

Loaders & nested routes

data loading parallelized by route nesting

Each route exports a loader() function. Nested routes load their data in parallel rather than serially. Result: TTFB measurably better than the typical client-side waterfall pattern. Type-safe via useLoaderData<typeof loader>().

Honest tradeoff

Parallel-by-default is genuinely faster than the client-side fetch waterfall. The tradeoff is that you have to think about what loads at which nesting level, which is more upfront design than ad-hoc useEffect.

02

Actions & forms

mutations through progressive enhancement

Mutations happen via action() exports paired with <Form> components. Without JS, the form posts to the action handler and re-renders the page. With JS, the form upgrades to a fetcher and updates without a full reload. Same code, two execution paths.

Honest tradeoff

The form-first mental model is a step back from controlled-input patterns React devs are used to. Once you adapt, your forms work without JS — accessibility and resilience improve meaningfully.

03

Error boundaries

per-route ErrorBoundary

Each route can export an ErrorBoundarycomponent that renders if a loader, action, or render throws. Errors don’t take down the whole page — only the affected route segment. The non-affected nested routes continue working.

Honest tradeoff

More granular than React Suspense boundaries; less verbose than try/catch in every loader. Forces you to think about error UX up front, which is a feature.

04

Adapters

the deploy story

Adapters for Vercel, Cloudflare, Netlify, Node, Deno, Bun, and AWS Lambda. The Cloudflare adapter is mature and the Workers ecosystem fits Remix's philosophy. The Node adapter handles long-lived processes for self-hosted deploys.

Honest tradeoff

Adapter coverage is broader than Next.js's. The downside: each adapter has slightly different behavior — edge-runtime quirks differ from Node, etc.

05

Type safety

loader/action types flow to components

useLoaderData<typeof loader>() gives you the full return type of the loader, including type narrowing on conditional returns. Action returns flow to useActionData(). The type story is among the cleanest in the React metaframework space.

Honest tradeoff

Better TypeScript ergonomics than Next.js for data flow. The downside is the patterns are framework-specific — refactoring to a non-Remix codebase loses the type guarantees.

06

RR7 unification

Remix is now React Router 7's framework mode

As of November 2024, Remix v3 is React Router 7. The Remix experience lives as "framework mode"; React Router 7’s "data mode" is the older library-only experience. Same maintainers, same philosophy, just consolidated naming.

Honest tradeoff

The naming change confuses tutorials — material from before Nov 2024 calls it Remix. The actual code and patterns are stable; the rebranding is mostly a docs concern.

fit / use or skip

Use it for, skip it for

use / remix

Use Remix for…

  • Forms-and-mutations heavy apps — CRUD admin, dashboards, multi-step workflows. The Form/action pattern is the right abstraction.
  • Progressive enhancement matters — your product needs to work without JavaScript or with intermittent connectivity.
  • Portability is non-negotiable — you want a framework that runs on Vercel, Cloudflare, Node, Deno, Bun without lock-in.
  • Your team is React-shaped but doesn't want Next.js's strong opinions about caching, ISR, and platform-locked features.
  • Type safety from data layer to component is a workflow priority — Remix's loader/action types are best-in-class.
skip / remix

Skip Remix for…

  • You specifically want React Server Components — Remix doesn't have RSC and isn't planning a 1:1 implementation.
  • Your team is heavily invested in Next.js patterns and the migration cost outweighs Remix's benefits.
  • Bundle size is the deciding factor — SvelteKit ships less JS, Astro ships zero JS for static content.
  • AI-generated code is core to your workflow — Claude/Copilot are still better at Next.js than at Remix.
  • You're building a content-first site (blog, docs, marketing) — Astro is the better fit.
gotchas / observed

Gotchas worth knowing

Six pitfalls visible in public docs and community discussion. None will stop you shipping; all of them will cost you an afternoon if you don’t know about them.

  • Remix / naming

    Remix is React Router 7 now — half the docs are outdated

    Tutorials and Stack Overflow answers from before November 2024 refer to 'Remix' as a separate framework. Code patterns are still valid, but imports and CLI commands changed. When following older guides, mentally substitute 'react-router' for '@remix-run'.

  • Remix / loaders

    Loaders run on every navigation by default

    Unlike Next.js's RSC caching, Remix's loaders re-run on every navigation. For genuinely static data, you cache at the loader level (in-memory, KV, Cache API). The default 'always fresh' behavior is correct but expensive at scale without caching.

  • Remix / adapters

    Some Node-only APIs don't work on Cloudflare adapter

    The Cloudflare adapter doesn’t support Node’s fs, crypto, or other Node-specific modules without compatibility flags. Code that works in npm run dev can fail in deploy. Test the deploy adapter early and often.

  • Remix / forms

    Forms without enctype default to URL-encoded — files break silently

    A <Form> with file inputs needs encType="multipart/form-data". Default URL-encoded forms strip files, and the action receives empty file fields without error. The first time you upload a file and it’s mysteriously empty, this is why.

  • Remix / streaming

    defer() needs explicit Suspense boundaries

    defer() in a loader returns promises that resolve client-side, but components consuming them need <Suspense> boundaries. Forgetting Suspense gives you a runtime error rather than a silent fall-through.

  • Remix / sessions

    Cookie sessions have a 4KB limit

    Remix's cookie-based session storage works great for small auth state. Push more than 4KB into a session (large user object, complex flash data), and the cookie either truncates or breaks. Use a backed session storage for anything bigger than minimal auth state.

how it compares / different bets

How it compares

Three short framings. No clear-winner declarations — these are different bets, and the right pick is mostly a question of what you’re optimizing for. Linked comparison pages have the side-by-side detail.

Remix ━▶ Next.jsdifferent bets

Next.js bets on RSC + caching + Vercel polish. Remix bets on web platform primitives + portability + progressive enhancement. The two have converged enough in 2026 that the right pick is mostly a question of hosting target and team taste.

Pick Next.js for Vercel-deployed React-product apps where RSC and ISR are real workflow features. Pick Remix for portable React-product apps that lean on forms, want to run on Cloudflare, or value progressive enhancement.

Remix ━▶ SvelteKitdifferent bets

SvelteKit's compiler ships less JS than Remix at the same scope. SvelteKit's load() functions are similar in shape to Remix's loaders. Form actions vs SvelteKit form actions are also similar.

Pick Remix if your team is React-shaped and won't retrain. Pick SvelteKit if smaller bundles + a more cohesive single-language stack are worth the ecosystem switch.

Remix ━▶ Astrodifferent bets

Astro is content-first and ships zero JS by default. Remix is app-first and ships React. The frameworks barely overlap — if you have to choose between them, your product probably doesn't fit one of them at all.

Pick Astro for a content site with a few interactive pieces. Pick Remix for an app with a few content pieces. Many companies run both — Astro for marketing/docs, Remix for /app.