Remix v3: The Bold React Breakup That's Reshaping Web Development

Why Remix's web standards approach reveals what's wrong with modern React development

The JavaScript framework landscape just experienced an earthquake. On May 26, 2025, the Remix team dropped a bombshell that left the React community divided: Remix v3 is completely abandoning React in favor of a Preact fork and embracing an entirely new development philosophy.

But here's what most analysis missed: This move exposes fundamental weaknesses in how we've been building web apps with React - and why the current "just use Next.js" advice might be steering you wrong.

As a frontend architect who's been building large-scale applications for over a decade, I've witnessed many framework transitions. But this? This isn't just about Remix. It's about whether we're building the web right.

🎯 What Actually Happened?

Let me break down the timeline and what it reveals about our ecosystem:

The Setup (2024)

• Remix v2 merged into React Router v7
• React Router now powers 11 million GitHub projects and applications at Shopify, X.com, GitHub, ChatGPT, Linear, and T3Chat
• Community thought this was the end of Remix as a separate entity
• The team announced Remix would "take a nap"

The Plot Twist (May 2025)

• Remix team announces "Wake up, Remix!"
• Remix v3 will fork Preact instead of using React
• Six revolutionary principles that challenge everything about modern web development
• Hints at reviving Reach UI: "time to wake up Reach UI too!"

// This is NOT happening anymore
import { useLoaderData } from '@remix-run/react'

// This is the new reality
import { useLoaderData } from '@remix-run/preact' // Hypothetical

But the real story isn't about Preact vs React. It's about web standards vs framework abstractions.

🏗️ The Six Pillars That Shame Modern React Development

The team outlined six core principles that inadvertently expose what's wrong with most React apps:

1. Model-First Development 🤖

What it means: Code that both humans AND AI can understand

While we've been writing clever abstractions, Remix v3 optimizes for clarity:

// Typical React component (clever but opaque)
const useUserData = (id) => {
  const [state, setState] = useState({ user: null, loading: true })

  useEffect(() => {
    fetchUser(id).then(user => setState({ user, loading: false }))
  }, [id])

  return state
}

// AI-Optimized approach (Remix v3 philosophy)
const userOperations = {
  load: {
    intent: "Fetch user data by ID",
    params: { userId: "string" },
    async execute({ userId }) {
      return await userService.findById(userId)
    }
  },

  update: {
    intent: "Update user profile with validation", 
    params: { userId: "string", updates: "object" },
    async execute({ userId, updates }) {
      return await userService.update(userId, updates)
    }
  }
}

2. Build on Web APIs 🌐

The wake-up call: We've been reinventing perfectly good browser features

This principle makes most React patterns look ridiculous:

// What we've been doing (React abstraction)
const [data, setData] = useState(null)
useEffect(() => {
  fetch('/api/data').then(r => r.json()).then(setData)
}, [])

// What browsers already provide (Web Standards)
<form method="post" action="/api/data">
  <input name="email" type="email" required />
  <button type="submit">Submit</button>
</form>
// This WORKS without JavaScript!

3. Religiously Runtime ⚡

The build tool rebellion: What if we didn't need webpack at all?

# Current React development
npm run build
[webpack processing...]
[babel transforming...]
[typescript compiling...]
[optimization passes...]
# 2-3 minutes later...

# Remix v3 promise
npm start
# Server starts immediately, no build step

4. Avoid Dependencies 🚫

The nuclear option: React itself is a dependency problem

This is the most controversial principle - and it's not wrong.

5. Demand Composition 🧩

Modular reality: Single-purpose, replaceable modules

6. Distribute Cohesively 📦

Developer experience: Unified tooling without the complexity

🛠️ Technical Deep Dive: What We've Been Doing Wrong

The Progressive Enhancement Reality Check

Here's the uncomfortable truth about most React apps:

// React Router v7 (ex-Remix) - Works without JavaScript
export default function ContactForm() {
  return (
    <Form method="post" action="/contact">
      <input name="email" type="email" required />
      <textarea name="message" required />
      <button type="submit">Send Message</button>
    </Form>
  )
}
// Users can submit forms even if JS fails to load!

// Typical Next.js - Breaks without JavaScript  
export default function ContactForm() {
  const [submitting, setSubmitting] = useState(false)

  const handleSubmit = async (e) => {
    e.preventDefault() // This breaks everything without JS
    setSubmitting(true)
    const response = await fetch('/api/contact', {
      method: 'POST',
      body: JSON.stringify(data)
    })
  }

  return <form onSubmit={handleSubmit}>...</form>
  // If JS fails, form is completely broken
}

The Data Loading Waterfall Problem

Most React apps suffer from this pattern:

