Expo Framework 20 min leestijd

Expo SDK 55 Compleet Overzicht: React 19.2, Hermes v1 en Nieuwe API's

Een compleet overzicht van Expo SDK 55 met React Native 0.83, React 19.2, Hermes v1, het definitieve einde van de Legacy Architecture, nieuwe navigatie-API's en een stapsgewijze migratiehandleiding.

Editorial Team

Inleiding: Een nieuwe mijlpaal voor Expo

Expo SDK 55 is er, en eerlijk gezegd? Dit is een flinke stap vooruit. Met React Native 0.83.1 en React 19.2.0 onder de motorkap gaat het hier niet om een klein updateje — dit verandert fundamenteel hoe we cross-platform apps bouwen. De Legacy Architecture is definitief verleden tijd, Hermes v1 staat in de startblokken, en er komen een hoop nieuwe API's bij die echt nieuwe mogelijkheden openen.

In dit artikel neem ik je mee door alles wat je moet weten. Breaking changes, codevoorbeelden, migratietips — het komt allemaal aan bod. Of je nu een bestaand project wilt upgraden of net begint: na dit artikel weet je precies wat SDK 55 in huis heeft.

De kern: React Native 0.83 en React 19.2

Laten we bij het fundament beginnen. Expo SDK 55 draait op React Native 0.83.1, en dat is best bijzonder. Het is namelijk de eerste React Native-release ooit zonder breaking changes voor gebruikers. Historisch moment, als je het mij vraagt.

Daarnaast zit React 19.2.0 erin, met twee krachtige nieuwe API's die je dagelijkse workflow echt gaan verbeteren.

De Activity-component

De <Activity>-component is een van de meest veelbelovende toevoegingen uit React 19.2. Hiermee kun je delen van je app opdelen in controleerbare "activiteiten" met twee modi: hidden en visible.

Wanneer een activiteit verborgen is, worden effecten ontkoppeld, updates uitgesteld en children niet gerenderd. Maar — en dit is het mooie — de componentstate blijft gewoon bewaard. Zodra de activiteit weer zichtbaar wordt, herstelt alles naadloos.

import React, { useState } from 'react';
import { View, Text, Button, StyleSheet } from 'react-native';
import { Activity } from 'react';

export function TabContainer() {
  const [activeTab, setActiveTab] = useState('home');

  return (
    <View style={styles.container}>
      <View style={styles.tabBar}>
        <Button title="Home" onPress={() => setActiveTab('home')} />
        <Button title="Profiel" onPress={() => setActiveTab('profiel')} />
        <Button title="Instellingen" onPress={() => setActiveTab('instellingen')} />
      </View>

      {/* State blijft bewaard zelfs wanneer tabs verborgen zijn */}
      <Activity mode={activeTab === 'home' ? 'visible' : 'hidden'}>
        <HomeScherm />
      </Activity>

      <Activity mode={activeTab === 'profiel' ? 'visible' : 'hidden'}>
        <ProfielScherm />
      </Activity>

      <Activity mode={activeTab === 'instellingen' ? 'visible' : 'hidden'}>
        <InstellingenScherm />
      </Activity>
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1 },
  tabBar: { flexDirection: 'row', justifyContent: 'space-around', padding: 12 },
});

Super handig voor tab-navigatie, modale schermen en wizard-flows. In plaats van componenten helemaal te unmounten en opnieuw te mounten (waardoor je scrollpositie, formulierinvoer en andere state kwijtraakt), kun je ze nu gewoon elegant verbergen en weer tonen.

De useEffectEvent-hook

De useEffectEvent-hook lost een probleem op waar ik zelf ook regelmatig tegenaan liep: die vervelende useEffect-afhankelijkheden. Je wilt binnen een effect reageren op een event, maar zonder dat het effect opnieuw draait wanneer de event-handler verandert.

import { useEffect, useEffectEvent } from 'react';
import { AppState } from 'react-native';

function useAppStateTracking(userId: string) {
  // Deze event-functie verandert niet de afhankelijkheden van useEffect
  const onAppStateChange = useEffectEvent((nextState: string) => {
    // Heeft altijd toegang tot de nieuwste userId
    // zonder useEffect opnieuw te triggeren
    analytics.track('app_state_change', {
      userId,
      state: nextState,
      timestamp: Date.now(),
    });
  });

  useEffect(() => {
    const subscription = AppState.addEventListener('change', onAppStateChange);
    return () => subscription.remove();
  }, []); // Lege dependency array — effect draait slechts eenmaal
}

