Expo SDK 55 Migration Guide: Every Breaking Change from SDK 53 to 55

Why Upgrading from Expo SDK 53 to 55 Requires Careful Planning

If you're planning an Expo SDK 55 migration from SDK 53 or 54, you're about to navigate one of the most significant transitions the Expo ecosystem has ever seen. I've been through this upgrade on two production apps now, and honestly, the prep work matters more than the actual upgrade commands.

This Expo upgrade guide covers every breaking change, deprecated API, and common pitfall across three major SDK releases. Knowing what's coming before you run that first npx expo install will save you hours of head-scratching.

The journey from SDK 53 to 55 spans React Native 0.79 through 0.83, React 19.0 through 19.2, and — most critically — the permanent switch from the Legacy Architecture to the New Architecture. Whether you're upgrading one SDK at a time (highly recommended) or making a bigger jump, this guide gives you the full picture of what breaks, what changes, and how to fix it.

Before You Start: Essential Preparation Steps

Before touching any dependency versions, take these preparatory steps. Trust me on this — making the migration predictable and reversible will save your sanity.

Create a Migration Branch and Backup

Always work on a dedicated branch. SDK upgrades have a way of cascading into unexpected parts of your codebase, and you'll want a clean rollback point.

git checkout -b upgrade/expo-sdk-55
git push origin upgrade/expo-sdk-55

Audit Your Current Dependencies

Run expo-doctor on your current SDK version first to establish a baseline. Fix any existing warnings before upgrading — they often become hard errors in newer SDK versions.

npx expo-doctor

This tool integrates with React Native Directory to validate your dependencies, identifying unmaintained libraries and those incompatible with the New Architecture. Deal with these findings before you upgrade.

Upgrade Incrementally, Not in One Jump

Expo's official recommendation is to upgrade one SDK version at a time. Going from SDK 53 directly to 55 makes it way harder to pinpoint which version introduced a specific breakage. Plan for three distinct upgrade phases: 53 → 54, then 54 → 55.

Phase 1: Upgrading from Expo SDK 53 to SDK 54

SDK 54 is built on React Native 0.81 and React 19.1. It introduces precompiled XCFrameworks for dramatically faster iOS builds, React Compiler support, and serves as the last SDK to support the Legacy Architecture.

Step-by-Step Upgrade Commands

# Install the new SDK version
npx expo install expo@^54.0.0

# Auto-fix dependency versions to match SDK 54
npx expo install --fix

# Run diagnostics
npx expo-doctor

# If using Continuous Native Generation (CNG), regenerate native directories
rm -rf android ios
npx expo prebuild --clean

# If NOT using CNG, install iOS pods
npx pod-install

Breaking Change: statusBar Removed from app.json

SDK 54 enforces stricter schema validation on your app configuration. The statusBar field is no longer supported in the root or Android config sections of app.json. If you've got entries like these, they need to go:

// REMOVE these from app.json
{
  "expo": {
    "androidStatusBar": {
      "backgroundColor": "#000000"
    }
  }
}

Instead, handle status bar styling programmatically using the expo-status-bar package:

import { StatusBar } from 'expo-status-bar';

export default function App() {
  return (
    <>
      <StatusBar style="light" backgroundColor="#000000" />
      {/* Your app content */}
    </>
  );
}

Breaking Change: Reanimated v3 to v4 Migration

SDK 54 ships with Reanimated v4, which introduces react-native-worklets as a separate dependency and only supports the New Architecture. The most common error developers run into is a duplicate plugin conflict:

// ERROR: Duplicate plugin/preset detected
// react-native-reanimated/plugin AND react-native-worklets/plugin

The fix is straightforward — react-native-worklets/plugin is already bundled inside react-native-reanimated/plugin. Just remove the duplicate from your babel.config.js:

// babel.config.js — SDK 54+
module.exports = function (api) {
  api.cache(true);
  return {
    presets: ['babel-preset-expo'],
    plugins: [
      'react-native-reanimated/plugin',
      // Do NOT add 'react-native-worklets/plugin' — it's included above
    ],
  };
};

Here's a nice bonus: if your babel.config.js only contains babel-preset-expo with no custom plugins, you can delete the file entirely. babel-preset-expo handles Reanimated configuration automatically in SDK 54+.

Breaking Change: JavaScriptCore Engine Removed

