Saltar al contenido

Arquitectura nueva de React Native: cómo migrar desde la 0.81 y el SDK 54

En la práctica/ 12 min de lectura

Desde la 0.82 la arquitectura vieja ya no se puede activar. El camino seguro desde la 0.81 o el SDK 54 de Expo y cómo revisar antes tus librerías nativas.

  • React
  • Migración
En este artículo (8)
  1. Qué cambió en la 0.82: React Native solo usa la arquitectura nueva
  2. Fabric, TurboModules y JSI en una tabla
  3. El camino: 0.81 o SDK 54, activar la nueva, probar librerías y subir
  4. Cómo saber si una librería es compatible
  5. Qué hacer si no es compatible
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Desde React Native 0.82 la arquitectura vieja ya no se puede activar: la arquitectura nueva (Fabric, TurboModules y JSI) es la única. La última versión que permite las dos es la 0.81, y en Expo el SDK 54. El camino seguro: sube a esa versión, activa la nueva, prueba tus librerías y después actualiza.

Hoy, 19 de noviembre de 2026, la versión más reciente es React Native 0.88 (19 de octubre de 2026) y el SDK 58 de Expo ya la incluye. Si tu app sigue en la arquitectura vieja, cada versión que pasa te deja más lejos. Aquí está qué cambió, el orden de la migración y un script que revisa qué librerías nativas tienes que mirar a mano.

Qué cambió en la 0.82: React Native solo usa la arquitectura nueva

El anuncio de React Native 0.82, del 8 de octubre de 2025, lo dice sin rodeos: la arquitectura nueva es la única para esa versión y las siguientes. Si pones newArchEnabled=false en Android o instalas los pods con RCT_NEW_ARCH_ENABLED=0 en iOS, esas opciones se ignoran y la app corre igual con la nueva. No hay error que te avise: simplemente ya no hay interruptor.

El mismo anuncio nombra a la 0.81 y al SDK 54 de Expo como las últimas versiones que permiten la arquitectura vieja, y recomienda migrar primero ahí. Expo lo confirma en las notas del SDK 54 (10 de septiembre de 2025): es el último SDK con soporte para la arquitectura vieja. En el SDK 55 (25 de febrero de 2026, con React Native 0.83) la opción newArchEnabled desapareció de app.json.

Después vino la limpieza. Según el anuncio de React Native 0.84, desde esa versión el código de la arquitectura vieja ya no entra en los builds de iOS por defecto, y en Android se eliminaron varias clases, como LazyReactPackage y BridgeDevSupportManager. La capa de compatibilidad (interop layer), que deja correr librerías escritas para la arquitectura vieja, sigue ahí. Así quedó la línea de tiempo:

VersiónFechaArquitectura vieja
0.7623 oct 2024La nueva pasa a ser la de por defecto; la vieja sigue disponible
0.8012 jun 2025Congelada: sin funciones nuevas, con avisos
0.81 · SDK 5412 ago 2025 · 10 sep 2025Últimas versiones donde todavía se puede activar
0.828 oct 2025Ya no se puede activar; las opciones se ignoran
0.83 · SDK 5510 dic 2025 · 25 feb 2026newArchEnabled sale de app.json
0.8411 feb 2026Su código sale de los builds de iOS; clases eliminadas en Android
0.88 · SDK 5819 oct 2026 · 15 oct 2026Versión actual

Fabric, TurboModules y JSI en una tabla

En la arquitectura vieja, JavaScript y el código nativo hablaban por un puente asíncrono: cada llamada se serializaba, se ponía en cola y se procesaba después. El equipo de React Native explica en New Architecture is here que ese paso se volvía un cuello de botella con actualizaciones frecuentes u objetos grandes. La arquitectura nueva cambia el puente por tres piezas:

PiezaQué reemplazaQué cambia para ti
JSIEl puente asíncronoJavaScript guarda una referencia a un objeto de C++ y llama a sus métodos sin serializar nada
TurboModulesLos Native Modules del puenteSe cargan solo cuando se usan, responden de forma síncrona y tienen tipos generados con Codegen
FabricEl renderizador viejoRenderizador en C++ compartido entre plataformas; layout síncrono en useLayoutEffect, Suspense y transiciones
CodegenContratos escritos a manoGenera el código nativo a partir de un archivo de especificación tipado
Interop layerNada: es un puente de transiciónDeja correr librerías viejas, pero no soporta Shadow Nodes propios ni funciones concurrentes