Zonder useEffectEvent zou je userId als afhankelijkheid aan useEffect moeten toevoegen, waardoor de subscription elke keer opnieuw wordt opgezet. Met deze hook heb je altijd toegang tot de meest recente waarden, zonder onnodige re-runs. Echt een verademing.

Afscheid van de Legacy Architecture

Oké, dit is misschien wel de grootste verandering in SDK 55. De Legacy Architecture wordt niet langer ondersteund. Klaar. Uit. Voorbij.

De newArchEnabled-configuratieoptie in app.json is verdwenen, want de Nieuwe Architectuur is nu altijd ingeschakeld en kan simpelweg niet meer uitgeschakeld worden.

Wat betekent dit concreet?

  • Alle native modules moeten compatibel zijn met TurboModules
  • Alle UI-componenten moeten Fabric ondersteunen
  • Oudere bibliotheken die nog op de bridge leunen, werken gewoon niet meer
  • Betere prestaties over de hele linie — geen fallback-code meer die meegesleept wordt

Als je die migratie nog niet hebt afgerond, is SDK 54 je laatste kans om de Legacy Architecture te gebruiken. Het goede nieuws: zo'n 83% van alle Expo SDK 54-projecten draaide al op de Nieuwe Architectuur, dus voor de meeste teams zou deze overgang vrij soepel moeten verlopen.

Hermes v1: de volgende generatie JavaScript-engine

Hermes v1 is een serieuze upgrade. Betere prestaties, betere ondersteuning voor moderne JavaScript-functies zoals ES6-klassen, const/let-syntax en async/await — precies wat je wilt.

In SDK 55 is Hermes v1 beschikbaar als opt-in. Naar verwachting wordt het de standaard in SDK 56. Wil je het nu al uitproberen? Voeg dit toe aan je configuratie:

// app.json
{
  "expo": {
    "experiments": {
      "hermesV1": true
    }
  }
}

Eén kanttekening: Hermes v1 vereist dat React Native vanuit broncode wordt gebouwd, wat de bouwtijd kan verlengen. Voor lokale ontwikkeling maakt dat weinig uit, maar houd er rekening mee bij je CI/CD-pipelines.

Hermes bytecode-diffing voor kleinere updates

Dit is een van die verbeteringen waar je misschien niet meteen bij stilstaat, maar die een enorm verschil maakt in de praktijk. Hermes bytecode-diffing vermindert de downloadgrootte van OTA-updates (via EAS Update) met ongeveer 75%.

In plaats van het volledige gecompileerde JavaScript-bestand te downloaden, worden alleen de binaire verschillen verstuurd. Activeer het als volgt:

// app.json
{
  "expo": {
    "updates": {
      "useHermesBytecodeForUpdates": true
    }
  }
}

Even concreet: een update van 4 MB wordt teruggebracht tot zo'n 1 MB. Voor gebruikers op mobiele netwerken (en dat zijn er best veel) maakt dit een wereld van verschil qua downloadsnelheid en dataverbruik.

Nieuw standaard projectsjabloon

Het standaard projectsjabloon is flink onder handen genomen. De belangrijkste veranderingen:

  • Mapstructuur: Routes wonen nu in /src/app in plaats van /app — sluit beter aan bij hoe de meeste projecten al gestructureerd zijn
  • Native Tabs API: Het sjabloon gebruikt de Native Tabs API voor een echt platformeigen tabervaring op iOS
  • Apple Zoom-transitie: Interactieve gedeelde-elementovergangen zijn standaard ingeschakeld op iOS
  • Vernieuwd ontwerp: Een fris uiterlijk met betere lay-out en navigatie

Een nieuw project aanmaken gaat zo:

# Nieuw project aanmaken met SDK 55
npx create-expo-app@latest --template default@next

# Projectstructuur na aanmaken:
# mijn-app/
# ├── src/
# │   └── app/
# │       ├── _layout.tsx
# │       ├── index.tsx
# │       └── (tabs)/
# │           ├── _layout.tsx
# │           ├── home.tsx
# │           └── profiel.tsx
# ├── assets/
# ├── app.json
# ├── package.json
# └── tsconfig.json

Expo Router: nieuwe navigatie-API's

