Remix 3 Ditched React: A New Era for Full-Stack JavaScript

The Shocking Announcement

In October 2025, the Remix team made a shocking announcement at Remix Jam 2025: Remix 3 would no longer be built on React. This wasn't just a version bump or incremental update--it was a complete philosophical shift that sent ripples through the JavaScript ecosystem.

After years of building on React's shoulders, creators Michael Jackson and Ryan Florence decided to forge their own path, building a custom reactivity system from scratch that prioritizes web standards, performance, and developer control over the familiar patterns that React developers had come to rely on.

The decision wasn't made lightly. Jackson and Florence have been part of the React community since its earliest days, watching it evolve from a fresh alternative to the dominant force in frontend development. But as React introduced increasingly complex features like Server Components, Suspense, and Server Actions, the team found themselves at what they describe as the "top of the mountain"--looking around at the complexity and wondering if there might be a better path forward.

At Digital Thrive, we believe the future of web development lies in frameworks that embrace web standards and prioritize performance. Our web development services focus on building applications that leverage modern browser capabilities while maintaining excellent developer experience. Remix 3's bold move represents exactly the kind of innovation that pushes our industry forward, whether you ultimately adopt it or not.

The 6 Principles Guiding Remix 3's Development

Before diving into the technical changes, it's essential to understand the philosophy driving Remix 3's development. The team published six core principles that serve as a compass for every decision.

Model-First Development

Emphasizes starting with data and letting it drive UI decisions. Rather than thinking in terms of components first, developers are encouraged to model their data structures and relationships first, then build the interface around those models. This approach aligns with how databases and APIs naturally structure information, making it easier to reason about complex applications.

Build on Web APIs

Remix 3 leans heavily into native browser APIs like Custom Events, AbortSignal, and the Fetch API. Instead of abstracting away browser functionality, the framework embraces it, which means developers can use their existing knowledge of web standards without learning framework-specific abstractions.

Religiously Runtime

Minimizing the amount of code that runs during application execution. The goal is to shift as much work as possible to build time, resulting in smaller bundle sizes and faster runtime performance. This principle directly addresses the bloat that has accumulated in modern React applications.

Avoid Dependencies

Reducing external dependencies makes Remix 3 more stable, easier to maintain, and less vulnerable to supply chain attacks. The team is building only what they need, rather than pulling in third-party solutions that might introduce unnecessary complexity.

Demand Composition

Every piece of Remix 3 can be combined with other pieces in predictable ways through consistent patterns.

Distribute Cohesively

Packages are designed to work together seamlessly but can also be used independently without the entire framework.

According to the Remix Jam 2025 Recap, these principles guide every architectural decision in the new framework.

Understanding the New Component Model

The most visible change in Remix 3 is the completely redesigned component model. Gone are the familiar hooks like useState and useEffect. Instead, Remix 3 introduces a simpler, more explicit approach to state management and reactivity that feels both familiar and alien to React developers.

export function App(this: Remix.Handle) {
 let count = 0;

 const increment = () => {
 count++;
 this.update();
 };

 const decrement = () => {
 count--;
 this.update();
 };

 return () => (
 <div id="app">
 <h1>Counter</h1>
 <p>Clicks: {count}</p>
 <button on={pressDown(increment)} type="button">+</button>
 <button on={pressDown(decrement)} type="button">-</button>
 </div>
 );
}

Two aspects immediately stand out to React developers. First, state is simply declared with a let statement--no special hooks required. Second, the component returns a function that returns JSX.

The outer function runs once when the component initializes, serving as a constructor where you set up initial state and define methods. The inner function is what actually renders and re-renders when updates occur. This pattern gives you a clear separation between initialization and rendering logic.

For teams evaluating their web development stack, understanding these alternatives helps inform better technology decisions. Our web development expertise covers various frameworks and their trade-offs.

Explicit Reactivity

In React, state changes automatically trigger re-renders. Remix 3 takes a different approach: you must explicitly call this.update() to trigger a re-render after mutating state. This explicit control means developers have complete awareness of when and why re-renders occur.

This explicit model also means that Remix 3 can be more intelligent about when updates actually happen. Since you're telling the framework exactly when state has changed, it can batch updates more effectively and avoid unnecessary work. The trade-off is more verbosity, but in return, you get predictability and the ability to optimize update scheduling precisely.

