Best T3 Stack Variations and Forks 2026

Q: When to Use T3 vs Other Starters?

T3 Stack is best when: TypeScript end-to-end type safety is a priority tRPC's auto-generated client types save your team hours of API maintenance You want fine-grained control over each dependency Community support matters more than paid support Consider ShipFast or Makerkit instead when: Billing and subscription UI needs to work from day one Team management is required in the first month Email templates and transactional flows need pre-configuration You want video documentation and creator supp

TL;DR

The T3 Stack spawned the richest TypeScript boilerplate ecosystem in 2026. The core create-t3-app remains the best starting point. T3 Turbo extends it for web+mobile monorepos. T3+Drizzle is now the preferred stack for edge deployments. T3+Lucia gives full session control for custom auth. T3+Clerk is the fastest path to a polished auth UI. Choose based on your auth complexity, deployment target, and whether you need mobile.

The T3 Stack Ecosystem

Theo Browne's T3 Stack changed how JavaScript developers approach full-stack TypeScript apps. The core formula — Next.js + TypeScript + Tailwind + tRPC + Prisma + NextAuth — spawned an ecosystem of variations addressing different needs.

In 2026, T3 has evolved. The recommended stack has shifted toward Drizzle (replacing Prisma for edge deployments), Lucia v3 or Clerk (replacing NextAuth for custom auth), and server components (augmenting tRPC for non-interactive data fetching). The community has followed.

Quick Comparison

Variation	Auth	ORM	Monorepo	Edge	Best For
create-t3-app	Auth.js	Prisma	❌	❌	Standard SaaS
T3 Turbo	Auth.js	Prisma	✅ Turborepo	❌	Web + Mobile
T3 + Drizzle	Auth.js	Drizzle	❌	✅	Edge SaaS
T3 + Lucia	Lucia	Drizzle	❌	✅	Custom auth
T3 + Clerk	Clerk	Prisma/Drizzle	❌	✅	Fastest auth UI

The Variations

create-t3-app — The Original

Price: Free | Creator: Theo Browne / T3 OSS | GitHub Stars: 25k+

The best starting point for new T3 apps. Modular — choose which components you want. Each combination is pre-configured and tested against each other. Running npm create t3-app@latest gives you an interactive CLI that asks which features you need.

npm create t3-app@latest my-saas
# ✔ Will you be using TypeScript or JavaScript? → TypeScript
# ✔ Will you be using Tailwind CSS? → Yes
# ✔ Will you be using tRPC? → Yes
# ✔ What authentication provider? → NextAuth.js
# ✔ What database ORM? → Prisma
# ✔ Would you like to use Next.js App Router? → Yes
# ✔ What database provider? → PostgreSQL

The generated project is a production-ready starting point with typed database access (Prisma), end-to-end type-safe API (tRPC), session authentication (Auth.js), and styling (Tailwind CSS).

What you add after generation:

Stripe billing (~6-8 hours with webhook handling)
Resend email (~2 hours with React Email templates)
Teams/organizations (~1-2 weeks)
Landing page and marketing site

Best for: Developers new to T3 who want a guided, opinionated TypeScript setup.

T3 Turbo — Monorepo Edition

Price: Free | Creator: Julius Marminge | GitHub Stars: 6k+

create-t3-app extended to a Turborepo monorepo. Shares the tRPC API router, Prisma database schema, and auth configuration between a Next.js web app and an Expo React Native mobile app — both in the same repository.

npm create t3-turbo@latest my-saas
cd my-saas && pnpm install
pnpm dev  # starts web and mobile concurrently

Repository structure:

apps/
├── nextjs/        # Web app (Next.js + tRPC client)
└── expo/          # Mobile app (Expo + tRPC client)
packages/
├── api/           # tRPC router — shared by web + mobile
├── auth/          # Auth.js configuration
├── db/            # Prisma schema and client
├── ui/            # Shared React components
└── validators/    # Zod schemas (shared validation)
tooling/
├── eslint/        # Shared ESLint config
├── typescript/    # Shared tsconfig
└── tailwind/      # Shared Tailwind config

