top of page

Web Development with Remix React Framework

Updated: Jun 12

In the ever-evolving world of JavaScript frameworks, one might argue that there are "too many" options available, all aiming to solve similar problems. However, this proliferation of projects can lead to industry progress, fostering innovation and novel approaches to web development. Among these frameworks, Remix stands out as a recently released minimal framework built on top of React.js, offering a fundamental approach to web development akin to projects like Svelte.

Remix introduces the concept of "Nested Routing," simplifying coding and enabling direct component-to-page route associations. Founded by individuals who played a role in the creation of React Router, Remix aims to revolutionize application development by embracing new ideas and approaches.

In this article, we will delve into the core concepts and features of Remix, exploring how it transforms the way we build applications.

What is Remix?

Remix is a React framework used for server-side rendering (SSR). This means that both the backend and the frontend can be made using a single Remix app. Data is rendered on the server and served to the client side with minimum JavaScript. Unlike vanilla React, where data is fetched on the frontend and then rendered on the screen, Remix fetches data on the backend and serves the HTML directly to the user.

Remix also uses web standards such as HTTP methods, status codes, headers, forms, links, etc. to handle routing, data loading, actions, transitions, and other features. This makes Remix more compatible with browsers, crawlers, accessibility tools, and progressive enhancements.

Remix is different from other React frameworks such as Next.js or Gatsby in several ways. For example:

  • Remix uses nested routes instead of flat routes. This allows for better code organization and the use of components and layouts.

  • Remix uses loaders to fetch data for each route on the server or the client. Loaders can also be nested and composed to share data between routes.

  • Remix uses actions to handle form submissions and other side effects on the server or the client. Actions can also return HTTP responses with status codes, headers, cookies, etc.

  • Remix uses transitions to handle navigation between routes with animations and loading indicators. Transitions can also be aborted or retried based on network conditions or user actions.

  • Remix uses traditional forms instead of custom components or libraries for handling user input. This makes forms more accessible, secure, and easy to use.

Features of Remix

Here, we will explore the core concepts of Remix. Each concept will be explained with example code to provide a comprehensive understanding of how Remix revolutionizes web development.

1. Optimistic UI:

Enhancing User Experience Optimistic UI is a design pattern adopted by Remix to create a responsive and seamless user experience. It aims to avoid showing loading indicators and allows users to continue using the application while data is being processed on the server. Remix achieves this by faking the UI update immediately after a user action, even before the server response is received. If the request fails, the user can be notified appropriately.

Here's an example code snippet showcasing Optimistic UI in Remix:

import { useLoaderData } from '@remix-run/react';   
function BlogPost() {        
    const data = useLoaderData();              
    return (              

export function loader() {        
    return { title: 'Loading...', content: 'Loading...' };  

In the above code, the loader function sets initial data to display a loading state in the BlogPost component. However, once the actual data is fetched from the server, the UI will update dynamically, creating an instantaneous and responsive experience for the user.

2. API Routes:

Simplifying Data Fetching Remix treats routes as APIs, enabling seamless data fetching without additional frontend requests. When a component, such as a link to a specific route, is loaded, Remix automatically fetches the required data from the server-side.

Here's an example showcasing API Routes in Remix:

import { Link, useRouteData } from '@remix-run/react';   
function Teams() {        
    const teams = useRouteData();              
    return (              
                { => (                                
                    <li key={}>{}</li>                          

export function loader() {        
    return fetchTeamsData();  

async function fetchTeamsData() {        
    const response = await fetch('');        
    const teams = await response.json();        
    return teams;  

In this example, the loader function fetches teams data from an API, which is then accessed in the Teams component using useRouteData. The data is rendered dynamically, simplifying the process of fetching and integrating data into components.

3. Data Writing (Mutations):

Streamlining Data Updates Remix simplifies data updates by leveraging forms and providing additional features like loading indicators and data validation feedback. Data mutations are handled through routes' action functions for POST methods and loader functions for GET methods.

Here's an example showcasing data writing in Remix:

import { Form, useActionData } from '@remix-run/react';    
function AddTeam() {        
    const { success, error } = useActionData();              
    const handleSubmit = async (data) => {              
        const response = await fetch('/teams', {                    
            method: 'POST',                    
            body: JSON.stringify(data),              
        if (response.ok) {                    
            // Handle success              
        } else {                    
            // Handle error              
    return (              
            <h1>Add Team</h1>             
            <Form action="/teams" method="post" onSubmit={handleSubmit}>                          
                {/* Form fields */}                    
            {success && <p>Team added successfully!</p>}                    
            {error && <p>Error: {error.message}</p>}              

In the above example, the AddTeam component handles the submission of a form to add a new team. The form's onSubmit function sends a POST request to the server-side route's action function. The resulting success or error messages are displayed accordingly, providing a streamlined approach to data updates.

4. Error Handling:

Embracing Robust Error Management Remix's error handling mechanism ensures a smooth user experience even in the presence of errors. Components that encounter loading failures display their respective ErrorBoundary functions within their boundaries or bubble up errors to the root error boundary.

Here's an example showcasing error handling in Remix:

import { ErrorBoundary } from '@remix-run/react';    
function App() {        
    return (              
            <h1>Remix App</h1>             
            <ErrorBoundary fallback={ErrorFallback}><BlogPost />             

function ErrorFallback({ error }) {        
    return (              
            <h2>An error occurred:</h2>             

In this example, the App component wraps the BlogPost component with an ErrorBoundary. If an error occurs within BlogPost, the ErrorFallback component will be rendered, displaying the error message gracefully.

5. Styling: Modular and Dynamic CSS

Remix provides a flexible styling approach that allows stylesheets to be added directly to individual components. These stylesheets are dynamically merged and rendered when their corresponding routes are active, ensuring efficient and modular CSS organization.

Here's an example showcasing styling in Remix:

import { useRouteData } from '@remix-run/react';    
function BlogPost() 
    const { title, content } = useRouteData();              
    return (              
        <div className="blog-post">             

export function styles() {        
    return `              
        .blog-post {                    
            font-size: 18px;                    
            color: #333;          

In this example, the styles function within the route exports the CSS specific to the BlogPost component. When the route is active, the corresponding styles will be applied, enhancing code modularity and performance optimization.

How Remix uses server-side rendering and web standards to deliver fast and resilient web apps?

Server-side rendering (SSR) is a technique that renders the initial HTML of a web page on the server instead of the client. This improves the performance and user experience of the web app by reducing the amount of JavaScript that needs to be downloaded, parsed, and executed by the browser. SSR also improves SEO (search engine optimization) and accessibility by making the web page more readable by crawlers and assistive technologies.

Remix uses SSR for every route by default. This means that when a user requests a web page from a Remix app, the server will render the HTML of that page using React components and data from loaders. The server will then send the HTML to the browser along with a minimal amount of JavaScript that hydrates the page with interactivity.

Remix also uses web standards such as HTTP methods (GET, POST, PUT, DELETE), status codes (200 OK, 404 Not Found), headers (Content-Type), forms (input, textarea), links (a), etc. to handle routing, data loading, actions, transitions, and other features. This makes Remix more compatible with browsers, crawlers, accessibility tools, and progressive enhancement.

For example:

  • Remix uses GET requests for fetching data from loaders and rendering pages on the server or the client.

  • Remix uses POST requests for submitting forms from actions and performing side effects on the server or the client.

  • Remix uses status codes for indicating the result of an action or a loader. For example, 200 OK means success, 404 Not Found means failure.

  • Remix uses headers for setting cookies or redirecting users after an action.

  • Remix uses forms for collecting user input and sending it to actions. Forms can also be validated on the server or the client using HTML attributes or custom logic.

  • Remix uses links for navigating between routes with transitions. Links can also have prefetch attributes that load data for the next route in advance.

By using web standards, Remix leverages the built-in features and optimizations of the web platform, such as caching, compression, security, accessibility, etc. This makes Remix web apps fast and resilient, even on slow or unreliable networks.

Benefits of using Remix:

Remix offers several benefits for web developers and users, such as:

1. Nested pages: Remix allows you to nest routes inside other routes, creating a hierarchy of pages. This allows you to reuse components and layouts across different pages, and also to embed pages inside other pages. For example, you can have a /blog route that renders a list of blog posts, and a /blog/:slug route that renders a single blog post inside the list. Nested pages also enable error boundaries, which are components that catch and handle errors from their children components. This way, you can prevent errors from breaking the entire page, and instead show a fallback UI or a custom error message.

2. Transitions: Remix allows you to handle navigation between routes with transitions. Transitions are animations and loading indicators that show the user what is happening when they click on a link or submit a form. Transitions can also be aborted or retried based on network conditions or user actions. For example, you can show a spinner while loading data for the next route, or show a retry button if the data fails to load. Transitions can also be customized with CSS or JavaScript to create different effects.

3. Traditional forms: Remix allows you to use traditional HTML forms instead of custom components or libraries for handling user input. This makes forms more accessible, secure, and easy to use. Forms can also be validated on the server or the client using HTML attributes or custom logic. For example, you can use required, pattern, min, max, etc. attributes to check the validity of the input fields, or use custom loaders and actions to perform more complex validations.

How to create a Remix app?

Now that we have seen some of the features and benefits of Remix, let’s create a simple weather app using Remix and OpenWeatherMap API. The app will allow the user to enter a city name and see the current weather information for that city.

To create a Remix app, we need to install Remix and set up a basic project. We will use npm as our package manager, but you can also use yarn if you prefer.

First, we need to install Remix globally:

npm install -g remix 

Then, we need to create a new project using the remix new command:

remix new weather-app 

This will create a folder called weather-app with some files and folders inside it. The main files and folders are:

  • app: This is where we write our React components and routes for our web app.

  • public: This is where we put our static assets such as images, fonts, etc.

  • remix.config.js: This is where we configure our Remix app with options such as server runtime (Node.js or Cloudflare Workers), browser build directory (public/build), etc.

  • server: This is where we write our server code for handling requests and rendering pages.

  • package.json: This is where we define the dependencies and scripts for our project.

To run our Remix app locally, we need to start two processes: one for the server and one for the browser. We can use npm scripts for this:

npm run dev # starts both processes

Alternatively, we can start them separately in different terminals:

npm run dev:server # starts the server process 
npm run dev:browser # starts the browser process

Once both processes are running, we can open http://localhost:3000 in our browser and see our Remix app running.

Cleaning up the Remix app

By default, Remix creates some files and folders that we don’t need for our weather app. Let’s delete them to make our project cleaner.

In the app folder, delete everything except for root.tsx and styles.css.

In the public folder, delete everything except for favicon.ico.

In the server folder, delete everything except for entry.server.tsx.

In the package.json file, delete all dependencies except for @remix-run/express, @remix-run/react-router-dom , react , react-dom , remix , typescript , @types/node , @types/react , @types/react-dom , @types/react-router-dom .

Your project structure should now look like this:

├── app 
│   ├── root.tsx 
│   └── styles.css 
├── public 
│   ├── build 
│   └── favicon.ico 
├── remix.config.js 
├── server 
│   └── entry.server.tsx 
└── package.json 


By understanding and leveraging these concepts, developers can create powerful and seamless web applications that excel in performance, user experience, and maintainability. Remix offers a streamlined approach to coding, empowering developers to focus on building exceptional web experiences.

bottom of page