As explained in Better Stack's technical coverage, this approach enables more precise performance optimization.

Event Handling: Accessibility Built In

Remix 3 introduces a new approach to event handling that prioritizes accessibility and consistency. Instead of React's onClick prop, Remix 3 uses an on prop combined with interaction helpers like pressDown:

<button on={pressDown(increment)} type="button">+</button>

The pressDown interaction bundles mouse clicks, spacebar presses, and Enter key presses into a single event. This means interactive elements work for keyboard users without requiring additional code. Accessibility isn't an afterthought to add later--it's built into the fundamental event system.

This approach reflects Remix 3's broader philosophy of embracing web standards. The browser already has built-in accessibility features through keyboard navigation. Rather than creating framework-specific event handlers that might not translate to native accessibility tools, Remix 3 leverages the platform's existing capabilities. Building accessible web applications is a core principle we apply in all our web development projects.

Custom Interactions with createInteraction

For complex interactive patterns, Remix 3 provides the createInteraction API. This allows developers to bundle event handling logic, state management, and side effects into reusable packages. A BPM tapper example demonstrates how this works: the interaction tracks the timing between user inputs, calculates the average tempo, and exposes the result as part of the event data.

The component using this interaction simply responds to the events it cares about, keeping the business logic contained within the interaction itself. This pattern promotes separation of concerns while making it easy to share interactive behaviors across different parts of an application.

As documented in Better Stack's guide, this interaction system represents a fundamental shift in how developers think about user input handling.

Server-Side Architecture: The Fetch Router

While the client-side changes are immediately visible, Remix 3's server-side architecture represents an equally significant evolution. The team has built a new routing system called @remix-run/fetch-router that embraces the Fetch API as its foundational primitive.

The fetch-router works similarly to client-side routers but operates entirely on the server. It accepts incoming requests, matches them against route definitions, executes handlers, and returns responses. The architecture is designed to be isomorphic--running the same routing logic on both client and server.

This approach means Remix 3 can run in any JavaScript environment that supports the Fetch API, including Cloudflare Workers, Deno Deploy, Node.js, and browser service workers. The portability eliminates vendor lock-in and allows developers to deploy to the platform that best suits their needs. Our web development team frequently leverages these deployment options for optimal performance and cost efficiency.

New Package Architecture

Remix 3 is distributed as a collection of focused packages rather than a monolithic framework:

• @remix-run/fetch-router: The core routing system based on Fetch
• @remix-run/route-pattern: Pattern matching for route definitions
• @remix-run/node-fetch-server: Server utilities for Node.js environments
• @remix-run/form-data-parser: Handling form data without external dependencies
• @remix-run/multipart-parser: Multipart form parsing for file uploads
• @remix-run/file-storage: File handling abstractions

This modular architecture means developers can adopt just the pieces they need. A project might use only the router without the component system, or vice versa. The packages are designed to work together seamlessly but don't require complete adoption.

According to the Remix Jam 2025 Recap, this distributed approach enables teams to adopt Remix incrementally.

The Frame Component: Async UI Made Simple

One of Remix 3's most innovative features is the <Frame> component, which addresses a common challenge in web development: handling asynchronous UI updates gracefully. Traditional approaches either block the entire page while loading or require complex state management to show partial content.

Frame provides a declarative way to handle loading states, streaming, and progressive enhancement:

<Frame
 data={fetchData()}
 loading={<LoadingSkeleton />}
 fallback={<ErrorMessage />}
>
 {(data) => <DisplayComponent data={data} />}
</Frame>

The component handles all the complexity of timing, error handling, and cleanup internally. Developers simply provide the data source and the UI to render, letting Frame manage the rest.

This pattern is particularly valuable for complex dashboards and data-heavy applications where multiple independent components load at different times. Rather than coordinating loading states across dozens of components, each component can be wrapped in its own Frame with independent behavior.

As covered in Better Stack's technical analysis, the Frame component demonstrates Remix 3's focus on developer experience for common patterns.

Performance Implications

The decision to move away from React has significant performance implications. React's bundle size has grown substantially over the years as it adds features like concurrent rendering, suspense boundaries, and server components. By building their own reactivity system, Remix 3 can optimize specifically for their use cases rather than supporting every possible scenario React was designed for.