Para tu código JavaScript casi nada cambia: los componentes y hooks son los mismos. Lo que cambia es la frontera con el código nativo, y por eso el riesgo está en las librerías que traen código en ios/ o android/, no en tus pantallas. Un ejemplo concreto del cambio: un módulo nativo viejo te devolvía un valor por callback; uno nuevo puede devolverlo directo, porque JSI permite la llamada síncrona.

el puente viejo contra JSI en React Nativearquitectura viejaJavaScriptpuentenativoserializaen colaasíncronocada llamada espera turnoarquitectura nuevaJavaScriptJSI (C++)Fabric · TurboModulesdirectosíncronobajo demandala llamada responde al momentodesde la 0.82 solo queda el lado derechofuente: reactnative.dev, New Architecture is here (2024)

Desliza la figura para verla completa

El camino: 0.81 o SDK 54, activar la nueva, probar librerías y subir

La recomendación oficial tiene un orden, y tiene sentido: si saltas de una versión vieja directo a la 0.82 o más, mezclas dos problemas (el cambio de versión y el cambio de arquitectura) y no sabrás cuál rompió qué. Los cuatro pasos:

  1. Sube a la 0.81 o al SDK 54 con la arquitectura que ya usas, y deja la app estable ahí. Expo recomienda subir los SDK de uno en uno.
  2. Activa la arquitectura nueva en esa misma versión. En la 0.81 y el SDK 54 ya viene activada por defecto, así que normalmente el trabajo es quitar el false que alguien dejó puesto.
  3. Prueba tus librerías en un build de desarrollo: pantallas, cámara, mapas, pagos, notificaciones, todo lo que toque código nativo.
  4. Actualiza a la 0.82 o, hoy, sigue subiendo hasta la versión actual, de SDK en SDK.

Para el paso 2, busca dónde está apagada. Según la guía de Expo sobre la arquitectura nueva, la opción vive en la configuración de la app, en gradle.properties y en Podfile.properties.json:

# Desde la raíz del proyecto: ¿dónde está apagada?
grep -rn "newArchEnabled" app.json android/gradle.properties ios/Podfile.properties.json
grep -rn "RCT_NEW_ARCH_ENABLED" ios/Podfile package.json

# app.json (SDK 54): quita el false o cámbialo a true
{
  "expo": {
    "newArchEnabled": true
  }
}
  1. El primer grep busca la opción en los tres lugares que documenta Expo. Si tu proyecto usa app.config.ts, búscala ahí también.
  2. El segundo busca la variable de CocoaPods, que a veces está fija en el Podfile o en un script de package.json.
  3. En app.json, "newArchEnabled": true la activa en el SDK 54; como ya es el valor por defecto, también puedes borrar la línea.
  4. Después de cambiarla, crea un build de desarrollo nuevo. Expo Go no sirve para esta prueba si tienes librerías nativas propias.

Antes de subir de versión, decide cómo vuelves si algo sale mal: qué build sigue disponible y cómo lo restauras. La lógica es la misma que en la web, y la explicamos en plan de rollback antes de desplegar.

la migración en cuatro escalones0.82: aquí ya no hay vuelta atrásuna versión, un cambioprueba antes de subirpaso 10.81 o SDK 54misma arquitecturapaso 2activar la nuevabuild de pruebapaso 3probar libreríasscript + pantallaspaso 4subir a 0.82+hoy 0.88 · SDK 58primero la arquitectura, después la versiónorden recomendado por React Native 0.82 y Expo

Desliza la figura para verla completa

Cómo saber si una librería es compatible

Las librerías que solo tienen JavaScript no te preocupan: la arquitectura no las toca. Las que traen código nativo sí. Hay tres señales que puedes revisar en tu propio node_modules, sin internet:

  • codegenConfig en su package.json. Es la configuración de Codegen que usan los TurboModules y los componentes de Fabric, según la documentación de Turbo Native Modules. Si está, la librería trae especificaciones para la arquitectura nueva.
  • expo-module.config.json. Es un módulo de Expo, y la documentación de Expo Modules dice que todos soportan la arquitectura nueva.
  • Código nativo sin ninguna de las dos. Puede funcionar por el interop layer o puede fallar. Esa es la lista que revisas a mano.

Este script hace esa clasificación con las dependencias de tu package.json. Córrelo después de npm install:

