Remix

Remix Newsletter #48

Remix Newsletter #48, November 2026, listing Shopify is Building on Remix, Prefetching, CSP Support, Remix v3.1.0-v3.2.0, and React Router v8.5.1 over a dimmed Shopify Editions Fall '26 page with its client components labeled

Shopify is building on Remix 3, and Shopify Editions Fall '26 is its public debut! We also shipped Remix 3.1 and 3.2, which add link prefetching and Content Security Policy support. Plus, React Router v8.5.1 is out with a new unstable <Await> and a bunch of fixes.

Let's hit it 🏎️

Shopify Editions: Shopify is Building on Remix

Remix 3 has only been out for a month, and we're already seeing real (and stunning) websites built with it. If you tuned into Remix Jam last month, you may have caught Josh's talk about rebuilding Shopify Editions on Remix 3. Well, it's live! Shopify Editions Fall '26 is the first Edition site built with Remix 3 instead of React.

Every Edition is packed with interactive stories, animation, and 3D, and all of it has to run smoothly on every device. The team wanted fewer re-renders, less hydration, and less JavaScript, and Remix 3 gave them a more browser-native way to build. For them, the choice was easy (their words, not ours): "Bye bye React, and hello Remix 3!"

Here's how they did it:

  • Islands: The page renders as HTML, and only the interactive pieces ship a clientEntry, along with their own code and just the data they need. In the team's words, there's "no need to have the whole app data in the source code!"
  • Frames: Small "micro-stories" in the hero and throughout the page each load their HTML and code separately through a <Frame>, so the rest of the page doesn't wait on them. Stories below the fold load as you scroll toward them.
  • Figma Motion: Designers animate in Figma, and a custom plugin compiles each scene into HTML and CSS keyframes. A lazy loaded <Frame> returns that HTML, and Remix diffs it into the page like any other frame response. Compared with the same story built in Rive, it was ready to play 38% sooner and the page downloaded 33% less (full write-up).

Shopify Editions Fall '26 page with green labels marking its client components: FallNavigation, DesktopNavigation, two ProductCtas, and a LazyFrame that has loaded an interactive chat showing product suggestions

The Editions team went deep on this one. Remix is just one part of the story: they also built a custom graph engine on WebGPU, sent their 3D assets "on a diet," and "got nerdy with colours." If you love seeing how ambitious sites get built, the full thread is worth your time.

Read the full technical breakdown ↗

Prefetching

Remix 3.1 introduces link prefetching. Simply add data-rmx-prefetch to a link, and Remix starts loading that page in the background so it's ready when the user clicks.

There are two prefetch options:

  • intent: Prefetches when a user hovers over or focuses the link for 100ms, or as soon as they press down on it.
  • viewport: Prefetches as soon as the link scrolls into view.

If you need more control, like prefetching the cart after someone adds an item, you can call prefetch(href) from remix/component yourself.

Code example: a product card link with data-rmx-prefetch="intent", a related products link with data-rmx-prefetch="viewport", and an add to cart handler that calls prefetch(routes.cart.href()) to warm up the cart, since the user will likely visit it next

Remix prefetches more than just the HTML. It reads through the page (without running any of it), finds the scripts, stylesheets, and preloaded images and fonts it needs, and prefetches those too. In the Remix Store, product links use intent. Hovering over a product in a collection prefetches its page and additional scripts. After the click, they all load from the cache:

Hovering the Racing Team Jacket in the Remix Store prefetches the racing-jacket page and its product-details, remix-navigation, and subscribe-form scripts. After the click, the Chrome DevTools Network panel shows the page served from disk cache and the scripts from prefetch cache

Remix doesn't add its own cache on top of this, so your Cache-Control headers still decide whether the HTML gets reused. Even if a page is no-store and has to be fetched again, its fingerprinted assets are already cached, so there's a lot less to download.

Prefetching only runs on links you opt in, and it skips users who have Save-Data turned on or are on a 2G connection.

Check out the prefetching docs ↗

CSP Support

Remix 3.2 adds Content Security Policy middleware, so you can lock down exactly which scripts and styles run on your pages.

A strict CSP is one of the best defenses against cross-site scripting (XSS). With a nonce-based policy, every request gets a fresh random value, and the browser only runs scripts and styles that carry it. A script an attacker manages to inject won't have the nonce, so the browser refuses to run it. The hard part is getting that nonce onto every tag your framework generates: import maps, module preloads, inline styles, and anything that arrives later through client navigation.

With remix/middleware/csp, you add csp() before render(), and Remix handles the rest:

Code example: app/router.ts adds csp() before render() with a nonce-based policy for scripts and styles, and app/actions/controller.tsx renders a script tag that reads its nonce with getCspNonce(context)

Every HTML response then carries a Content-Security-Policy header with that request's nonce. Here's an example from the Remix Store:

Chrome DevTools Network panel for shop.remix.run showing the document's Content-Security-Policy response header, including a script-src nonce and strict-dynamic alongside Shopify's CDN and checkout domains

