Best React Native Boilerplates with Expo Router in 2026

TL;DR

Expo Router is now the standard for production React Native apps in 2026 — file-based routing, universal links, and web support in a single codebase. The styling question is more interesting: Nativewind (Tailwind for React Native) wins on developer experience for web-first teams; Tamagui wins on performance and cross-platform component systems; Gluestack UI v2 (formerly NativeBase) wins on pre-built accessible components. Top boilerplates to consider: Expo Starter (full-featured, Supabase/Clerk), T3 Turbo (monorepo with Next.js web app), and ShipFlutter alternative picks for true native performance needs.

Key Takeaways

Expo Router v4 is the standard — file-based routing, universal deep links, web support, and typed routes are all stable and production-ready
Nativewind v4 works with Tailwind CSS v4 — developer experience is nearly identical to web Tailwind; the learning curve is minimal for teams already using Tailwind
Tamagui outperforms both on runtime — compile-time style optimization produces smaller, faster apps, especially important on Android
Most boilerplates ship Nativewind — it's the path of least resistance for web developers entering React Native
Cross-platform monorepo (Next.js + Expo) is the modern pattern — T3 Turbo and Expo-Next.js starters let you share code between web and mobile
Auth is the hard part — Clerk, Supabase Auth, and Better Auth all have Expo support, but session handling in deep links and background refresh requires careful setup

Why Expo Router Changed Everything

Before Expo Router, React Native navigation was a solved problem with poor ergonomics. React Navigation required imperative navigation.navigate('ScreenName', { params }) calls, manual deep link configuration, and separate web handling.

Expo Router brought the Next.js file-system routing model to React Native:

app/
  (tabs)/
    index.tsx        ← Home tab
    profile.tsx      ← Profile tab
  auth/
    login.tsx        ← /auth/login
    register.tsx     ← /auth/register
  [userId].tsx       ← /user/123 (dynamic route)

Every route is a file. Deep links work automatically. Web URLs match app routes. Typed routes (Expo Router v3+) give you TypeScript autocomplete for navigation targets.

The result: a React Native app with file-based routing, automatic deep link handling, universal web support (via React Native Web), and shared layouts — all without configuration.

Expo Router v4 (current) adds:

React 19 support with concurrent rendering
Expo Modules API for native code without Objective-C/Swift boilerplate
Build profiles for managed vs bare workflow in a single project
Better web performance with static routes and reduced bundle size

For SaaS mobile apps, the managed workflow (no native build required) + Expo Router is now the dominant pattern.

The Styling Decision: Nativewind vs Tamagui vs Gluestack

Styling in React Native is fundamentally different from web — no CSS, only a subset of styles, and performance characteristics that matter more at 60/120fps on a phone than in a browser. Three libraries dominate the modern boilerplate ecosystem.

Nativewind v4: Tailwind for React Native

Nativewind translates Tailwind CSS classes to React Native StyleSheet at build time. The developer experience is nearly identical to web:

// Web (shadcn/ui component)
<div className="flex items-center gap-4 rounded-lg bg-card p-4">

// React Native (Nativewind)
<View className="flex-row items-center gap-4 rounded-lg bg-card p-4">

The mental model is the same. For full-stack teams building Next.js + Expo, Nativewind means writing one styling language across both codebases.

Nativewind v4 improvements (2024):

Tailwind CSS v4 compatibility — uses Vite plugin, faster compilation
CSS variables support — theme tokens work in React Native, enabling dark mode via CSS variables instead of conditional logic
Better web support — the gap between React Native Web and true web styling is significantly narrowed

Where Nativewind excels:

Teams coming from a web/Next.js background
Projects that share design tokens with a web app
Rapid prototyping where Tailwind's utility-first approach speeds development

Where Nativewind struggles:

Complex animations requiring native driver
Performance on low-end Android devices (the class transformation adds overhead)
Custom native components that need StyleSheet APIs directly

