Expo SDK 53 beta is now available

The SDK 53 beta period begins today and will last approximately two weeks. The beta is an opportunity for developers to test out the SDK and ensure that the new release does not introduce any regressions for their particular systems and app configurations. We will be continuously releasing fixes and improvements during the beta period — some of these may include breaking changes.

SDK 53 beta includes React Native 0.79.0 and React 19.0.0. The full release notes for SDK 53 won't be available until the stable release, but you can browse the changelogs in the expo/expo repository to learn more about the scope of the release and any breaking changes. We'll merge all changelogs into the root CHANGELOG.md when the beta is complete.

We're also hosting office hours on Discord for those of you interested in helping test the release!

In SDK 52, we enabled the New Architecture in all new projects, but it remained opt-in for existing projects. In SDK 53, the New Architecture is enabled by default in all projects, and you must explicitly opt out if you aren’t ready to adopt it yet. Learn how to opt out.

If you use react-native-maps, instead of using the currently recommended 1.20.0 version, try installing the the latest 1.21.0 release (npx expo install expo-maps@1.21.0 , exclude it from version validation, and apply this change to the config plugin). This version includes full support for the New Architecture, and it could benefit from additional testing from the broader community before it is recommended as a default version for Expo SDK 53. Additionally, if your app depends heavily on this open source, community maintained library, consider joining us in sponsoring the project to support its ongoing maintenance. For apps that require maps and that are able to enforce a minimum version of iOS 18 (or don't support iOS), then you could consider the new Swift UI and Jetpack Compose based expo-maps as an alternative.

If you use @stripe/stripe-react-native, note that it does not yet support the New Architecture — but it is coming soon.

If there are any issues blocking you from migrating to the New Architecture, create an issue on expo/expo, and opt out until the issue is resolved.

In SDK 52, we shared that we were working with @zoontek to help ship react-native-edge-to-edge, a library that 'effortlessly enables edge-to-edge display in React Native, allowing your Android app content to flow seamlessly beneath the system bars.' This has become increasingly important, because Google has announced that opting out of edge-to-edge will no longer be possible in Android 16, coming in June.

Android 15 enforced edge-to-edge for apps targeting Android 15 (API level 35), but your app could opt-out by setting R.attr#windowOptOutEdgeToEdgeEnforcement to true. For apps targeting Android 16 (API level 36), R.attr#windowOptOutEdgeToEdgeEnforcement is deprecated and disabled, and your app can't opt-out of going edge-to-edge.

In SDK 53, edge-to-edge on Android is now:

• enabled by default in the Expo Go app, with no opt-out.
• enabled by default in all new projects, with opt-out available outside of Expo Go.
• disabled by default in all existing projects outside of Expo Go, with opt-in available and encouraged.

Looking to the future, in SDK 54, edge-to-edge will be the default for new and existing projects. A guide that goes more in depth will be coming in time for the proper SDK 53 release. Until then, refer to the “Considerations” section of the react-native-edge-to-edge README.

Building this interface should take a couple minutes in your Expo iOS app, and we hope it will be soon with Expo UI. Source code.

Expo UI aims to give developers easy access to native UI components from SwiftUI and Jetpack Compose. It will include essential platform primitives—like toggles, sliders, context menus, pickers, and lists—to complement existing community libraries built around iOS UIKit and Android Views.

This library is experimental, it’s very rough, and it’s changing quickly. APIs that you are using today may change tomorrow! Swift UI and Jetpack Compose are not yet widely used in the React Native ecosystem, and we’ve been exploring some unique approaches to integrating with these tools. You will find issues and limitations, and we encourage you to report them!

This is not the first attempt at doing something like this in the ecosystem, and getting it off of the ground has been a joint effort — with contributions from folks like Andrew Levy, Janic Duplessis, Andrew Prifer, Emanuel Quimper, Benjamin Komen, Fernando Rojo, and the mysterious “Pflaumenbaum”. If this is a problem that you are interested in, we encourage you to contribute.

More information will be coming soon about the improved Swift UI and Jetpack Compose integration, you can learn more about Expo UI in the API reference, and see examples on GitHub.

When you set experiments.remoteBuildCache.provider to eas in your app config, running npx expo run:[ios|android] will look for a build with a matching fingerprint on EAS, and if one exists it will download and launch it rather than compiling the app again. If there is no matching build, then it will continue to compile locally as usual for the run command, then upload the archive once it is completed. On subsequent runs, you and your teammates will download the new build automatically and save a few minutes each time.

If you have been using eas build:dev , you might wonder what the difference is — the main distinction is that this remoteBuildCache approach will compile your app locally when there is a cache miss, rather than build on EAS. Additionally, during the beta we will add support for alternative remote cache provider implementations, so you will be able to host your own cache on GitHub or wherever you prefer.

During this initial experiment period, we’ve limited the number of cached builds with the EAS provider to 10 on the free and on demand plans, 50 with the production plan, and 100 with the enterprise plan (per billing cycle). We’ll adjust this as the feature moves towards a stable release. The cache is built on top of eas upload and eas build:download commands, which we built for the Radon IDE team for this same use case — so you can expect to see similar behavior for Expo projects using the IDE in the near future.

Let us know if this is useful for you and your team, and any other thoughts you have about similar tools we can build to help improve the speed of your development workflow.

• React Native 0.79 with React 19 and React Native Web 0.20.0. Refer to the release notes for React Native 0.79 and React 19 release notes for detailed information. There are some great features in React 19 — such as Suspense for loading states and use for contexts and promises, so be sure to read up on it! Also, learn more about the Expo SDK policy for tracking React Native versions.
• Stable release of new expo-audio library. We released the beta for expo-audio in SDK 52 and received a lot of great feedback. We spent the last SDK cycle incorporating that feedback and making other improvements to the library, and now we're ready to call it stable! We recommend migrating to it from expo-av now. It is more reliable, easier to use, more performant, and more powerful than Audio component from expo-av. Learn more about expo-audio.
• New expo-maps package alpha release. This library aims to provide wrappers for the platform standard APIs for maps — Google Maps on Android and Apple Maps for iOS. It is built on top of the modern Jetpack Compose and Swift UI APIs for each component. Keep in mind that the minimum iOS version required to use the library is currently iOS 18, although we plan on adding support for iOS 17. Support for older versions than iOS 17 likely won’t be possible, due to limitations of the Swift UI API. We also do not intend to support Google Maps on iOS in this library. We’re excited about expo-maps because, like with our Camera, Video, and Audio libraries, it will be built with our philosophy of providing a stable, consistent, and reliable interface to the most common use cases that most apps will need. Other maps libraries in the ecosystem can focus on filling in more specific and uncommon use cases that a smaller set of app developers may need. Learn more.
• Improve Android build times with prebuilt Expo Modules. Build time significantly impacts daily development. Recently, we announced that we’ve improved the iOS build time by upgrading our hardware — now it's time for Android. By precompiling some of our Expo Modules for Android in this SDK, you will experience up to a 25% reduction in build time locally (depending on your hardware). The improvements are currently more modest on EAS, but they enable us to build a more robust caching mechanism for EAS and further speed up build times.
  By default, this feature is enabled when using a new project template. As always, you can opt out by passing buildFromSource to Expo Autolinking in the package.json:

{
  "name": "opt-out-example",
  "dependencies": {},
  "expo": {
    "autolinking": {
      "android": {
        "buildFromSource": [".*"]
      }
    }
  }
}

• expo-updates now allows you to override headers at runtime with Updates.setUpdateURLAndRequestHeadersOverride() , giving you full control over updates on the client side (use it with caution). The expo-updates library was intentionally built with guardrails to minimize the risk of accidentally bricking your app, but there are sometimes cases where you would prefer to trade off these protections in favor of control, for example to enable the ability to allow a client to switch between updates (such as in a preview build for internal employees). Learn more.
• React Server Functions support is now in beta. You can now deploy React Server Functions to production with EAS Hosting and the new EXPO_UNSTABLE_DEPLOY_SERVER environment variable, along with setting experiments.reactServerFunctions to true in your app config. Learn more.
• Improved background tasks - our new module expo-background-task uses the latest APIs on Android and iOS and deprecates the expo-background-fetch module, which was based on now deprecated platform APIs. The new package supports running deferrable tasks in the background in a way that optimizes power usage on the end user’s device. Expo Background Task uses the WorkManager API on Android and the BGTaskScheduler API on iOS. Using this package, you can run tasks when your app is in the background and perform operations like downloading data, running Expo Updates to check for and download new versions (you should do this!), or perform routine operations like cleaning up your database or uploading local data at regular intervals. Learn more.
• Development builds can now be deployed to TestFlight. More information available in facebook/react-native#49154. This can be a good alternative to using ad hoc distribution, which requires registering every device by UDID to distribute development builds. Try it out with the new npx testflight package if you use EAS — set "distribution": "store" on your development profile and add "development": {} as a submit profile in eas.json, then then run npx testflight --profile development .
• Expo Modules for TV and macOS improvements: the primary platforms supported by Expo are currently Android, iOS, and web, and we also invest in tvOS and Android TV through the react-native-tvos project. In Expo Orbit, we target macOS with the react-native-macos project and we have built support this platform into parts of the Expo SDK and Expo Modules APIs as needed for our development and maintenance of Orbit. In SDK 53, we added support for macOS AppDelegate subscribers and users can now extend directly from ExpoAppDelegate for an easier setup. Learn more about Expo Module TV and macOS platform support.
• expo-file-system/next now integrates with expo/fetch for file uploads withfile.blob(). Learn more.
• expo-sqlite now includes experimental support for web. It uses a WebAssembly build of SQLite based on wa-sqlite, with a few additions. To learn more about other details of the implementation, see expo#35207. To learn how to use it, refer to the documentation.
• expo-sqlite now supports libsql, and in collaboration with Turso we’ve shipped support for their Offline Sync Public Beta. Give it a try and provide feedback to the Turso team to help the product grow! Learn more in this example repository and its accompanying YouTube video.
• expo-notifications improvements: Following the deprecation of support for push notifications in Expo Go for Android in SDK 52, the feature is no longer supported in Expo Go for Android in SDK 53. Expo Go for iOS continues to work, along with all other environments. We recommend you migrate to a development build if you were using push notifications in Expo Go for Android. We added support for custom images and icons to the Expo Push Service for Android. The iOS implementation has been almost entirely converted to Swift and Expo modules API, making it easier to navigate and further improve — please verify that your notifications features work as expected during the beta, and report any regressions you might find. Additionally, there was a number of bug fixes across both Android and iOS.
• Add import.meta transform plugin. This is an experimental opt-in feature, you can turn it on with the unstable_transformImportMeta option in the babel-preset-expo configuration (example). This was added in order to improve ESM integration and specifically to better support LiveStore.
• AppDelegate has moved from Objective-C to Swift. Config Plugins that modify the AppDelegate source code will need to be updated to make Swift modifications rather than Objective-C.
• Bumped the recommend TypeScript version to ~5.8.3. We also now use this version in the expo repository.
• Experimental opt-in React 19.1 support with improved errors available: you can try it out by toggling experiments.reactCanary to true in your app config.

• Flat config support in eslint-config-expo. npx expo lint now supports flat config. Learn how to migrate.
• package.json exports and imports now enabled by default. This change comes from Metro bundler. This is a breaking change, see “Notable breaking changes” below for additional information.
• Expo Atlas has been promoted from experimental to stable. You can enable it with EXPO_ATLAS=1 npx expo to investigate your JavaScript bundle and improve the app size.
• Added experimental support for web workers on web. This is used in expo-sqlite for multi-threaded web support. Native apps can still use native modules and Reanimated worklets to run JavaScript off the main thread. Learn more.
• Added experimental EAS Update support to Expo DOM components. You can now update your DOM components with eas update — be sure to test this in a staging build before updating your DOM components in production, and report any issues to us.
• Improved error messages. React errors will now print symbolicated stack traces in the Expo CLI logs. This makes it easier to ⌘+click into a file and jump directly to the related line of code.

Error: Couldn't find the bottom tab bar height. Are you inside a screen in Bottom Tab Navigator?

This error is located at:

  20 |
  21 | export default function ParallaxScrollView({
> 22 |   children,
     |           ^
  23 |   headerImage,
  24 |   headerBackgroundColor,
  25 | }: Props) {

Call Stack
  ParallaxScrollView (components/ParallaxScrollView.tsx:22:11)
  HomeScreen(./(tabs)/index.tsx) (<anonymous>)
  Suspense (<anonymous>)
  RCTView (<anonymous>)
  RCTView (<anonymous>)
  RNSScreen (<anonymous>)
  Suspense (<anonymous>)
  RNSScreenNavigationContainer (<anonymous>)
  RCTView (<anonymous>)
  TabLayout (app/(tabs)/_layout.tsx:12:37)

• Added build-time redirects and rewrites. These can be used for customizing the URL and routing behavior of your app and website. This is especially useful for migrating existing projects to Expo Router. Learn more.
• Make authentication and other flows using an initial redirect easier to build. Apps are now wrapped in a virtual root navigator to ensure all navigation events can be processed.
• Improved Fast Refresh and error stack traces in Expo Router to improve development.
• Improved documentation. We're happy to share our much improved new Expo Router documentation. For example, check out the "Router 101" section to shore up your foundational router knowledge.

• expo-av: the Video component was replaced by expo-video in SDK 52 and the Audio API is replaced by expo-audio in SDK 53. The expo-av package will no longer be maintained and we will not publish any new versions for SDK 54 and beyond.
• expo-background-fetch: this has been replaced by expo-background-task, which uses modern platform APIs.

• React 19 comes with some breaking changes, which you can learn more about in the React 19 upgrade guide — note that you may skip over the web-specific instructions in the guide.
• Internal imports in React Native were updated to export syntax. Refer to the examples from the React Native 0.79 blog post to more.
• Updated default AppTheme. New native Android projects and projects generated with CNG is now use the DayNight theme, see: https://github.com/expo/expo/pull/33964. This change was made in order to facilitate the rollout of edge-to-edge layout, for compatibility with react-native-edge-to-edge.
• Deprecated setImmediate polyfill has been removed from the runtime.
• expo-status-bar and expo-navigation-bar are more limited when edge-to-edge is enabled. Only the StatusBar component can be used, none of the imperative methods are available on either module. For now, you can control the navigation bar through the SystemBars API in react-native-edge-to-edge, and we will likely expose that through expo-navigation-bar as well.
• The package.json exports field is now enabled by default in Metro bundler. You can opt out of this in your app by specifying unstable_enablePackageExports: false if you run into related issues (source). If libraries that you depend on are incompatible with this change, it may manifest in subtle ways in your app caused by what’s known as the dual package hazard — your app may end up importing both the ESM and CommonJS versions of a library, and if that library is stateful then you will have two independent copies of it. One way is to analyze your bundle with Expo Atlas. In the following screenshot, there are commonjs and module copies of @react-navigation packages (the issue has already resolved in this particular case, this is only included here as an example). You will be able to identify the dual package hazard in your app by looking for this pattern. Additionally, If you are a library author and use react-native-builder-bob, we recommend following their guide to adapt to this change.

Exploring an app bundle using Expo Atlas, we can see the same source files are included multiple times for a single package, both under “commonjs” and “module”.

• If you use npm, you may encounter installation issues related to peer dependencies, eg: "ERESOLVE could not resolve" / "Could not resolve dependency". This is due to libraries having peer dependencies such as "expo": ">= 52.0.0", which will not match "expo@53.0.0-preview" (due to this quirk of npm). You can work around this using -legacy-peer-deps and/or setting that option in your .npmrc file, or switching to another package manager.
• React 18 peer dependencies can lead to multiple react installations. Many libraries have peer dependencies on React 18 — even though they are likely compatible with React 19. To prevent npm from installing multiple copies of react, which will cause runtime errors, you may need to add overrides to your package.json to ensure every library uses the same single version of React.
• Fix for expo-updates error handling in release builds coming in React Native 0.79.1. React Native 0.79.0 included a regression in an API that expo-updates depends on for handling launch errors in release builds. It was fixed in facebook/react-native#50400 and it will be available in the next patch release. We recommend holding off on production releases with the beta until this is resolved.

• Found an issue? Report a regression.

Note: create-expo-app will install dependencies with the package manager that you are using. For example, with npm when npx is used and yarn when yarn create used.

• Upgrade all dependencies to match SDK 53:

• Install the latest Expo Go for iOS to your physical device: Join the TestFlight External Beta.
• Install the latest Expo Go for Android emulators/physical devices or iOS simulators:
  • Launch your project through Expo CLI (press the a or i keyboard shortcut after running npx expo start) and the updated version of Expo Go will be automatically installed.
• Read the documentation by selecting it from the version selector in the API reference section.

• Upgrade your app with npm install expo@next or yarn add expo@next, then run npx expo install --fix and consult the Native project upgrade helper and report any issues you encounter.
• Build your app with EAS Build, and/or if you have Xcode installed and up to date on your machine and/or Android Studio, try prebuilding your app and running it: npx expo prebuild --clean and npm run ios and npm run android. Alternatively, try out npx expo run. Any new issues? Please report them.
• Did we miss updating the documentation somewhere? Let us know.

• Create an issue and be sure to fill out the appropriate template (and include a minimal reproducible example).
• Figuring out the underlying causes of issues is always super helpful, and it'll help expedite a solution.
• Let us know that you are using the SDK 53 beta so we can prioritize the issue.
• The most helpful beta testers will be listed in the final release notes (and possibly even provided with some Discord flair — you can link your Discord and GitHub accounts to your Expo account).

Thank you for helping us with testing the release — we look forward to shipping it soon! 🚀