React Native 0.81 no longer ships with built-in JSC support. If you were using "jsEngine": "jsc" in your app config, you'll need to either switch to Hermes (the default and recommended engine) or install the community-maintained @react-native-community/javascriptcore package. Fair warning though — the community package doesn't yet provide a config plugin, so manual native project modification may be needed.

Breaking Change: Asset Validation Enforcement

SDK 54 now validates that asset images like android.adaptiveIcon.foregroundImage and icon are perfectly square. Non-square dimensions (e.g., 116×106) that were previously accepted will now throw validation errors.

Make sure all your icon assets are exactly square — 1024×1024 is the recommended size.

Breaking Change: expo-av Deprecation Deadline

While expo-av was deprecated in SDK 53, SDK 54 is the last release where it ships as part of the SDK. You need to start migrating to the replacement packages. Here's how the APIs map:

// OLD: expo-av Audio playback
import { Audio } from 'expo-av';
const sound = new Audio.Sound();
await sound.loadAsync(require('./audio.mp3'));
await sound.playAsync();

// NEW: expo-audio (SDK 54+)
import { useAudioPlayer } from 'expo-audio';

function Player() {
  const player = useAudioPlayer(require('./audio.mp3'));

  return (
    <Button title="Play" onPress={() => player.play()} />
  );
}

// OLD: expo-av Video
import { Video } from 'expo-av';
<Video source={require('./video.mp4')} />

// NEW: expo-video (SDK 54+)
import { VideoView, useVideoPlayer } from 'expo-video';

function VideoPlayer() {
  const player = useVideoPlayer(require('./video.mp4'));
  return <VideoView player={player} style={{ width: 350, height: 200 }} />;
}

New Feature: Precompiled XCFrameworks for iOS

This one's genuinely exciting. SDK 54 ships React Native and its dependencies as precompiled XCFrameworks, reducing clean iOS build times from roughly 120 seconds to about 10 seconds on an M4 Max. That's not a typo — it's that dramatic of a difference. And it's automatic, no configuration changes needed.

New Feature: React Compiler

You can now enable the stable React Compiler for automatic memoization by adding this to your app.json:

{
  "expo": {
    "experiments": {
      "reactCompiler": true
    }
  }
}

New Feature: expo-file-system Overhaul

The expo-file-system/next API is now the default export. If you were using the old API, update your imports:

// Quickest migration path — use the legacy import
import * as FileSystem from 'expo-file-system/legacy';

// Recommended: migrate to the new object-oriented API
import { File, Directory } from 'expo-file-system';

const file = new File('data', 'config.json');
await file.write(JSON.stringify({ theme: 'dark' }));

Common Issue: App Stuck on Splash Screen

This was probably the most frustrating issue I hit. After upgrading from SDK 53 to 54, the app just sits on the splash screen in development builds. Uninstalling and reinstalling doesn't always fix it. The actual solution is to create a fresh development build from scratch:

# Delete existing native directories and rebuild
rm -rf android ios node_modules
npm install
npx expo prebuild --clean
npx expo run:ios  # or npx expo run:android

Common Issue: Unhandled Promise Rejection Errors

After upgrading to SDK 54, you might notice new promise rejection errors that weren't visible before. Don't panic — these aren't new bugs. React Native now properly surfaces unhandled promise rejections as errors, aligning with browser behavior. You just need to add proper .catch() handlers or try/catch blocks to your async code.

Phase 2: Upgrading from Expo SDK 54 to SDK 55

SDK 55 is built on React Native 0.83.1 and React 19.2.0. This is the big one — the New Architecture becomes mandatory and several long-deprecated features are fully removed.

Step-by-Step Upgrade Commands

# For the stable release
npx expo install expo@^55.0.0
npx expo install --fix

# For beta (if stable is not yet released)
npx expo install expo@next --fix

# Run diagnostics
npx expo-doctor

# Regenerate native code
npx expo prebuild --clean

# Test on both platforms
npx expo run:ios
npx expo run:android

Breaking Change: Legacy Architecture Permanently Removed

This is the single most impactful change in SDK 55. The Legacy Architecture can't be enabled — period. The newArchEnabled config option has been removed from app.json. If you still have it in your config, it'll be ignored, but remove it to avoid confusion.

// REMOVE from app.json
{
  "expo": {
    "newArchEnabled": true  // This property no longer exists — delete it
  }
}