Tamagui: Cross-Platform Component System

Tamagui is both a component library and a styling system. It uses a compiler that converts Tamagui component props to platform-optimized styles at build time — producing native StyleSheet calls on iOS/Android and CSS on web.

import { Button, Stack, Text } from 'tamagui'

export function Card({ title, children }) {
  return (
    <Stack padding="$4" borderRadius="$3" backgroundColor="$backgroundStrong">
      <Text fontSize="$6" fontWeight="bold">{title}</Text>
      {children}
    </Stack>
  )
}

The $4, $3, $backgroundStrong tokens resolve to different values on iOS, Android, and web — but you write them once. No conditional styling, no platform checks.

Tamagui's key advantages:

Compile-time optimization. Tamagui's compiler extracts static props at build time, converting them to atomic CSS or StyleSheet entries rather than computing them at runtime. On Android, this can produce 30–50% faster initial renders compared to runtime styling systems.

Theming system. Tamagui's theme system supports light/dark mode, brand variants, and component-level overrides with a type-safe token system that catches theming mistakes at compile time.

Pre-built components. Tamagui ships an optional @tamagui/core component set (Button, Input, Sheet, Dialog, Select) that are cross-platform and production-quality. You can use just the styling engine or the full component library.

Where Tamagui excels:

Apps that need maximum performance on mid-range Android
Cross-platform components shared across web and mobile
Teams that want a complete design system, not just utilities

Where Tamagui is harder:

Steeper learning curve than Nativewind for web developers
Compiler setup adds build complexity
Smaller community than Nativewind; fewer examples and tutorials

Gluestack UI v2: Accessible Component First

Gluestack UI v2 (the successor to NativeBase) takes the component-first approach. Rather than a styling system, it provides pre-built accessible components with headless logic that works on React Native and web:

import { Button, ButtonText, Input, InputField } from '@gluestack-ui/themed'

<Button variant="solid" action="primary">
  <ButtonText>Get Started</ButtonText>
</Button>

Gluestack v2 components are:

Accessible — ARIA attributes, keyboard navigation, screen reader support handled
Cross-platform — same component API on iOS, Android, and web
Customizable — Style overrides use a sx prop or Tailwind (Gluestack supports Nativewind alongside its own styling)

What the ecosystem includes:

40+ pre-built components covering forms, navigation, overlays, and feedback
Form components with built-in React Hook Form integration
Authentication flow screens (Login, Register, OTP)
Dashboard layout patterns

Where Gluestack excels:

Teams that want components rather than a styling system
Apps where accessibility is a hard requirement
Projects that want NativeBase's familiar API without its legacy v4 tech debt

Top React Native Boilerplates with Expo Router

1. Expo Starter (Supabase + Clerk)

Stack: Expo Router v4 · Supabase · Clerk · Nativewind · TypeScript Price: Free / MIT Best for: Full-stack mobile SaaS with shared auth across web and mobile

The community standard for Expo + Supabase boilerplates. Includes pre-configured Clerk auth with biometric support, Supabase real-time subscriptions, push notifications via Expo Notifications, and a tab-based navigation structure.

Key patterns it establishes:

Clerk + Expo — session management with deep link callback handling for OAuth
Supabase real-time — subscribing to Postgres changes in React Native
Nativewind — consistent Tailwind styling between web (if paired with Next.js) and mobile
EAS Build profiles — separate development, preview, and production build configurations

2. T3 Turbo — Monorepo Web + Mobile

Stack: Turborepo · Next.js · Expo Router · tRPC · Prisma · NextAuth Price: Free / MIT GitHub: github.com/t3-oss/create-t3-turbo Best for: Teams building a SaaS with both web and mobile apps sharing a backend

T3 Turbo extends the T3 Stack into a Turborepo monorepo that shares tRPC routers, Prisma schema, and TypeScript types between a Next.js web app and an Expo mobile app. Both apps call the same API layer — no REST API duplication, no type drift between platforms.