// React component waterfall hell
function UserProfile({ userId }) {
  const [user, setUser] = useState(null)
  const [posts, setPosts] = useState(null)
  const [followers, setFollowers] = useState(null)

  useEffect(() => {
    // Load user first
    getUser(userId).then(user => {
      setUser(user)
      // Then load posts (waterfall!)
      getUserPosts(user.id).then(posts => {
        setPosts(posts)
        // Then load followers (another waterfall!)
        getFollowers(user.id).then(setFollowers)
      })
    })
  }, [userId])

  // Show loading spinners for 2-3 seconds
  if (!user) return <LoadingSpinner />
  if (!posts) return <LoadingSpinner />
  if (!followers) return <LoadingSpinner />
}

// React Router v7 - Parallel paradise
export async function loader({ params }) {
  // All load in parallel automatically!
  const [user, posts, followers] = await Promise.all([
    getUser(params.userId),
    getUserPosts(params.userId), 
    getFollowers(params.userId)
  ])

  return json({ user, posts, followers })
}

export default function UserProfile() {
  const { user, posts, followers } = useLoaderData()
  // No loading states needed - data is already here!
  return <div>...</div>
}

First-Class Database Integration

Remix v3 will include built-in database drivers:

// No more ORM dependencies
import { db } from '@remix-run/database'

export async function loader({ params }) {
  // Direct database integration
  const user = await db.users.findById(params.id)
  return json({ user })
}

export async function action({ request }) {
  const formData = await request.formData()
  const user = await db.users.create({
    name: formData.get('name'),
    email: formData.get('email')
  })
  return redirect(`/users/${user.id}`)
}

Reach UI Revival

The announcement hints at bringing back Reach UI:

// Integrated, accessible component library
import { Dialog, Button, Form } from '@remix-run/ui'

export default function UserProfile() {
  return (
    <Form method="post">
      <Dialog>
        <Dialog.Content>
          <h2>Edit Profile</h2>
          <Button type="submit">Save Changes</Button>
        </Dialog.Content>
      </Dialog>
    </Form>
  )
}

📊 The Honest Framework Comparison

Performance Reality Check

Next.js 15.3 with Turbopack:

• 28% faster builds on 4 cores
• 83% faster builds on 30 cores
• Still requires complex build process
• Optimized mainly for Vercel deployment

React Router v7 (proven Remix approach):

• Vite-based fast development
• Parallel data loading eliminates waterfalls
• Works on any platform
• Progressive enhancement by default

Remix v3 Promise:

• Zero build time (runtime-only)
• 3KB Preact base vs React's footprint
• Edge-first for "disgustingly fast" performance
• AI-optimized architecture

🗣️ Community Reactions: The Real Talk

The announcement has sparked intense debates. Here are the unfiltered reactions:

😤 The Frustrated Voices

On branding confusion:

"The fact that they're re-using the Remix brand and calling it Remix V3 while also dropping React in favor of a fork of Preact, amongst other major changes" creates substantial confusion.

On framework fatigue:

"I have never, in my entire career, seen a library change (in large, completely non-backward-compatible ways) as many times as React Router" - Hacker News user

On trust issues:

"while they are undoubtedly intelligent individuals, their approach to marketing and brand management has consistently fallen short" - Reddit developer

🚀 The Visionary Supporters

Jan Hesters (LinkedIn):

"This could be the next big thing... The focus on composition comes from real, hard-earned experience. It's a principle every software company can benefit from. And the focus on AI-first development feels like a smart bet on the future"

Tanner Linsley (React Query creator):

"I think it's great that they're going out on a limb here. They no longer need to worry about money (thanks Shopify) and they're attempting to rethink fundamentals... Only good things can come from research like this, regardless if it succeeds or not"

🤷 The Confused Middle

Reddit developer:

"it's been a weird journey with Remix it started as a wrapper for React Router that was meant to be a template you would pay for it then slowly became a framework and it's since spiraled into all sorts of different things"

🏢 Enterprise Reality Check

Current State (React Router v7)

• 99% of Shopify projects use React Router
• 11 million GitHub projects depend on it
• Major companies: X.com, GitHub, ChatGPT, Linear, T3Chat

Migration Strategies by Company Size

Startups & Small Teams:

• Should seriously consider React Router v7 over Next.js
• Can benefit from progressive enhancement
• Value simplicity over vendor ecosystems

Mid-Size Companies:

• Migrating to React Router v7 from Remix v2
• Discovering Next.js limitations with scale
• Balancing innovation with reliable patterns

Enterprise Organizations:

• Recognizing vendor lock-in risks with Next.js
• React Router v7 offers platform independence
• Avoiding Remix v3 until proven at scale

💡 Why React Router v7 (ex-Remix) is Superior

Let me be brutally honest about why the Remix approach beats Next.js for most web applications:

✅ Progressive Enhancement That Actually Works

// React Router v7 approach
export default function NewsletterSignup() {
  return (
    <Form method="post" action="/newsletter">
      <input name="email" type="email" required />
      <button type="submit">Subscribe</button>
    </Form>
  )
}
// Works perfectly even when JavaScript fails
// Enhanced with JS when available
// Accessible by default

