Expo SDK 57 Upgrade Guide

What Is Expo SDK 57?

Expo SDK 57 is the latest Expo release, shipping with React Native 0.75, React 19.3, and significant improvements to routing, EAS Build, performance, and developer tooling. It's a stable, production-ready release designed for teams building and shipping apps at scale.

This SDK marks the continuation of Expo's focus on developer experience and production reliability. Every feature has been tested through the Expo ecosystem, and breaking changes have been flagged early with deprecation warnings in prior SDKs.

What's New in Expo SDK 57

React Native 0.75 and React 19.3

SDK 57 bumps to React Native 0.75 and React 19.3, bringing:

• Improved bridging performance: React Native's new bridge batching reduces JS-to-native communication overhead, especially noticeable in animation-heavy apps.
• Better error boundaries: React 19.3 improves error boundary recovery and dev error messages in ways that make debugging production issues faster.
• New React hooks: useFormStatus and useFormState are now available for form handling in React Native via the JS SDK pattern.
• Experimental async component support: Foundation laid for Server Components in React Native contexts.

Expo Router Enhancements

Router receives major usability upgrades:

• Native navigation state persistence: Tab and stack navigation state now persists by default on native platforms, matching web behavior. This solves the "app reset on deep link" problem.
• Route-level logging: Debug expo-router navigation with EXPO_ROUTER_DEBUG=true to see exact navigation transitions in the Metro console.
• Improved modal dismissal: Modal stack handling now respects OS-level swipe gestures uniformly across iOS and Android.
• Search parameter validation: Define expected search params in route components and get warnings if params are missing or malformed.
• Deep link interceptors: New hook useDeepLinkInterceptor lets you intercept and modify deep links before navigation, enabling analytics, auth checks, and redirects.

EAS Build and Update Improvements

• Faster incremental builds: EAS now caches more aggressively—native library layers, compiled Java/Kotlin, and Swift modules are cached between builds. Subsequent builds for the same branch are 40–60% faster.
• EAS Update batching: Push multiple updates in a single command and schedule rollbacks with a new eas update --batch mode.
• Build log search: New eas build logs --search="pattern" command makes debugging build failures faster.
• Improved build secrets management: Secrets are now scoped by environment and build profile, reducing the risk of accidentally shipping wrong credentials.

New Expo APIs

• expo-camera v16.0: New useCameraPermissions hook replaces the older promise-based API. Camera streaming is now smoother on Android.
• expo-image v1.8: Advanced image loading strategies: progressive JPEG support, adaptive format selection (WebP on Android, HEIC on iOS), and blurred placeholder rendering before the full image loads.
• expo-haptics v13.0: New useHapticFeedback hook and support for custom haptic patterns on supporting devices.
• expo-notifications v17.0: Notification scheduling now supports recurring notifications and custom sound playback.
• Expo Symbols: New symbol-based icon system in addition to vector icons—useful for building native-looking interfaces quickly.

Developer Experience Improvements

• Faster Metro startup: Metro bundler now starts 25% faster on cold start due to improved module resolution caching.
• Improved type checking: Better TypeScript support in expo config files and new type stubs for Expo modules.
• Dev client improvements: Development builds now auto-reload after a crash if possible, reducing manual rebuilds during active development.
• Expo Go parity: More Expo Go-compatible APIs in SDK 57, making it easier to test before committing to a development build.

Platform Requirements

• iOS: Requires iOS 13.4+ (unchanged from SDK 56)
• Android: Requires Android 8 (API 26) and higher; Android 15 (API 35) support added
• Xcode: Xcode 15.4 or later required (was 15.0)
• Node.js: 18 LTS or later (was 16 minimum)
• EAS CLI: Update to version 12.0+ (major version bump for compatibility)

Breaking Changes in SDK 57

Removed APIs and Deprecations

• expo-permissions removed: The legacy permissions API is gone. Use expo-camera, expo-location, expo-media-library, and their respective permission hooks instead.
• expo-keep-awake moved: Functionality merged into expo-power-mode. Update imports and check the migration guide if you're using this.
• Unsafe file operations in Managed Workflows: Direct file system writes outside of document and cache directories now throw errors in managed workflows. Use expo-file-system utilities or migrate to a development build if you need raw file access.

Expo Router Breaking Changes

• Router history API changed: The internal navigation history is now immutable. If you were accessing navigation.getState().history directly, migrate to the new useNavigationHistory hook.
• Modal presentationStyle defaults: Modals now default to pageSheet on iOS instead of formSheet. Update your app.json or component options if you relied on the old default.
• Search params must be serializable: Complex objects in search params are no longer silently stringified. Pass JSON strings explicitly or use the new param validation.

Package Updates and Versions

• React Navigation now 6.1+: If you have custom navigators or reach into React Navigation internals, test those carefully.
• Reanimated 3.15+ required: Older Reanimated versions are not compatible. If you're on Reanimated 2.x, you must upgrade.
• Gesture Handler 2.17+: Swipe-based navigation gestures have been reworked.
• TypeScript 5.4+: TypeScript 4.9 is no longer supported in projects using SDK 57 types.