Expo Router krijgt een aantal krachtige nieuwe API's in SDK 55. Laten we de hoogtepunten doorlopen.

Apple Zoom-transitie

De Apple Zoom-transitie biedt interactieve gedeelde-elementovergangen op iOS. Je kent het vast: die vloeiende zoomanimatie als je een foto opent in de Foto's-app. Diezelfde ervaring kun je nu in je eigen app inbouwen, en het is standaard ingeschakeld.

import { Stack } from 'expo-router';

export default function Layout() {
  return (
    <Stack
      screenOptions={{
        // Apple Zoom-transitie is standaard ingeschakeld
        // Je kunt het per scherm configureren
      }}
    >
      <Stack.Screen
        name="index"
        options={{ title: 'Overzicht' }}
      />
      <Stack.Screen
        name="detail"
        options={{
          presentation: 'card',
          // Zoomtransitie met gedeeld element
          sharedTransitionTag: 'product-afbeelding',
        }}
      />
    </Stack>
  );
}

Het mooie is dat de transitie interactief is: gebruikers kunnen met een veegbeweging terug navigeren, waarbij de zoomanimatie soepel meegaat met de vingerbeweging. Dat voelt zo veel natuurlijker dan die standaard schuifanimatie.

Stack.Toolbar API

De nieuwe Stack.Toolbar API geeft je toegang tot UIToolbar op iOS. Ideaal voor menu's en acties die naadloos integreren met het platform.

import { Stack } from 'expo-router';
import { Text, Pressable } from 'react-native';

export default function DetailScherm() {
  return (
    <>
      <Stack.Screen
        options={{
          title: 'Productdetails',
        }}
      />
      <Stack.Toolbar>
        <Pressable onPress={() => handleDelen()}>
          <Text>Delen</Text>
        </Pressable>
        <Pressable onPress={() => handleOpslaan()}>
          <Text>Opslaan</Text>
        </Pressable>
        <Pressable onPress={() => handleVerwijderen()}>
          <Text>Verwijderen</Text>
        </Pressable>
      </Stack.Toolbar>

      {/* Scherminhoud */}
    </>
  );
}

Momenteel is deze API iOS-only, maar Android-ondersteuning staat op de planning.

Experimentele SplitView-ondersteuning

En dan is er nog experimentele SplitView-ondersteuning. Hiermee kun je master-detail-layouts bouwen die optimaal gebruikmaken van grotere schermen, zoals iPads. Iets waar de community al jaren om vraagt, eerlijk gezegd.

Verbeterde DevTools in React Native 0.83

De DevTools hebben een behoorlijke upgrade gekregen. Dit zijn de dingen waar ik het meest enthousiast over ben.

Netwerkinspectiepaneel

Je kunt nu alle netwerkverzoeken van je app bekijken en analyseren, direct vanuit de DevTools. Het paneel vangt verzoeken op van fetch(), XMLHttpRequest en zelfs <Image>-componenten. Elk verzoek toont gedetailleerde metadata: timing, headers, response-previews en een Initiator-tab die laat zien waar in je code het verzoek vandaan komt. Die laatste is echt een gamechanger bij het debuggen.

Prestatietracing

Het nieuwe prestatietracingpaneel laat je opnamesessies starten met een uniforme tijdlijn van:

  • JavaScript-uitvoering
  • React Performance-tracks
  • Netwerkevents
  • Custom User Timings

Precies wat je nodig hebt om die lastige jank-problemen op te sporen.

Nieuwe desktopapplicatie

De DevTools zijn nu ook beschikbaar als standalone desktopapplicatie. Geen browser meer nodig, snellere opstarttijd, en je hebt geen last meer van browserextensies die de boel verstoren.

# React Native DevTools starten
# De desktop-app wordt automatisch geopend bij het starten van je project
npx expo start

# Of handmatig de DevTools openen
# Druk op 'j' in de terminal om de debugger te openen

Web Performance API's

React Native 0.83 implementeert nu W3C-standaard Web Performance API's. Een grote stap richting webcompatibiliteit, en het maakt het mogelijk om dezelfde prestatiemetrieken te verzamelen die je al kent van webontwikkeling.

import { PerformanceObserver, performance } from 'react-native';

// Markeer het begin en einde van een operatie
performance.mark('data-laden-start');

const data = await fetchProducten();

performance.mark('data-laden-einde');