// audit-native-deps.mjs: list the dependencies that ship native code and what they declare.
// Usage: node audit-native-deps.mjs [path/to/app]   (run after npm install)
import { readFileSync, existsSync, readdirSync } from "node:fs";
import { join } from "node:path";

const root = process.argv[2] ?? ".";
const app = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
const names = Object.keys({ ...app.dependencies, ...app.devDependencies }).sort();

const rows = [];
for (const name of names) {
  const dir = join(root, "node_modules", name);
  if (!existsSync(join(dir, "package.json"))) {
    rows.push([name, "?", "not installed"]);
    continue;
  }
  const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
  const files = readdirSync(dir);
  const native = files.includes("ios") || files.includes("android") || files.some((f) => f.endsWith(".podspec"));
  if (!native) continue; // JavaScript only: the architecture does not affect it
  const verdict = pkg.codegenConfig
    ? "codegenConfig: ships New Architecture specs"
    : files.includes("expo-module.config.json")
      ? "Expo module: supports the New Architecture"
      : "CHECK: native code, no codegenConfig";
  rows.push([name, pkg.version, verdict]);
}

for (const [name, version, verdict] of rows) console.log(`${name.padEnd(34)} ${String(version).padEnd(9)} ${verdict}`);
const check = rows.filter((r) => r[2].startsWith("CHECK") || r[1] === "?").length;
console.log(`\n${rows.length} native or missing, ${check} to check by hand`);
process.exit(check ? 1 : 0);
  1. Lee el package.json de la app (o de la ruta que le pases) y junta dependencies y devDependencies.
  2. Para cada nombre busca su carpeta en node_modules; si no está, la marca como no instalada, porque no puede revisarla.
  3. Considera nativa una librería con carpeta ios, android o un .podspec. Las demás se saltan.
  4. Si tiene codegenConfig, trae especificaciones nuevas. Si tiene expo-module.config.json, es un módulo de Expo. Si no tiene ninguna, va a la lista de revisión.
  5. Imprime una línea por librería nativa y sale con código 1 si hay algo que revisar, para que puedas usarlo en CI.

Lo corrimos con Node 22 sobre una carpeta de prueba con paquetes inventados (uno con codegenConfig, un módulo de Expo, uno solo de JavaScript, dos nativos sin especificación y uno sin instalar). Esta es la salida real:

$ node audit-native-deps.mjs fixture
@acme/maps                         1.4.0     CHECK: native code, no codegenConfig
expo-example-module                3.0.1     Expo module: supports the New Architecture
missing-lib                        ?         not installed
old-native-lib                     0.9.3     CHECK: native code, no codegenConfig
react-native-fast-thing            2.1.0     codegenConfig: ships New Architecture specs

5 native or missing, 3 to check by hand

El script es un filtro, no un veredicto. Una librería puede tener codegenConfig y aun así fallar en un caso tuyo, y otra sin él puede funcionar bien por el interop layer. Para la lista de revisión hay dos fuentes más. La primera es React Native Directory, donde cada librería tiene un campo newArchitecture. La segunda es npx expo-doctor, que según Expo compara tus dependencias con los datos de ese directorio. Si una dependencia no aparece ahí y ya la revisaste, puedes excluirla en package.json:

{
  "expo": {
    "doctor": {
      "reactNativeDirectoryCheck": {
        "exclude": ["old-native-lib"],
        "listUnknownPackages": false
      }
    }
  }
}

exclude acepta nombres exactos y expresiones regulares; listUnknownPackages: false apaga el aviso de paquetes que el directorio no conoce. La prueba final siempre es un build de desarrollo con la arquitectura nueva activada, recorriendo las pantallas que usan cada librería de la lista.

librerías nativas: qué revisar en cada unaseñalqué significaqué hacercodegenConfigtrae specs nuevasprobar en un buildexpo-module.configmódulo de Expoprobar en un buildsolo JavaScriptno le afectanadanativo sin specsinterop o fallarevisar a manorepo archivadono habrá arreglosreemplazarReact Native Directory: campo newArchitecturenpx expo-doctor compara tus dependencias con ese directoriouna señal filtra, la prueba es el buildfuente: documentación de React Native y Expo, nov 2026

Desliza la figura para verla completa

Qué hacer si no es compatible