Performance optimization is critical for modern web applications, affecting everything from user experience to search engine rankings. The explicit reactivity model also enables more predictable performance characteristics. Since developers know exactly when updates occur, they can optimize accordingly. There's no hidden reconciliation process to profile or memoization to debug--just straightforward code that executes when told to.

Bundle Size Comparison

For developers concerned about performance budgets, the difference between React and Remix 3 becomes significant at scale. A typical React application might include:

• React core: ~40KB gzipped
• React DOM: ~120KB gzipped
• React Router: ~30KB gzipped

Remix 3's component model and routing system can achieve similar functionality with significantly less--often 50% or more savings for common use cases. The exact savings depend on which features are used.

Server-side performance benefits as well. The fetch-router's simplicity means less overhead per request. The ability to run in lightweight environments like Cloudflare Workers reduces infrastructure costs and improves cold start times.

As analyzed in LogRocket's coverage and Appwrite's architecture review, these performance advantages represent one of the primary motivations behind the React departure.

What This Means for React Developers

For developers who built careers around React's patterns, Remix 3's departure raises an important question: should you learn the new system, or stick with what you know? The answer depends on your priorities and the types of applications you build.

React developers will find some concepts familiar. The component-based architecture remains. JSX is still used for describing UI. The server/client separation still exists. But the day-to-day coding experience changes significantly. There are no hooks, no effect dependencies to manage, and no reconciler to reason about.

The learning curve isn't just syntactic. The explicit reactivity model requires a different mental model. Developers must think about when updates happen rather than assuming they happen automatically. This shift can feel limiting at first but often leads to better performance and fewer surprises in production.

Migration Considerations

Performance requirements: If your application is performance-sensitive and bundle size matters, Remix 3's leaner architecture provides real benefits.

Team expertise: Developers deeply invested in React patterns may find the transition challenging. The new paradigm requires unlearning some habits and adopting new practices.

Ecosystem compatibility: React's ecosystem is enormous. Component libraries, tools, and community resources are plentiful. Remix 3's ecosystem is nascent by comparison, though growing.

Long-term vision: Remix 3's approach to web standards and minimal dependencies suggests a different philosophical direction. Teams who value this philosophy may find Remix 3 more aligned with their goals.

LogRocket's analysis provides additional perspective on the migration challenges and opportunities.

Remix 3 and the Future of Web Development

Remix 3's bold move represents a broader trend in web development: questioning the assumptions that have guided the industry for years. React's virtual DOM approach was revolutionary when introduced, but modern browsers have evolved significantly. Web Components, custom elements, and native browser features provide capabilities that didn't exist when React was created.

The team behind Remix isn't alone in exploring alternatives. Projects like Svelte, SolidJS, and Qwik have experimented with different approaches to reactivity and rendering. Each offers different trade-offs between developer experience, runtime performance, and bundle size.

What sets Remix 3 apart is its explicit embrace of web standards. Rather than creating abstractions that hide the platform, Remix 3 works with it. This approach may resonate with developers who feel that modern frontend frameworks have become too abstracted from the underlying platform.

Getting Started with Remix 3

For developers eager to experiment with Remix 3's new paradigm, the team has published several packages on NPM that can be installed individually:

npm install @remix-run/fetch-router
npm install @remix-run/route-pattern
npm install @remix-run/events

The fetch-router package provides the foundation for server-side routing, while the events package includes interaction helpers like pressDown. As development progresses, additional packages will be released for component rendering, data loading, and form handling.

For now, Remix 3 remains in active development. Many features are marked experimental, and production use isn't recommended. But the direction is clear: a framework that prioritizes web standards, explicit control, and performance.

At Digital Thrive, we continuously evaluate emerging technologies to deliver the best solutions for our clients. Remix 3's focus on performance and web standards aligns with our commitment to building high-quality web applications that perform well and scale effectively.

The Remix Jam 2025 Recap provides ongoing updates as development progresses.

Sources

1. Remix Jam 2025 Recap - Official source for Remix 3 announcements
2. LogRocket: Remix 3 Ditched React - Developer-focused analysis
3. Better Stack: Remix 3 and the Future Beyond React - Technical deep dive
4. Appwrite: Remix 3 What's Changing - Architecture analysis