// Meet de duur
performance.measure('data-laden', 'data-laden-start', 'data-laden-einde');

// Observeer prestatiemetrieken
const observer = new PerformanceObserver((list) => {
  list.getEntries().forEach((entry) => {
    console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
  });
});

observer.observe({ entryTypes: ['measure'] });

Het fijne is dat deze API's ook in productiebuilds werken. Je kunt dus echte prestatiegegevens van gebruikers in het veld verzamelen — ontzettend waardevol voor het monitoren van je app na lancering.

Intersection Observer API

Nog een webstandaard die naar React Native komt: de Intersection Observer API. Hiermee kun je asynchroon observeren wanneer elementen zichtbaar worden in de viewport. In de canary-release van 0.83 is deze API beschikbaar voor testen.

import { useEffect, useRef } from 'react';
import { View, Text, ScrollView, StyleSheet } from 'react-native';

function LazyAfbeelding({ bron, alt }: { bron: string; alt: string }) {
  const ref = useRef<View>(null);
  const [isZichtbaar, setIsZichtbaar] = useState(false);

  useEffect(() => {
    if (!ref.current) return;

    const observer = new IntersectionObserver(
      (entries) => {
        entries.forEach((entry) => {
          if (entry.isIntersecting) {
            setIsZichtbaar(true);
            observer.unobserve(entry.target);
          }
        });
      },
      { threshold: 0.1 } // Trigger bij 10% zichtbaarheid
    );

    observer.observe(ref.current);

    return () => observer.disconnect();
  }, []);

  return (
    <View ref={ref} style={styles.afbeeldingContainer}>
      {isZichtbaar ? (
        <Image source={{ uri: bron }} style={styles.afbeelding} />
      ) : (
        <View style={styles.placeholder} />
      )}
    </View>
  );
}

Dit opent de deur naar lazy-loading, viewport-gebaseerde animaties en oneindig scrollen — met dezelfde API die je al uit de browser kent. Lekker consistent.

Brownfield-integratie met expo-brownfield

Voor teams die React Native willen toevoegen aan een bestaande native app is er goed nieuws. Het nieuwe expo-brownfield-pakket maakt dit een stuk eenvoudiger. React Native-code wordt verpakt als een native bibliotheek (AAR voor Android, XCFramework voor iOS) die native ontwikkelaars kunnen gebruiken zonder Node.js of React Native build-afhankelijkheden in te stellen.

# expo-brownfield installeren
npx expo install expo-brownfield

# Native bibliotheek genereren
npx expo-brownfield build --platform ios
npx expo-brownfield build --platform android

Dit is echt een gamechanger voor grotere organisaties die geleidelijk onderdelen van hun bestaande native apps willen migreren naar React Native, zonder het hele bouwproces overhoop te gooien.

Nieuwe en verbeterde pakketten

SDK 55 brengt updates voor een hele rits Expo-pakketten. Hier zijn de hoogtepunten.

Nieuw versienummeringssysteem

Klein maar fijn: vanaf SDK 55 gebruiken alle Expo SDK-pakketten dezelfde major-versie als de SDK zelf. Dus expo-camera compatibel met SDK 55 heeft versienummer ^55.0.0. Nooit meer puzzelen welke pakketversies bij elkaar horen.

expo-blur op Android

Blur-effecten zijn nu stabiel op Android, dankzij de RenderNode API op Android 12+. Er is wel een breaking change: je moet nu een <BlurTargetView>-wrapper gebruiken rondom de content die geblurd moet worden.

import { BlurView, BlurTargetView } from 'expo-blur';
import { View, Text, StyleSheet } from 'react-native';

export function BlurVoorbeeld() {
  return (
    <BlurTargetView style={styles.container}>
      {/* Content die geblurd kan worden */}
      <View style={styles.achtergrond}>
        <Text style={styles.tekst}>Achtergrondinhoud</Text>
      </View>

      {/* BlurView past het blureffect toe */}
      <BlurView
        intensity={80}
        tint="light"
        style={styles.blurOverlay}
      >
        <Text style={styles.overlayTekst}>
          Wazig overlay
        </Text>
      </BlurView>
    </BlurTargetView>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1 },
  achtergrond: { flex: 1, justifyContent: 'center', alignItems: 'center' },
  tekst: { fontSize: 24 },
  blurOverlay: {
    position: 'absolute',
    bottom: 0,
    left: 0,
    right: 0,
    height: 100,
    justifyContent: 'center',
    alignItems: 'center',
  },
  overlayTekst: { fontSize: 18, fontWeight: 'bold' },
});