La guía de Expo da el orden. Primero, actualiza la librería a su última versión: muchas ya añadieron soporte y tu proyecto solo tenía una versión vieja. Segundo, si sigue fallando, crea una rama, quita las librerías que fallan hasta que la app arranque y mide cuánto depende tu app de cada una. Tercero, busca un reemplazo compatible; la propia guía sugiere, por ejemplo, expo-location en lugar de react-native-geolocation-service. Cuarto, si no hay reemplazo, abre un issue o un pull request en el repositorio de la librería con un ejemplo mínimo que reproduzca el fallo.

Si la librería es tuya o la mantienes en tu empresa, la salida es migrarla: escribir su especificación en TypeScript con el prefijo Native, añadir codegenConfig a su package.json y regenerar. Algunas librerías publicaron versiones que solo funcionan con la arquitectura nueva: las notas del SDK 54 dicen que, si necesitas seguir en la arquitectura vieja, puedes quedarte con Reanimated v3. Quedarte es una pausa, no un plan: el SDK 54 es el techo para la arquitectura vieja, y todo lo que salga después queda fuera de tu alcance, como Expo UI, estable desde el SDK 56, o los cambios de Expo Router en el SDK 56.

Cuando la app ya corre con la arquitectura nueva en el SDK 54, sube un SDK a la vez, como indica la guía de actualización de Expo:

npm install expo@^55.0.0
npx expo install --fix
npx expo-doctor
  1. npm install expo@^55.0.0 sube el paquete expo al SDK siguiente. Repites con 56, 57 y 58.
  2. npx expo install --fix ajusta el resto de dependencias a las versiones que espera ese SDK.
  3. npx expo-doctor revisa problemas comunes, incluida la compatibilidad con React Native Directory.

Si tu proyecto no usa Expo, React Native ofrece el Upgrade Helper, que muestra todos los cambios de archivos entre dos versiones.

Errores comunes

  • Saltar de una versión vieja directo a la 0.82 o más. Mezclas el cambio de versión con el de arquitectura y no sabes qué rompió qué.
  • Creer que newArchEnabled=false sigue funcionando. Desde la 0.82 se ignora sin error; la app corre con la nueva aunque la opción diga otra cosa.
  • Probar en Expo Go. Para revisar tus librerías nativas necesitas un build de desarrollo.
  • Revisar solo las dependencias directas de JavaScript. El riesgo está en las que traen ios/ o android/.
  • Tomar el resultado de una herramienta como prueba. El directorio y el script filtran; la prueba es abrir las pantallas que usan cada librería.
  • Quedarse en el SDK 54 sin fecha de salida. Cada versión nueva deja la app más lejos y la migración más grande.

Preguntas frecuentes

¿Cuál es la última versión de React Native que permite la arquitectura vieja?

La 0.81, y en Expo el SDK 54. Desde la 0.82 la arquitectura nueva es la única, y las opciones para desactivarla se ignoran.

¿Mi código JavaScript tiene que cambiar?

Casi nunca. Los componentes y hooks son los mismos. Lo que cambia es la frontera con el código nativo, así que el trabajo está en las librerías nativas y en los módulos que hayas escrito tú.

¿El interop layer va a desaparecer?

El anuncio de la 0.82 dice que se queda en el código "en el futuro previsible" y que avisarán antes de quitarlo. En la 0.84 seguía ahí. No lo tomes como solución permanente: no soporta Shadow Nodes propios ni funciones concurrentes.

¿Cuánto tarda la migración?

Depende de cuántas librerías nativas tengas y de si ya son compatibles. Una app con pocas dependencias nativas actualizadas puede quedar lista en el paso 2; una con módulos propios sin especificación necesita migrar cada uno.

Checklist

  • La app está en React Native 0.81 o en el SDK 54 de Expo, estable.
  • Ningún archivo deja newArchEnabled en false ni RCT_NEW_ARCH_ENABLED=0.
  • Hay un build de desarrollo nuevo con la arquitectura nueva activada.
  • El script de auditoría corrió y cada librería de la lista se probó a mano.
  • npx expo-doctor pasa, o las exclusiones están justificadas.
  • Cada librería incompatible está actualizada, reemplazada o reportada.
  • Hay un plan para volver al build anterior si algo falla.
  • La actualización sigue de SDK en SDK hasta la versión actual.

La guía en PDF trae esta checklist paso a paso y el método para auditar librerías nativas, con el script.

¿Viste esto en Instagram? Comenta ARQUITECTURA en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 19 de noviembre de 2026

← Blog