The middleware also handles the cases where a strict policy is easy to break:

  • Frames: Frames rendered on the server share the document's nonce, and client navigation keeps it working across frame and island updates.
  • HMR: Hot module replacement works under a strict policy, even one without 'unsafe-eval', so you can develop against the same policy you ship.
  • Gradual rollout: Try stricter rules with reportOnlyPolicy while your current policy stays enforced, and collect violation reports with reportingEndpoints before you switch them on.

Check out the CSP middleware docs ↗

Remix v3.1.0-v3.2.0

Prefetching and CSP weren't the only things to land in Remix 3.1 and 3.2. Here's everything else worth knowing about.

Performance

Server rendering with remix/component is about twice as fast and uses less memory, without any code changes on your end. A 48-product listing page now renders in 244µs instead of 513µs. In the browser, we folded the runtime into fewer modules and trimmed its bundle size, and css() rerenders take about half as long too.

Streaming Uploads (Unstable)

New /future entrypoints for the form data middleware, form data parser, and multipart parser stream file uploads straight from the request instead of holding them in memory. In our benchmarks, a 100 MiB upload added 29 MiB to peak memory instead of 396 MiB, and the upload handler started after 0.2ms instead of 45ms. remix/file-storage/s3 now streams multipart uploads too, so the two together send large files straight to S3.

To try it, import formData() from remix/middleware/form-data/future. Future APIs may change in any release, but they show where these packages are headed in the next major. If your app handles uploads, please give them a spin and report any issues you run into.

New Features

  • More control over frame reloads: frame.reload() accepts a different src, or a method and body to submit data, and renders the response while leaving browser history alone.
  • Better test mocks: Mocks and spies in remix/test gain mockImplementation(), mockImplementationOnce(), callCount(), resetCalls(), and restore().
  • Manual focus control: Opt out of automatic focus resets during navigation with resetFocus: 'manual' or data-rmx-reset-focus="manual".
  • Client-only mixins: createMixin(setup, { ssr: false }) skips a mixin on the server while keeping its browser behavior, which is handy for mixins that don't affect the server HTML.
  • Motion preferences: prefersReducedMotion() from @remix-run/ui/animation checks the user's motion setting, and it's safe to call during server rendering.

Bug Fixes & Improvements

  • css() and the style prop serialize property names and numbers the way browsers expect, so flex: 2 means a grow factor instead of 2px, custom properties keep their casing, and vendor-prefixed properties get their leading dash
  • Navigations keep page-specific stylesheets in place, so pages stop flashing unstyled content
  • Safari restores the full scroll position on back and forward navigation
  • Boolean aria-* and data-* attributes render as "true" and "false" on the server, so assistive technology reads aria-current={true} correctly
  • clientEntry props hydrate more reliably, and objects that only look like JSX elements (say, parsed from JSON) now throw, so data from a database or API can't inject markup
  • remix/session-storage/fs and remix/file-storage/fs keep existing files intact when saves overlap or an upload fails
  • Apps created with remix new fingerprint assets in production and run their scripts on Windows
  • Adding or removing a clientEntry during HMR restarts the app server, so hydration boundaries stay current
  • Browser tests in remix/test handle dynamic imports, and WebKit runs finish instead of stalling

Check out the Remix changelog ↗

React Router v8.5.1

React Router v8.5.1 packs a lot into a patch release: a new unstable <Await> built on React's use() and 19 fixes, many of them around fetchers and lazy routes. It also includes 15 PRs from 12 community contributors, so thank you to everyone who helped ship this one!

Unstable Features

Adopt in production at your own risk, as unstable APIs may change in minor or patch releases.

<Await unstable_promise>: Pass your promise to unstable_promise instead of resolve to leverage React.use() internally, instead of custom React Router promise tracking logic (required prior to React.use() stabilizing). The only functional change is that with the new API, errorElement only handles a rejected promise - not render function exceptions - those will bubble upwards to the nearest React error boundary.

Bug Fixes & Improvements

  • Streamed server content no longer flashes back to its <Suspense> fallback when a parent updates during hydration
  • Fetcher revalidation errors bubble to the nearest error boundary instead of the root
  • Loader data stays fresh when an older navigation or background reload finishes after a fetcher mutation
  • Loader data revalidates when a fetcher action's redirect is skipped because a newer navigation started or the fetcher unmounted
  • Rejected lazy route imports are retried instead of cached permanently
  • A rejected lazy.Component import on a route without a loader renders the nearest error boundary instead of a blank page
  • Posting a <Form> to the current URL with an encoded action replaces the history entry instead of adding a duplicate
  • Lazy route discovery finds routes with commas in their paths
  • In ssr: false apps with a prerender config, SPA fallback routes without prerendered data return your host's 404 instead of an internal "No result found for routeId" error
  • @react-router/dev plays nicer with other Vite plugins, using Vite's resolved output directories and waiting for other plugins' build hooks before prerendering
  • @react-router/architect preserves binary request bodies
  • create-react-router runs package manager commands correctly on Windows
  • Server route manifest processing is bounded for paths with expensive route expansion, and turbo-stream decoding validates input more strictly (also in v7.18.5)

Check out the React Router changelog ↗

If you enjoy getting this email, please let us know! We'd love to hear what you like about Remix and these updates, along with any suggestions you have to improve them.

- The Remix Team

Get updates on the latest Remix news

Be the first to learn about new Remix features, community events, and tutorials.