expo-widgets (iOS Alpha)

Met expo-widgets kun je iOS-startschermwidgets en Live Activities maken met Expo UI-componenten, zonder native code te hoeven schrijven. Het is nog alpha, maar het is veelbelovend en breidt de mogelijkheden van Expo-apps behoorlijk uit.

expo-audio verbeteringen

Het audiopakket ondersteunt nu vergrendelscherm-besturingselementen en achtergrondopname. Dat betekent dat je nu echt volwaardige muziekspeler- en podcast-apps kunt bouwen met Expo. Dat was eerder toch een pijnpunt.

expo-image: HDR en SF Symbols

Het beeldpakket ondersteunt nu HDR-afbeeldingen op iOS en kan SF Symbols renderen — Apple's uitgebreide bibliotheek met systeemiconen. Handig als je wilt dat je app er volledig native uitziet op iOS.

expo-sqlite: Inspector en Tagged Templates

De SQLite-module heeft een devtools-inspectorplugin gekregen (eindelijk kun je je database inspecteren tijdens het ontwikkelen) en er is ondersteuning voor tagged template literals:

import * as SQLite from 'expo-sqlite';

const db = await SQLite.openDatabaseAsync('mijn-app.db');

// Tagged template literal — schoon en veilig tegen SQL-injectie
const naam = 'Jan Jansen';
const leeftijd = 30;

const resultaat = await db.getFirstAsync`
  SELECT * FROM gebruikers
  WHERE naam = ${naam} AND leeftijd > ${leeftijd}
`;

console.log(resultaat);

Objectgeoriënteerde API's voor contacten, mediabibliotheek en kalender

De pakketten expo-contacts/next, expo-media-library/next en expo-calendar/next introduceren objectgeoriënteerde API's met SharedObjects. Een meer intuïtieve manier om met native bronnen te werken, wat het een stuk prettiger maakt om data te manipuleren.

AI-tooling en ontwikkelaarservaring

Expo zet ook stevig in op AI-tooling. SDK 55 breidt de MCP-server (Model Context Protocol) uit om CLI-acties te ondersteunen, en er is een officiële expo/skills-collectie voor integratie met AI-codeassistenten.

In de praktijk betekent dit dat je AI-tools kunt gebruiken om je project te upgraden, fouten op te sporen en code te genereren die specifiek is afgestemd op het Expo-ecosysteem. Dat klinkt misschien futuristisch, maar het werkt nu al behoorlijk goed.

Breaking changes en migratie-aandachtspunten

Naast het verdwijnen van de Legacy Architecture zijn er nog wat breaking changes om rekening mee te houden. Even op een rijtje:

  • DateTimePicker hernoemd: DateTimePicker heet nu DatePicker en ondersteunt datumbereiken en aangepaste labels
  • expo-av verwijderd uit Expo Go: Gebruik voortaan expo-video en expo-audio
  • expo-video-thumbnails verouderd: Stap over op expo-video's generateThumbnailsAsync
  • Push-notificaties in Expo Go (Android): Geven nu fouten in plaats van waarschuwingen
  • BlurView-wijziging: Vereist nu een <BlurTargetView>-wrapper
  • Swift 6 taalmodusadoptie: Expo Modules Core gebruikt nu Swift 6 voor strengere compilercontroles

Stapsgewijze migratiegids: van SDK 54 naar SDK 55

Goed, klaar om te upgraden? Hier is een stapsgewijze handleiding om je project over te zetten.

Stap 1: Controleer je huidige status

Allereerst: zorg dat je project al draait op de Nieuwe Architectuur. Als je nog newArchEnabled: false in je app.json hebt staan, moet je eerst die migratie afronden voordat je aan SDK 55 kunt beginnen.

# Controleer je huidige SDK-versie
npx expo --version

# Controleer of de Nieuwe Architectuur actief is
# Zoek in app.json naar newArchEnabled
cat app.json | grep newArchEnabled

Stap 2: Update Expo en afhankelijkheden

# Update naar SDK 55
npx expo install expo@next --fix

# Dit commando doet het volgende:
# 1. Update expo naar de nieuwste versie
# 2. Past alle Expo-pakketten aan naar compatibele versies
# 3. Toont waarschuwingen voor incompatibele pakketten