The key value: when you add a field to your Prisma schema, TypeScript errors appear in both the web app and mobile app simultaneously. Change the tRPC API, both clients break at compile time. This forces atomic updates and eliminates the "works on web, forgot to update mobile" bug class.

Best for: Teams building both a web app and mobile app sharing business logic from day one.

T3 + Drizzle — The Edge Stack

Price: Free | Creator: Community forks

The T3 stack with Drizzle ORM replacing Prisma. Drizzle is preferred for edge runtimes because it has a much smaller bundle size, supports Cloudflare D1, PlanetScale serverless, and other edge databases natively, and uses a SQL-like query API that maps directly to what SQL developers know.

// Drizzle schema (type-safe, SQL-like)
import { pgTable, varchar, timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: varchar('id', { length: 255 }).notNull().primaryKey(),
  name: varchar('name', { length: 255 }),
  email: varchar('email', { length: 255 }).notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

// Type-inferred from schema
export type User = typeof users.$inferSelect;
export type NewUser = typeof users.$inferInsert;

Drizzle vs Prisma query comparison:

// Prisma
const user = await prisma.user.findMany({
  where: { email: { contains: '@company.com' } },
  include: { team: true },
});

// Drizzle (SQL-like — familiar to database developers)
const user = await db
  .select()
  .from(users)
  .where(like(users.email, '%@company.com%'))
  .leftJoin(teams, eq(users.teamId, teams.id));

Bundle size comparison: Prisma generates a large client (~3MB). Drizzle is ~35KB — a critical difference for edge functions where cold start time matters.

Best for: Edge deployments (Cloudflare Workers, Vercel Edge Functions), smaller bundle requirements, SQL-fluent developers.

T3 + Lucia — Custom Auth Control

Price: Free | Creator: Community forks

NextAuth (now Auth.js) can be heavy and opinionated. Lucia v3 provides a lightweight auth library that gives you full control over session management without hiding the implementation behind a black box.

import { Lucia } from 'lucia';
import { DrizzlePostgreSQLAdapter } from '@lucia-auth/adapter-drizzle';
import { db } from './db';
import { sessions, users } from './db/schema';

const adapter = new DrizzlePostgreSQLAdapter(db, sessions, users);

export const lucia = new Lucia(adapter, {
  sessionCookie: {
    attributes: { secure: process.env.NODE_ENV === 'production' },
  },
  getUserAttributes: (attributes) => ({
    email: attributes.email,
    name: attributes.name,
    role: attributes.role,
  }),
});

Creating a session after login:

// server action or tRPC mutation
const session = await lucia.createSession(userId, {});
const sessionCookie = lucia.createSessionCookie(session.id);

cookies().set(
  sessionCookie.name,
  sessionCookie.value,
  sessionCookie.attributes
);

Why Lucia over Auth.js:

Complete control over session storage and expiry
Custom user attributes without callback configuration
No magic — you can read the entire auth flow in your codebase
Supports non-standard auth flows (device auth, passkeys, magic links)

Best for: Apps that need custom auth flows, fine-grained session control, or non-standard auth providers.

T3 + Clerk — Fastest Auth UI

Price: Free tier + $25/month Pro | Creator: Clerk

Auth.js requires building your own login/signup pages. Clerk provides pre-built, accessible, customizable auth UI components — login, signup, user profile, organization management — with no design work required.

// app/layout.tsx — wrap with Clerk provider
import { ClerkProvider } from '@clerk/nextjs';

export default function RootLayout({ children }) {
  return (
    <ClerkProvider>
      <html><body>{children}</body></html>
    </ClerkProvider>
  );
}

// app/sign-in/[[...sign-in]]/page.tsx
import { SignIn } from '@clerk/nextjs';

export default function SignInPage() {
  return <SignIn />;  // Pre-built, polished auth UI
}

// Protect a route
import { auth } from '@clerk/nextjs/server';

export default async function Dashboard() {
  const { userId } = await auth();
  if (!userId) redirect('/sign-in');
  // ...
}

Clerk's advantages over Auth.js:

Pre-built UI components (login, signup, user profile, org switcher)
Multi-factor authentication out of the box
Organization management (team features) without code
Webhooks for user events
Device session management

Trade-off: Clerk charges $0.02/MAU after the first 10,000. At 50,000 MAU, you're paying $800/month. For most early-stage SaaS, the free tier is sufficient.

Best for: Founders who want auth fully handled and are comfortable with vendor dependency.

T3 Stack Configuration Matrix

Use Case	Auth	ORM	UI	Notes
Standard SaaS	Auth.js	Prisma	shadcn/ui	Best default
Edge SaaS	Lucia	Drizzle	shadcn/ui	Cloudflare Workers
Web + Mobile	Auth.js	Prisma	Tamagui	T3 Turbo
AI SaaS	Clerk	Drizzle	shadcn/ui	Vercel AI SDK
Fast launch	Clerk	Prisma	shadcn/ui	Fastest auth setup
Custom enterprise	Lucia	Drizzle	shadcn/ui	Full control

Deploying T3 Stack Variations

Each variation has different deployment constraints:

create-t3-app with Prisma: Deploy to Vercel (recommended) or any Node.js host. Prisma's query engine doesn't support edge runtimes — keep API routes in Node.js serverless functions.

T3 + Drizzle: Supports Vercel Edge Functions and Cloudflare Workers. Drizzle's HTTP-based database clients (Neon serverless, PlanetScale serverless) work in edge environments.

T3 Turbo: Web app deploys to Vercel. Mobile app deploys via Expo (App Store / Google Play). Backend is shared between both.

# T3 Turbo: deploy web app to Vercel
cd apps/nextjs
vercel deploy

# T3 Turbo: build mobile app
cd apps/expo
eas build --platform all

Community Resources by Variation

The T3 Stack's greatest advantage is community. For any problem you encounter, it's been solved publicly:

create-t3-app: T3 Discord (15k+ members), extensive YouTube tutorials from Theo and community creators, GitHub Discussions with searchable solutions
T3 Turbo: Smaller community but growing, Julius Marminge's Discord, monorepo-specific Q&A
T3 + Drizzle: Drizzle Discord + T3 Discord intersection, strong documentation from Drizzle team
T3 + Clerk: Clerk's own Discord with dedicated support, extensive video docs for each component

When to Use T3 vs Other Starters

T3 Stack is best when:

TypeScript end-to-end type safety is a priority
tRPC's auto-generated client types save your team hours of API maintenance
You want fine-grained control over each dependency
Community support matters more than paid support

Consider ShipFast or Makerkit instead when:

Billing and subscription UI needs to work from day one
Team management is required in the first month
Email templates and transactional flows need pre-configuration
You want video documentation and creator support

Consider Supastarter instead when:

You need a production-grade monorepo with isolated packages
Multi-framework (Next.js + Nuxt) is a potential requirement
Provider-swappable architecture (billing, auth, email) is valuable

Key Takeaways

create-t3-app remains the best TypeScript full-stack starting point — 25k+ stars, massive community, modular selection of tRPC/Prisma/Auth.js
T3 Turbo is the definitive web + mobile monorepo starter — shared tRPC types between Next.js and Expo with zero code duplication
T3 + Drizzle is the right choice for edge deployments — Drizzle's HTTP database clients support Vercel Edge and Cloudflare Workers
T3 + Clerk saves 1-2 days of auth UI work: pre-built sign-in, sign-up, user profile, and organization flows, plus webhooks for user events
T3 + Lucia is best when you need session control that Auth.js doesn't provide — custom token rotation, device management, or non-standard OAuth flows
The T3 ecosystem's community resources (Discord, YouTube, GitHub Discussions) mean most problems are already documented publicly — a meaningful advantage over smaller boilerplates

How to Evaluate T3 Stack Variations

The T3 ecosystem's openness is its strength and its complexity. Before settling on a variation, evaluate:

Community activity for the specific variation. create-t3-app has 25k+ stars and thousands of contributors. T3 + Lucia or T3 + Drizzle community forks have dozens to hundreds of stars and often a single maintainer. For the base T3 Stack, community support is excellent. For community forks, verify that the specific combination you need has active maintenance and recent commits.

Auth migration path. Switching auth providers after launch is painful. T3 + Auth.js, T3 + Clerk, and T3 + Lucia have meaningfully different session shapes, middleware implementations, and user data models. Choose your auth strategy based on where you expect to be at 10,000 users, not at 10 users. Clerk's $0.02/MAU pricing is negligible at 100 users and significant at 50,000.

ORM compatibility with your deployment target. T3 + Prisma deploys correctly to Node.js serverless functions (Vercel, AWS Lambda) but requires workarounds for edge functions (Prisma's query engine binary doesn't run in edge runtimes). T3 + Drizzle's HTTP-based database clients work natively in edge environments. Know your deployment target before choosing your ORM.

Billing integration. The base T3 Stack includes no billing. Every variation adds billing manually — there's no T3 + Stripe variation with the same community maturity as the base stack. Factor in the time to add Stripe (6-8 hours for correct webhook handling, subscription creation, and customer portal) regardless of which T3 variation you choose.

What These T3 Variations Have in Common

Despite the variations in auth, ORM, and deployment target, all T3 Stack configurations share the properties that make T3 compelling in 2026:

Type safety as the organizing principle. tRPC's end-to-end types are the distinctive feature. A tRPC procedure defined on the server is typed on the client without a code generation step or manual type duplication. Change a procedure's return type, and TypeScript errors appear on every client call site immediately. This eliminates an entire class of frontend-backend contract bugs.

Next.js App Router as the framework. All T3 variations have moved to App Router. Server components for initial data loading, route handlers for API endpoints, server actions for mutations — the T3 community has adapted these patterns and produced extensive tutorials and examples.

shadcn/ui as the component library. Across all T3 variations, shadcn/ui is the standard UI foundation. The CVA-based component system, Radix UI accessibility primitives, and Tailwind v4 styling are assumed by essentially all T3 tutorials and example codebases.

Zod as the validation layer. Input validation via Zod schemas is universal across T3. tRPC procedures accept Zod schemas as input validators. Auth.js callbacks validate session shapes with Zod. Server actions validate form data with Zod. The consistent use of Zod across the stack means validation errors are typed and consistent everywhere.

For the broader landscape of TypeScript SaaS boilerplates including commercial options that build on T3 patterns, see the best SaaS boilerplates guide. For free boilerplates in the T3 ecosystem and beyond, the free open-source SaaS boilerplates guide covers the best no-cost foundations. For T3 Turbo specifically — the monorepo variant — see the best monorepo boilerplates guide.

The T3 Stack's enduring strength is community. When you encounter a problem — Prisma connection pooling on serverless, Clerk organization webhooks not triggering, tRPC middleware that affects only specific procedures — the T3 Discord, Theo's YouTube channel, and GitHub Discussions almost always have a documented solution. This community depth is worth more than any technical feature comparison between T3 variations. The specific variation you choose matters less than starting with the stack that has the most people willing to help you debug it.

Compare T3 variations and other TypeScript starters in the StarterPick directory.

See our guide to monorepo boilerplates — how T3 Turbo, Supastarter, and Bedrock structure their Turborepo.

Browse all free open-source SaaS boilerplates — T3 Stack is the starting point for most free starters.

The SaaS Boilerplate Matrix (Free PDF)