Lightweight React SSR

Everything you need.
Nothing you don't.

Familiar patterns from Next.js and Remix, without the complexity. A focused SSR framework that stays out of your way.

Streaming

Progressive loading, out of the box

defer() and <Await> stream data through React Suspense boundaries. No full-page spinners.

Routing

File-based, convention-driven

page.tsx, layout.tsx, head.tsx, loader.ts — patterns you already know.

State

Built-in store with SSR sync

defineStore() with Immer mutations and automatic server/client serialization. Zero extra deps.

No RSC

Regular React components

Standard components with data loaders. No mental model split between server and client.

Portable

Standard Express + Vite

No framework lock-in. Your server is Express, your build is Vite. Everything stays portable.

Head

Per-route meta tags

head.tsx files set <title> and meta tags per route. Nested heads merge automatically.

What is Pareto?

Pareto is an open-source React SSR framework built on Vite 7 and React 19. It provides streaming server-side rendering, file-based routing, and built-in state management — using standard React components and an Express server you fully control. No server components, no compiler magic, no platform lock-in.

By the numbers.

~5 KB Framework runtime shipped to the browser (gzipped), excluding React itself.

19 KB Total client bundle uncompressed. Router, hydration, streaming, and store.

6 Convention files to learn. page, layout, loader, head, not-found, route.

0 Custom webpack/turbopack config. Vite handles everything.

Why Pareto over Next.js or Remix?

Next.js and Remix are excellent frameworks. If you need their full feature set, use them. Pareto is for teams that want a lighter foundation — familiar conventions without the abstraction cost.

Standard React, no compiler magic

Next.js introduced React Server Components and a client/server split that requires "use client" directives and a new mental model. Remix stays closer to standard React but still couples routing to its own server runtime. Pareto uses plain React 19 components with explicit data loaders — no directives, no compiler boundaries, no hidden transforms.

You own the server

Your Pareto app runs on Express. You add middleware, mount routes, configure CORS — the same way you would in any Node.js project. There is no framework-controlled server runtime to work around, and no deployment platform assumed.

Vite all the way down

Next.js uses Webpack (or Turbopack). Remix recently adopted Vite but still maintains its own build layer. Pareto is built directly on Vite 7 — your config, your plugins, your dev server. Nothing is wrapped or abstracted away.

Deliberately smaller scope

No image optimization component, no font subsystem, no edge runtime, no middleware chain, no server actions. Pareto ships what an SSR framework needs — routing, streaming, state — and leaves the rest to the ecosystem you already know.

Simple by design

A streaming page with data loading — in 20 lines. No magic, no hidden abstractions.

app/home/page.tsx

import { defer } from '@paretojs/core'
import { Await, useLoaderData } from '@paretojs/core/client'
import { Suspense } from 'react'

export const loader = async () => {
  return defer({
    posts: fetchPosts(),
  })
}

export default function Home() {
  const { posts } = useLoaderData()

  return (
    <Suspense fallback={<PostsSkeleton />}>
      <Await resolve={posts}>
        {(data) => <PostList posts={data} />}
      </Await>
    </Suspense>
  )
}

Start building.

Get a streaming React app running in under 5 minutes. No boilerplate, no ceremony.

Get StartedRead the docs →