Stap 3: Verwijder verouderde configuratie

// VOOR (app.json met SDK 54)
{
  "expo": {
    "newArchEnabled": true,  // Verwijder deze regel
    "plugins": [
      "expo-av"  // Vervang door expo-video en expo-audio
    ]
  }
}

// NA (app.json met SDK 55)
{
  "expo": {
    "plugins": [
      "expo-video",
      "expo-audio"
    ]
  }
}

Stap 4: Werk native mappen bij

Als je Continuous Native Generation (CNG) gebruikt — en dat is absoluut de aanbevolen aanpak — verwijder dan de android- en ios-mappen. Ze worden automatisch opnieuw gegenereerd.

# Verwijder gegenereerde native mappen (alleen bij CNG)
rm -rf android ios

# Hergeneer bij de volgende build
npx expo prebuild

Stap 5: Controleer compatibiliteit van bibliotheken

# Controleer of alle pakketten compatibel zijn
npx expo-doctor

# Zoek specifiek naar bibliotheken die de Legacy Architecture vereisen
# en vervang deze door alternatieven die de Nieuwe Architectuur ondersteunen

Stap 6: Test grondig

Neem hier echt de tijd voor. Test alle functionaliteit, niet alleen de stukken die je hebt aangepast.

# Start het project en test alle functionaliteit
npx expo start

# Bouw een productieversie voor beide platformen
eas build --platform ios --profile preview
eas build --platform android --profile preview

Prestatie-impact: wat levert het op?

Mooi verhaal allemaal, maar wat merk je er concreet van? Hier zijn de belangrijkste verbeteringen:

  • OTA-updates: Tot 75% kleinere downloads dankzij Hermes bytecode-diffing
  • Opstarttijd: Snellere app-opstart — geen Legacy Architecture fallback-code meer die geladen hoeft te worden
  • Renderingprestaties: Fabric's immutable Shadow Tree en concurrent rendering zorgen voor soepelere UI-updates
  • JavaScript-uitvoering: Hermes v1 biedt merkbare snelheidsverbeteringen
  • Buildgrootte: Kleinere apps doordat Legacy Architecture-code is verwijderd

Al deze verbeteringen stapelen op. Een app die op SDK 54 al goed presteerde, wordt op SDK 55 nog sneller en kleiner. En voor apps die nog op de Legacy Architecture draaiden? Het verschil is enorm.

Toekomstperspectief

SDK 55 geeft ook een vooruitblik op wat er komen gaat. Hermes v1 wordt standaard in SDK 56, bytecode-diffing wordt automatisch ingeschakeld, en Jetpack Compose-integratie voor Android UI-componenten zit in de bètafase.

De richting is duidelijk: Expo groeit steeds meer uit tot een volwaardig alternatief voor puur native ontwikkeling, zonder in te leveren op prestaties of platform-integratie. En met expo-brownfield laat Expo zien dat het niet alleen voor greenfield-projecten is. Grote organisaties met bestaande native apps kunnen nu geleidelijk onderdelen migreren.

Conclusie

Expo SDK 55 is meer dan een versie-update — het is een verklaring van volwassenheid. Met het definitieve afscheid van de Legacy Architecture, React 19.2, Hermes v1 en een indrukwekkende reeks nieuwe API's, zet Expo de standaard voor moderne cross-platform app-ontwikkeling.

De belangrijkste takeaways:

  • De Legacy Architecture is weg — migreer nu als je dat nog niet hebt gedaan
  • React 19.2 brengt Activity en useEffectEvent voor betere state- en effectbeheer
  • Hermes v1 biedt betere prestaties en moderne JavaScript-ondersteuning
  • Kleinere OTA-updates dankzij bytecode-diffing (tot 75% kleiner)
  • Nieuwe navigatie-API's zoals Zoom-transities, Toolbar en SplitView
  • Verbeterde DevTools met netwerkinspectie en prestatietracing
  • Brownfield-ondersteuning voor geleidelijke migratie van native apps

Of je nu een nieuw project start of een bestaande app upgradet — SDK 55 biedt de tools en prestaties die je nodig hebt om professionele, performante mobiele apps te bouwen. De toekomst van React Native met Expo ziet er rooskleuriger uit dan ooit.

Over de Auteur Editorial Team

Our team of expert writers and editors.

Gerelateerde Artikelen