Expo SDK 52: Everything You Need to Know

Expo SDK 52: The Biggest Release Yet

Expo SDK 52 landed at the end of 2024 and it is one of the most consequential releases in the framework's history. For years, the community debated when the React Native New Architecture would be stable enough to use in production. With SDK 52, that debate is over — New Architecture is now enabled by default for all new Expo projects, and the ecosystem has caught up to support it.

In this post we'll walk through every meaningful change, what it means for your existing apps, and the migration steps you need to know.

New Architecture is Now the Default

The React Native New Architecture is a complete rewrite of the internals that power React Native. It brings three major components:

JSI (JavaScript Interface) — a new C++ bridge that lets JavaScript directly call native functions without going through the async bridge. This means no more serialisation overhead on every native call.
Fabric — the new rendering engine that makes UI updates synchronous and enables concurrent features from React 18.
TurboModules — a lazy-loading native module system that only initialises modules when they are actually used, dramatically reducing startup time.

In SDK 52, newArchEnabled: true is set by default in app.json. If you are starting a new project, you get all of this for free.

For existing projects upgrading from SDK 51 or earlier, Expo provides a migration guide and the npx expo-doctor tool will flag any libraries in your project that are not yet compatible with the New Architecture.

What this means in practice

On a typical mid-size app with a mix of navigation, lists, and native integrations, you can expect:

20–40% faster startup time due to TurboModules lazy loading
Smoother animations because Fabric renders synchronously with the UI thread
React 18 concurrent features — useTransition, startTransition, and Suspense work as intended

Camera API Fully Rewritten

One of the longest-standing pain points in the Expo ecosystem was expo-camera. The old implementation had platform inconsistencies, limited control over camera modes, and was difficult to extend. SDK 52 ships with a completely rewritten Camera API.

The new API introduces:

import { CameraView, useCameraPermissions } from 'expo-camera';

export function Scanner() {
  const [permission, requestPermission] = useCameraPermissions();

  if (!permission?.granted) {
    return <Button onPress={requestPermission} title="Grant camera access" />;
  }

  return (
    <CameraView
      style={{ flex: 1 }}
      facing="back"
      onBarcodeScanned={({ data, type }) => {
        console.log(`Scanned ${type}: ${data}`);
      }}
    />
  );
}

Key improvements in the new Camera API:

Unified CameraView component for photo, video, and barcode scanning — no more switching between Camera and BarCodeScanner
useCameraPermissions hook for declarative permission handling
Better performance on Android — the new implementation uses CameraX under the hood
Zoom, focus, and flash controls that work consistently across both platforms
Picture-in-picture recording on supported iOS devices

If you are using expo-camera or the old expo-barcode-scanner (which is now deprecated), migrating to CameraView is straightforward and the new API is significantly cleaner.

Expo Router 4

SDK 52 ships with Expo Router v4, which brings several developer experience improvements on top of the file-based routing system.

Typed routes are stable

Typed routes — which give you full TypeScript autocompletion when navigating between screens — are now stable and enabled by default. If you use router.push('/profile') and the route doesn't exist, TypeScript will catch it at compile time.

import { router } from 'expo-router';

// TypeScript now knows every valid route in your app
router.push('/settings/notifications');
router.push('/(tabs)/home');

Stack and Tab improvements

The <Stack> and <Tabs> components now accept screenOptions at the layout level, making it much easier to apply consistent header and tab bar styles across your entire app without repeating configuration on every screen.

API Routes for EAS hosting

Expo Router v4 introduces API routes — server-side route handlers that run on EAS servers. You can now write backend logic directly inside your Expo project:

// app/api/user+api.ts
export async function GET(request: Request) {
  const user = await getUser(request);
  return Response.json({ user });
}

This is particularly useful for webhooks, server-side data fetching, and lightweight API endpoints — without needing a separate backend.

React Native 0.76 Under the Hood

SDK 52 is built on top of React Native 0.76, which brings its own set of improvements:

Box Shadow and Filter CSS properties are now natively supported on iOS and Android. You can use boxShadow and filter in your StyleSheet without a third-party library.
android:windowSoftInputMode improvements make keyboard handling on Android more predictable.
Improved error messages — errors in native modules now include better stack traces and source maps.

`expo-updates` Improvements

Over-the-air updates are a core part of the Expo workflow, and SDK 52 brings meaningful improvements to expo-updates:

Embedded updates are compressed — the initial bundle size shipped inside the app binary is now smaller.
expo-updates hooks let you check for and apply updates programmatically:

import * as Updates from 'expo-updates';

async function checkForUpdate() {
  const update = await Updates.checkForUpdateAsync();
  if (update.isAvailable) {
    await Updates.fetchUpdateAsync();
    await Updates.reloadAsync();
  }
}

Better handling of network failures during update checks — the app no longer hangs if the update server is unreachable.

How to Upgrade

Upgrading from SDK 51 to SDK 52 is straightforward for most projects. The official tool is:

npx expo install expo@^52.0.0 --fix

After running this, check the output of:

npx expo-doctor

This will flag any incompatible packages and suggest the correct versions. For libraries that are not yet New Architecture compatible, you can temporarily opt out by setting newArchEnabled: false in app.json while the library maintainers catch up — though most major libraries are already compatible.

Summary

Expo SDK 52 is a milestone release. New Architecture being the default closes a multi-year chapter and gives every new Expo project a solid performance foundation from day one. The Camera rewrite eliminates one of the ecosystem's most painful APIs, and Expo Router 4's typed routes make navigating large codebases significantly safer.

If you are building a new React Native app in 2025, SDK 52 is the version to start with.

The CodeBaseHub React Native Starter Kit is fully updated to Expo SDK 52 with New Architecture enabled, the new Camera API, and Expo Router v4 typed routes out of the box — so you can skip the migration and start building immediately.