// Next.js typical pattern
export default function NewsletterSignup() {
  const [email, setEmail] = useState('')
  const [loading, setLoading] = useState(false)

  const handleSubmit = async (e) => {
    e.preventDefault() // Breaks without JS!
    setLoading(true)
    await fetch('/api/newsletter', { 
      method: 'POST',
      body: JSON.stringify({ email })
    })
    setLoading(false)
  }

  return (
    <form onSubmit={handleSubmit}>
      <input 
        value={email} 
        onChange={e => setEmail(e.target.value)}
        type="email" 
      />
      <button disabled={loading}>
        {loading ? 'Loading...' : 'Subscribe'}
      </button>
    </form>
  )
  // Completely broken without JavaScript
  // More code for worse functionality
}

✅ No Vendor Lock-in

• React Router v7: Deploy anywhere (AWS, Google Cloud, Netlify, Cloudflare, your own servers)
• Next.js: Optimized for Vercel, suboptimal performance elsewhere

✅ Parallel Data Loading by Default

React Router v7 eliminates the request waterfalls that plague most React apps.

✅ Web Standards Foundation

Building on web standards means your skills transfer and your apps are future-proof.

🎯 Corrected Framework Recommendations

Honest Decision Matrix

The Uncomfortable Truth About Next.js

Next.js is great for:

• Static marketing sites
• Content-heavy blogs
• Projects already locked into Vercel

Next.js struggles with:

• Progressive enhancement
• Platform-independent deployment
• Avoiding request waterfalls
• Working without JavaScript

React Router v7 excels at:

• True web applications
• Progressive enhancement
• Platform independence
• Parallel data loading
• Web standards compliance

🚀 Updated Practical Recommendations

For Individual Developers

• Learn React Router v7 (the actual future of web dev)
• Study web standards and progressive enhancement
• Experiment with Remix v3 principles
• Question framework abstractions that reinvent browser features

For Teams

# Honest immediate actions
1. Choose React Router v7 for new web applications
2. Migrate existing Remix to React Router v7 
3. Use Next.js ONLY for static/marketing sites
4. Plan for platform-independent deployment

For Architects

• Prioritize web standards over framework magic
• Design for progressive enhancement first
• Avoid vendor lock-in (including Vercel)
• Plan for AI-assisted development patterns

🔮 What This Really Means for the Industry

The Deeper Trends

1. Web Standards Renaissance: Frameworks returning to platform primitives
2. Progressive Enhancement Revival: Apps that work for everyone
3. Vendor Independence: Avoiding platform lock-in
4. AI-Native Development: Code optimized for AI understanding
5. Build Complexity Rebellion: Runtime over compile-time

The Real Winners and Losers

Winners:

• React Router v7: Best of both worlds - Remix innovation + ecosystem stability
• Web Standards: Finally getting the respect they deserve
• Platform Independence: No more vendor lock-in
• Progressive Enhancement: Making the web work for everyone

Losers:

• Complex Build Processes: Being questioned and abandoned
• Vendor Lock-in Strategies: Developers seeking independence
• JavaScript-Only Apps: Failing accessibility and reliability standards
• Framework Magic: Being replaced by web standards

💭 My Honest Take: We've Been Building Wrong

Here's what the Remix v3 announcement really reveals:

What We Got Right:

• Component-based UI development
• Declarative programming patterns
• Hot module replacement for development

What We Got Wrong:

• Abandoning progressive enhancement
• Accepting vendor lock-in as normal
• Reinventing web standards with framework abstractions
• Building apps that break without JavaScript

The Path Forward:

• React Router v7 proves you can have modern development AND web standards
• Remix v3 shows there's still room for radical innovation
• Next.js reveals the costs of vendor optimization

🔚 Conclusion: Choose Web Standards

The Remix v3 announcement isn't just about one framework's future - it's a wake-up call about how we've been building web applications.

The hierarchy of choices:

1. React Router v7 - Proven Remix approach with ecosystem stability
2. Remix v3 - Experimental future that might revolutionize everything
3. Next.js - Good for static sites, problematic for web applications

The principles that matter:

• Progressive enhancement over JavaScript dependency
• Web standards over framework abstractions
• Platform independence over vendor optimization
• User experience over developer convenience

React Router v7 gives you the best web development patterns available today. Remix v3 might give you the patterns of tomorrow. Next.js gives you yesterday's patterns with today's marketing.

The choice should be obvious.

The JavaScript framework landscape just got more honest. Whether you're ready to embrace web standards or stick with comfortable abstractions, one thing is certain: the next few years will separate the frameworks that respect the web from those that try to replace it.

What's your take? Are you ready to build web applications that actually work like web applications? Share your thoughts below.

Want to stay updated on web standards and framework honesty? Follow me for more deep dives into building better web experiences.