EAS and Build Tooling

• EAS CLI 12.0 required: Old EAS CLI versions will not work with SDK 57 builds. Run npm install -g eas-cli@latest.
• app.json config changes: The runtimeVersion field now must be a string if specified. Objects are no longer supported (though expo-updates still understands them at runtime).
• Custom Gradle scripts: Android build scripts using deprecated Gradle APIs will fail. Test builds locally before pushing to CI.

Environment Variables and Secrets

• EXPO_PUBLIC_ prefix stricter: Variables prefixed with EXPO_PUBLIC_ are now validated to ensure they don't contain sensitive patterns (API keys, tokens). Violations will fail the build.
• Secrets no longer available at build time by accident: If you relied on a secret being available as an env var during a managed build, it will now fail. Use EAS secret variables explicitly in your build profile.

Step-by-Step Upgrade Guide

1. Create an Upgrade Branch and Back Up

Start with a clean git state. If you have uncommitted changes, stash or commit them first.

Create a backup or tag the current state so you can revert if needed:

2. Update Expo and Expo CLI

Update the Expo CLI globally first, then install SDK 57 in your project:

If you use yarn:

3. Install and Fix Compatible Packages

Let Expo's package installer resolve compatible versions for all Expo modules:

This command:

• Updates all Expo modules to SDK 57–compatible versions
• Pins React and React Native to tested versions
• Checks for known incompatibilities and warns you

4. Run Expo Doctor

Expo Doctor scans your project and catches common issues after an upgrade:

Common warnings and how to fix them:

• Mismatched peer dependencies: Update the flagged package or check if it's optional.
• Native module incompatibilities: Some modules may need upgrades; check the package's changelog for SDK 57 support.
• Config plugin version mismatches: If you use config plugins, ensure they're updated.

If Expo Doctor complains about something, address it before moving forward. Those warnings often hide real upgrade problems.

5. Update App Config (app.json)

Review your app.json for SDK 57 changes:

• Ensure runtimeVersion is a string (not an object).
• Verify all config plugins are listed and their versions are compatible.
• Check platform-specific settings for iOS and Android.

6. Migrate Router Code (if using Expo Router)

If your app uses Expo Router, apply the official migration codemod:

This codemod updates:

• History API usage to the new useNavigationHistory hook
• Modal presentation styles to new defaults
• Deep link handling patterns

After running the codemod, manually test navigation—especially tab switching, modal dismissal, and deep links. Codemod migrations are usually correct but navigation logic can be subtle.

7. Clear Metro Cache and Rebuild

Before testing, clear the Metro bundler cache and iOS build artifacts:

A clean prebuild ensures native modules and config plugins are rebuilt against SDK 57 dependencies.

8. Test Thoroughly Before Release

Load your development build on a real device and walk through critical user paths:

• App launch and initial navigation
• Authentication and session state
• File uploads or downloads (if your app uses them)
• Camera, location, notifications (if used)
• Push notifications end-to-end
• Payments or in-app purchases
• Deep links and push notification taps
• Media playback and permissions

Run your unit and integration test suite:

9. Create a Staging EAS Update

Before releasing to production, test an over-the-air update:

Load the staging build on a test device and verify the OTA update lands and runs correctly.

10. Merge and Release

Once testing is complete:

Create a pull request, have it reviewed (especially diffs to package.json, app.json, and native config), then merge and cut a release build.

Compatibility Matrix

Use this table to plan which packages to upgrade for SDK 57:

Migration Checklist

Use this checklist before deploying SDK 57 to production:

• Created upgrade branch and backed up current SDK
• Updated Expo and EAS CLI globally
• Ran npm install expo@^57.0.0 && npx expo install --fix
• Ran npx expo-doctor and resolved all warnings
• Updated app.json config (runtimeVersion as string, plugins verified)
• Ran Router migration codemod (if using Expo Router)
• Tested code compiles with no TypeScript errors
• Cleared Metro cache and ran npx expo start --clear
• Built and tested on iOS device
• Built and tested on Android device
• Tested authentication and session state
• Tested push notifications end-to-end
• Tested deep links and navigation
• Ran full test suite (npm test)
• Tested critical user flows (payments, uploads, etc.)
• Created staging EAS Update and verified OTA works
• Reviewed Git diff for app.json and package.json changes
• Merged PR and ran CI/CD pipeline

Troubleshooting Common Issues

Metro Cache Issues

Solution: Clear all Metro caches:

Then restart the dev server and rebuild development builds.

Native Build Failures

Solution: Rebuild native dependencies from scratch:

The --clean flag forces EAS to rebuild everything, skipping caches. First clean build will be slow but subsequent builds use the cache again.

EAS Build Failures After SDK 57 Upgrade

Solution:

• Ensure EAS CLI is updated: npm install -g eas-cli@latest
• Check app.json for any config that changed (runtimeVersion format, plugins, etc.)
• Review EAS build logs: eas build logs --search="error"
• If using secrets, verify they're scoped to the right build profile: eas secret list

Dependency Conflicts

Solution:

Then verify with npx expo-doctor that nothing critical is incompatible. If a package truly doesn't support SDK 57, you may need to find an alternative or file an issue with the maintainer.

TypeScript Errors

Solution: Update TypeScript and rebuild type definitions:

CocoaPods Lock Issues (iOS)

Solution:

Android Gradle Issues

Solution:

If problems persist, ensure your build.gradle and settings.gradle use compatible Gradle and plugin versions. The npx expo prebuild command generates these files based on your Expo config, so regenerating them usually fixes version mismatches.

Should You Upgrade to SDK 57?

Upgrade Immediately If:

• Your app is currently in early development or pre-launch
• You want EAS Build performance improvements (40–60% faster incremental builds)
• You're using Expo Router and want native state persistence and deep link interceptors
• You need the latest React Native and React features
• Your team is comfortable with breaking changes and has time to test thoroughly

Take Your Time If:

• You're in active production support for an SDK 56 app—stability comes first
• You have a small team and limited testing bandwidth
• Your app relies heavily on custom native modules or config plugins—wait a few weeks for the ecosystem to update
• You're near a critical deadline or release; schedule the upgrade after launch

Wait If:

• Your app is in a maintenance phase and doesn't need new features
• Critical packages you depend on haven't announced SDK 57 support yet
• You've found stability issues in your current SDK 56 setup and want to avoid risk

General guidance: SDK 57 is stable and production-ready. Most teams can upgrade within 2–4 weeks of release. Set aside time for testing, run the migration checklist, and don't rush it into production.

Frequently Asked Questions

Is Expo SDK 57 stable and production-ready?

Yes. Expo SDK 57 is a stable, production-ready release. It ships with tested packages and the Expo team uses it internally for production apps. That said, always test your own app thoroughly before releasing.

Does Expo SDK 57 require React Native 0.75?

Yes. SDK 57 is pinned to React Native 0.75.x. If you need React Native 0.74 or earlier, stay on SDK 56.

Can I skip SDK 56 and go straight from 55 to 57?

Technically, yes—Expo supports skipping minor versions. But I recommend upgrading one SDK at a time. Jumping two versions at once makes debugging much harder if something breaks. You'll spend more time hunting for which SDK introduced the issue.

Does Expo Go support SDK 57?

Expo Go has limited support for SDK 57. Some new APIs (like the camera hooks and image streaming) require a development build. For serious development, use eas build --profile development to create a dev build instead of relying on Expo Go.

What happens if I skip the router codemod?

If you don't run the Router migration codemod and your app uses the old history API, your app will crash at runtime with a clear error pointing to the missing hook. The codemod saves you from debugging that. It's worth running even if you think your app doesn't use the history API.

Do I have to upgrade EAS CLI to 12.0?

Yes. EAS CLI 11.x and earlier won't recognize SDK 57 projects and will fail. Run npm install -g eas-cli@latest to update.

Are there performance improvements?

Yes. Metro starts 25% faster, React Native 0.75 bridges are more efficient, and EAS incremental builds are 40–60% faster because of aggressive caching. Most users notice faster development iteration and shorter build times.

What's the migration path for my custom native modules?

Custom native modules usually just work if they're compiled against the same React Native version (0.75). Test them in a development build. If a module breaks, check its GitHub issues or documentation for SDK 57 guidance, or consider opening an issue with the maintainer.

Can I downgrade back to SDK 56 if SDK 57 breaks my app?

Yes, but it's not seamless. You'll need to downgrade packages, run npx expo install --fix, rebuild native projects, and test again. This is why creating a backup branch before upgrading is important. If you've already deployed SDK 57 to production and need to roll back, use eas update to push a compatible build while you fix the issue on the SDK 57 branch.

How do I test an EAS Update for SDK 57?

Build a development or production build with SDK 57, install it on a device, then push an update:

Open the app and it will pull the update. Check the console for update events and verify the update lands correctly.

What about Firebase compatibility with SDK 57?

Firebase (via the JS SDK or Firebase Auth and Firestore for Expo) works perfectly with SDK 57. No changes needed on your end—just upgrade Expo and test.

Conclusion

Expo SDK 57 brings meaningful improvements to React Native development: faster builds, better routing, more reliable OTA updates, and access to React 19.3 and React Native 0.75 features. While there are breaking changes, they're well-documented and easy to address with the migration codemod and this guide.

The key to a smooth upgrade:

1. Start on a branch
2. Follow the step-by-step guide
3. Use the migration checklist
4. Test thoroughly on real devices
5. Don't rush into production

If you're using EAS Build with environment variables, Firebase Hosting with GitHub Actions, or Expo push notifications, the upgrade won't affect those workflows—they'll just get faster and more reliable.

Plan your upgrade, run the tests, and ship with confidence. Welcome to SDK 57.