If any of your third-party libraries don't support the New Architecture, you've got three options:

1. Check if the library has published a New Architecture-compatible version
2. Use the interop layer, which allows many older libraries to work transparently with the New Architecture
3. Find an alternative library — run npx expo-doctor for compatibility reports

Breaking Change: Unified Package Versioning

Starting with SDK 55, all Expo SDK packages use the same major version number as the SDK. So expo-camera compatible with SDK 55 is ^55.0.0, not some separate version number. This makes it trivially easy to spot version mismatches at a glance — and honestly, this is a change I've been wanting for years.

// package.json — SDK 55 dependency examples
{
  "dependencies": {
    "expo": "^55.0.0",
    "expo-camera": "^55.0.0",
    "expo-notifications": "^55.0.0",
    "expo-router": "^55.0.0",
    "expo-video": "^55.0.0"
  }
}

Breaking Change: notification Field Removed from app.json

Following its deprecation in SDK 54, the notification configuration field has been completely removed from app.json. Specifying it will throw an error during prebuild. Migrate all notification configuration to the expo-notifications config plugin:

// OLD — app.json (no longer works in SDK 55)
{
  "expo": {
    "notification": {
      "icon": "./assets/notification-icon.png",
      "color": "#ffffff"
    }
  }
}

// NEW — app.json (SDK 55+)
{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "icon": "./assets/notification-icon.png",
          "color": "#ffffff"
        }
      ]
    ]
  }
}

Breaking Change: expo-av Removed from Expo Go

expo-av has been fully removed from Expo Go and isn't receiving patches anymore. If you haven't migrated to expo-video and expo-audio yet, now's the time. The package could stop working at any point since it won't receive updates for React Native 0.83 compatibility.

Breaking Change: expo-blur API Overhaul

SDK 55 introduces a new blur implementation using the RenderNode API on Android 12+, which offers significantly better performance. However, it requires wrapping your blurrable content in a <BlurTargetView>:

// OLD — expo-blur (SDK 54 and earlier)
import { BlurView } from 'expo-blur';

<BlurView intensity={50} style={styles.blur}>
  <Text>Blurred content</Text>
</BlurView>

// NEW — expo-blur (SDK 55+, Android 12+)
import { BlurView, BlurTargetView } from 'expo-blur';

<BlurTargetView>
  <Image source={backgroundImage} style={styles.background} />
</BlurTargetView>
<BlurView intensity={50} style={styles.blur}>
  <Text>Overlay content</Text>
</BlurView>

Worth noting: this change is technically non-breaking for existing code, but adopting the new API gives you substantial performance gains on Android.

Breaking Change: @expo/ui API Renames

Several components in the @expo/ui library have been renamed to align with native platform conventions:

• DateTimePicker is now DatePicker (with added range support)
• Switch is now Toggle
• CircularProgress and LinearProgress are merged into ProgressView (using a progressViewStyle modifier)
• Section now uses a title prop and isExpanded state
• Form replaces scrollEnabled with a scrollDisabled modifier

Breaking Change: Native Tabs API Restructuring

If you use the Native Tabs API, the Icon, Label, and Badge sub-components have moved:

// OLD (SDK 54)
import { Icon, Label, Badge } from 'expo-router/native-tabs';

// NEW (SDK 55)
import { NativeTabs } from 'expo-router';

// Access via NativeTabs.Trigger.*
<NativeTabs.Trigger.Icon />
<NativeTabs.Trigger.Label />
<NativeTabs.Trigger.Badge />

Breaking Change: Push Notifications in Expo Go (Android)

Attempting to use push notifications in Expo Go on Android now throws an error instead of just a warning. This was first announced in SDK 53 and is now fully enforced. You must use a development build for push notification testing:

# Create a development build for notification testing
npx expo install expo-dev-client
eas build --profile development --platform android

New Default Project Template

SDK 55 introduces a redesigned default template that moves application code from /app to /src/app and uses the Native Tabs API for a platform-native tab experience. Existing projects don't need to adopt this structure, but new projects created with npx create-expo-app will use it by default.

New Features Worth Adopting in SDK 55

expo-widgets: iOS Home Screen Widgets and Live Activities

The new expo-widgets package (still in alpha) lets you build iOS Home Screen Widgets and Live Activities using Expo UI components — no Swift code required:

import { updateLiveActivity, createLiveActivity } from 'expo-widgets';

// Start a Live Activity
const activity = await createLiveActivity({
  data: {
    orderStatus: 'preparing',
    estimatedDelivery: '12:30 PM',
  },
});

// Update it later
await updateLiveActivity(activity.id, {
  data: {
    orderStatus: 'on-the-way',
    estimatedDelivery: '12:15 PM',
  },
});

expo-brownfield: Better Native App Integration

The expo-brownfield package simplifies adding Expo to existing native apps. You develop your React Native code separately and package it as a native library (AAR for Android, XCFramework for iOS) that native developers can consume without needing React Native build tools. This is a game-changer if you're working in a team with dedicated native developers.

Hermes v1 Opt-In and Smaller OTA Updates

SDK 55 offers Hermes v1 as an opt-in engine upgrade and introduces Hermes bytecode diffing for smaller over-the-air updates. Your EAS Update payloads will be significantly smaller, which means faster downloads for your users.

AI-Assisted Upgrades via MCP

This is a pretty cool addition. The Expo CLI now exposes commands to AI agents through the Model Context Protocol (MCP). Tools like Claude Code can read the migration guide, analyze your codebase, update dependencies, fix breaking changes, and run prebuild automatically:

# Add the Expo upgrade skill to your AI tool
# Claude Code users can install the Expo skills plugin:
npx expo skills install upgrading-expo

Colors API for Material 3 and Adaptive iOS Colors

A new Colors API lets you add dynamic Material 3 styles on Android and adaptive colors on iOS, giving your app a native look without manual theme configuration.

Apple Zoom Transition

SDK 55 adds support for interactive shared element transitions on iOS using the native zoom transition and gestures. It's enabled by default and provides fluid, platform-native navigation transitions.

Complete Dependency Version Reference

Here's a quick reference table showing the core dependency versions across all three SDK versions:

Dependency	SDK 53	SDK 54	SDK 55
React Native	0.79.x	0.81.x	0.83.1
React	19.0.0	19.1.0	19.2.0
Hermes	Default	Default	Default (v1 opt-in)
Reanimated	~3.17.x	~4.1.x	~4.x.x
New Architecture	Default on	Default on (last Legacy)	Mandatory
React Compiler	Not available	Stable (opt-in)	Stable
Node.js Required	20+	20+	20+

Post-Upgrade Verification Checklist

After completing each phase of the upgrade, run through this checklist to catch issues early:

1. Run npx expo-doctor — Verify all dependencies are compatible with the new SDK version
2. Clear all caches — Metro, Gradle, and CocoaPods caches can hold stale data:

   npx expo start --clear
   cd android && ./gradlew clean
   cd ios && pod cache clean --all

3. Test on both platforms — Some breaking changes are platform-specific (the blur API only affects Android 12+, for instance)
4. Test production builds — Dev builds can mask issues that only surface in release mode:

   npx expo run:ios --configuration Release
   npx expo run:android --variant release

5. Verify OTA updates — If you use EAS Update, publish a test update and verify it applies correctly on both platforms
6. Check third-party library compatibility — Especially for SDK 55, make sure all native libraries support the New Architecture

Troubleshooting Common Migration Errors

How to Fix "should NOT have additional property" Errors

SDK 54+ enforces strict schema validation on app.json. If you see errors like should NOT have additional property 'statusBar' or should NOT have additional property 'notification', you've got deprecated fields in your config. Remove them and use the corresponding programmatic APIs or config plugins instead.

How to Fix Metro Bundler "attempted to import Node standard library" Errors

React Native 0.79 (SDK 53) enabled package.json exports by default in Metro. This can cause dual-package hazard errors where your app imports both ESM and CommonJS versions of a library. The fix is to either update the problematic library or add a resolution in your metro.config.js:

// metro.config.js
const { getDefaultConfig } = require('expo/metro-config');

const config = getDefaultConfig(__dirname);

// Force specific module resolution if needed
config.resolver.unstable_enablePackageExports = true;

module.exports = config;

How to Fix Build Failures After Reanimated Upgrade

If your Android or iOS build fails after upgrading Reanimated from v3 to v4 (SDK 53 to 54), try these steps in order:

1. Remove react-native-worklets/plugin from babel.config.js if present
2. Delete babel.config.js entirely if it only contains babel-preset-expo
3. Clean rebuild: rm -rf node_modules android ios && npm install && npx expo prebuild --clean
4. If you must stay on Legacy Architecture temporarily, pin Reanimated v3: npx expo install react-native-reanimated@~3.17.4

How to Fix "New Architecture Required" Errors in SDK 55

If a third-party library throws New Architecture compatibility errors in SDK 55, first check for an updated version. If none exists, try the interop layer — many older libraries work transparently through it. As a last resort, consider replacing the library with a New Architecture-compatible alternative. Run npx expo-doctor for specific compatibility guidance.

How to Handle Unhandled Promise Rejection Crashes

SDK 54+ surfaces unhandled promise rejections as proper errors. If your app starts crashing after the upgrade, you'll need to wrap your async operations properly:

// Before — silent failure
async function fetchData() {
  const response = await fetch('https://api.example.com/data');
  const json = await response.json();
  return json;
}

// After — proper error handling
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error('Failed to fetch data:', error);
    return null;
  }
}

Migrating Your EAS Build Configuration

If you use EAS Build, your eas.json configuration may need updates as you progress through SDK versions. Here are the key changes for each phase.

EAS Build Profile Updates for SDK 54

SDK 54's precompiled XCFrameworks should work automatically with EAS Build. Just make sure your build profiles use compatible Node and Xcode versions:

{
  "build": {
    "production": {
      "node": "20.18.0",
      "ios": {
        "image": "macos-ventura-14.5-xcode-16.2"
      },
      "android": {
        "image": "ubuntu-24.04-jdk-21-ndk-27"
      }
    },
    "development": {
      "developmentClient": true,
      "distribution": "internal"
    }
  }
}

EAS Build Profile Updates for SDK 55

With SDK 55, the New Architecture is always on. Remove any env variables or build arguments that attempted to control the architecture setting. If you had separate build profiles for Legacy and New Architecture testing, you can consolidate them:

// REMOVE from eas.json if present
{
  "build": {
    "legacy-arch": {       // Delete this profile entirely
      "env": {
        "EXPO_USE_LEGACY_ARCH": "1"  // No longer functional
      }
    }
  }
}

EAS Update and Hermes Bytecode Diffing

SDK 55 introduces Hermes bytecode diffing for OTA updates. This means your update payloads will be significantly smaller because only the changed bytecode instructions get transmitted rather than the entire bundle. No configuration changes needed — this kicks in automatically when you publish updates with eas update.

To verify the size improvement, compare update sizes before and after your SDK 55 upgrade:

# Publish an update and check the size
eas update --branch production --message "SDK 55 upgrade"

# Check update details
eas update:list --branch production --limit 5

Managing Third-Party Library Compatibility

Let's be real — the most challenging aspect of any Expo SDK upgrade is making sure third-party libraries still work. Here's a structured approach for managing this across the SDK 53 to 55 journey.

Identifying Incompatible Libraries

Before upgrading, generate a full compatibility report:

# Run a full dependency audit
npx expo-doctor

# Check specific libraries against React Native Directory
npx expo-doctor --check-react-native-directory

Pay special attention to libraries that:

• Use native modules but haven't published New Architecture-compatible versions
• Depend on JavaScriptCore-specific behavior (relevant for SDK 54+)
• Haven't been updated in the last 6 months
• Use deprecated Expo APIs like expo-av internally

The New Architecture Interop Layer

The interop layer is your best friend during this migration. It allows many libraries built for the Legacy Architecture to work transparently with the New Architecture. The layer was introduced alongside the New Architecture and remains available in SDK 55. That said, it's not a permanent solution — libraries should eventually migrate to native Fabric and TurboModule support.

To check if a specific library works through the interop layer, just install it and test. If it throws a TurboModuleRegistry error, the library likely needs a native update.

Common Library Migration Paths

Here are migration paths for frequently used libraries that changed between SDK 53 and 55:

• react-native-reanimated: v3.17.x (SDK 53) → v4.1.x (SDK 54+). The babel-preset-expo handles plugin configuration automatically.
• react-native-gesture-handler: ~2.24.0 (SDK 53) → ~2.28.0+ (SDK 54+). Generally backward compatible, but test your custom gesture handlers.
• react-native-safe-area-context: 5.4.0 (SDK 53) → ~5.6.0+ (SDK 54+). API is stable, but make sure edge-to-edge layout works correctly on Android.
• expo-camera: ~16.x (SDK 53) → ~17.x (SDK 54) → ~55.x (SDK 55). Note the version scheme change in SDK 55.
• @react-navigation/native: Make sure you're on v7+ which fully supports the New Architecture.