The monorepo structure:

apps/
  nextjs/        ← Next.js web app
  expo/          ← Expo React Native app
packages/
  api/           ← tRPC routers (shared)
  db/            ← Prisma schema (shared)
  validators/    ← Zod schemas (shared)
  ui/            ← React Native Paper / Gluestack components

This is the go-to boilerplate for indie SaaS builders who want iOS + Android + web without running two separate codebases. The tradeoff: Turborepo monorepo setup adds initial complexity, and native app store deployment (via EAS) requires separate configuration.

3. Expo + Supabase + Nativewind Starter

Stack: Expo Router v4 · Supabase · Nativewind v4 · TypeScript Price: Free / MIT Best for: Mobile-first SaaS, data-heavy apps, real-time features

A leaner alternative to the full Clerk version — uses Supabase's built-in auth (email, OAuth, magic link) directly rather than Clerk. Simpler dependency tree, slightly less auth flexibility.

Includes pre-built:

Supabase auth screens (login, register, forgot password) styled with Nativewind
Row-level security patterns for user-scoped data
Dark mode via CSS variables + Nativewind
Splash screen and app icon configuration via Expo

4. Expo + Tamagui SaaS Starter

Stack: Expo Router v4 · Tamagui · Supabase or Convex · TypeScript Price: Free / MIT Best for: Performance-critical apps, teams building a consistent design system

Several community starters on GitHub pair Expo Router with Tamagui for cross-platform component development. The official Tamagui docs include an Expo starter configuration.

Best approach: Use the Tamagui Create App CLI (npm create tamagui@latest) and select the Expo + Next.js template — it gives you a monorepo with shared Tamagui components across both platforms.

The Auth Deep-Link Problem (and How Boilerplates Solve It)

The hardest part of React Native auth isn't the login form — it's handling the redirect after OAuth (Google, GitHub, Apple) in a production app.

On web, OAuth redirects to a URL (/auth/callback). On mobile, the OS intercepts a deep link (myapp://auth/callback) and opens the app. The boilerplate needs to:

Register a URL scheme with Expo (myapp://)
Configure the auth provider's allowed redirect URLs
Handle the link in the app and exchange the auth code for a session
Refresh tokens on app foreground without user interaction

How top boilerplates handle it:

Auth Provider	Expo Support	Boilerplate Approach
Clerk	✅ Official SDK	`@clerk/expo` handles all redirect logic
Supabase Auth	✅ Official	`supabase.auth.getSession()` on AppState change
Better Auth	✅ Via expo adapter	Manual deep link handling in `expo-linking`
NextAuth	⚠️ Web-only	Requires separate mobile auth or API proxy

Most boilerplates recommend Clerk for Expo because the @clerk/expo package handles all the OAuth redirect complexity — you configure URL schemes once and Clerk manages the rest.

Choosing the Right Boilerplate

You need a shared web + mobile codebase: T3 Turbo (Next.js + Expo, shared tRPC)

You need mobile-first with full Supabase integration: Expo Starter (Supabase + Clerk + Nativewind)

You prioritize performance on mid-range Android: Expo + Tamagui starter

You want pre-built screens (auth, settings, onboarding): Gluestack UI-based starters or Expo + SaaS UI

You're an indie hacker launching fast: Expo + Convex + Clerk starter (minimizes infrastructure decisions)

Methodology

Boilerplates surveyed: 10+ Expo Router starters on GitHub and npm (March 2026)
Framework versions: Expo Router v4.x, Nativewind v4.x, Tamagui v1.x, Gluestack UI v2.x
Sources: Expo official docs, Tamagui docs, Nativewind docs, T3 Turbo GitHub, community forum posts

Browse all React Native and Expo boilerplates on StarterPick — filter by auth, database, and styling library.

Best React Native Expo Router Boilerplates 2026