Testing Your Migration Thoroughly

A successful SDK upgrade goes beyond "it builds and runs." Here's a more comprehensive testing strategy for each upgrade phase.

Automated Testing After Upgrade

Run your full test suite after each SDK version bump. Pay particular attention to tests that interact with native modules, animations, or navigation:

# Run unit tests
npx jest --no-cache

# Run end-to-end tests with Maestro
maestro test .maestro/

# If using Detox
detox build --configuration ios.sim.release
detox test --configuration ios.sim.release

Manual Testing Checklist

Beyond automated tests, manually verify these areas that are most commonly affected by SDK upgrades:

1. Navigation transitions: Verify that all screen transitions animate correctly, especially if using Reanimated-powered custom transitions
2. Push notifications: Test both foreground and background notification handling on real devices (not Expo Go for Android in SDK 55)
3. Deep links: Verify all deep link routes resolve correctly after the Expo Router version bump
4. Camera and media: If you migrated from expo-av, test all audio and video playback scenarios including background audio
5. File operations: If you migrated from the legacy expo-file-system API, verify all read, write, and download operations
6. Animations: Test all Reanimated-powered animations, especially shared element transitions and layout animations
7. Android edge-to-edge: Verify your UI properly accounts for system bars and the navigation gesture area
8. Keyboard handling: Test all input forms and ensure keyboard avoidance works correctly

Configuration Cleanup Checklist for SDK 55

After reaching SDK 55, clean up your configuration by removing properties and files that are no longer needed:

• Remove sdkVersion from app.json — Expo manages this automatically based on your installed expo package version
• Remove newArchEnabled from app.json — The New Architecture is always enabled in SDK 55
• Remove notification from app.json — Use the expo-notifications config plugin instead
• Remove statusBar from app.json — Use the expo-status-bar package programmatically
• Remove implicit dependencies from package.json — Packages like @babel/core, babel-preset-expo, and expo-constants are managed internally
• Delete babel.config.js if it only contains babel-preset-expo — This is the default and doesn't need to be specified
• Update expo-file-system imports from expo-file-system/next to expo-file-system — The new API is now the default

Frequently Asked Questions

Can I skip SDK 54 and upgrade directly from SDK 53 to 55?

While technically possible, it's strongly discouraged. Expo recommends upgrading one SDK version at a time. The jump from 53 to 55 spans two React Native major versions (0.79 to 0.83), Reanimated v3 to v4, and the complete removal of the Legacy Architecture. Upgrading incrementally makes it way easier to figure out which change caused a specific issue.

What happens to my app if I don't migrate from the Legacy Architecture?

You can keep using SDK 54 with the Legacy Architecture, but you won't receive new features, security patches, or React Native updates beyond 0.81. The Legacy Architecture was frozen in June 2025 — no new features or bugfixes are being developed for it. Over 83% of EAS Build projects were already using the New Architecture as of January 2026, and the interop layer means most older libraries continue to work.

How do I check if my third-party libraries support the New Architecture?

Run npx expo-doctor — it integrates with React Native Directory to validate your dependencies and report which libraries are incompatible or untested with the New Architecture. You can also check reactnative.directory directly, which marks each library's New Architecture compatibility status.

Why is my development build stuck on the splash screen after upgrading to SDK 54?

This is a known issue when upgrading from SDK 53 to 54. The most reliable fix is to create a completely fresh development build: delete android, ios, and node_modules directories, reinstall dependencies, run npx expo prebuild --clean, and build again. Simply uninstalling and reinstalling the app on the device usually isn't enough.

Do I need to rewrite my entire expo-av usage at once?

Nope. You can migrate incrementally. In SDK 54, expo-av still functions but is no longer part of the official SDK. Starting with SDK 55, it's removed from Expo Go entirely. The pragmatic approach is to first migrate video components to expo-video (which tends to be the more common use case) and then tackle audio with expo-audio. Both new APIs use React hooks, making them more idiomatic and easier to work with in modern React.