Expo UI: SwiftUI and Jetpack Compose from one React Native import
Update/ 8 min read
What @expo/ui is, how one component becomes SwiftUI on iOS and Jetpack Compose on Android, how to install it, a full settings screen, and where it still falls short.
- React
- JavaScript
In this article (9)
Expo UI is the @expo/ui library: you write a screen in React Native with components like Switch, Slider or Button, and the app renders them with SwiftUI on iOS and Jetpack Compose on Android, with no JavaScript copies. It has been stable since Expo SDK 56, announced May 26, 2026.
Updated November 12, 2026: the announcement covers SDK 56, but the current Expo UI docs are already on SDK 58 (recommended version ~58.0.28) and install the package with npx expo install @expo/ui. The code in this article comes from the announcement and those docs; I did not run it on an iPhone or an Android device, so what follows is a cross-checked reading of the sources, not a device test.
What Expo UI is and what changes in React Native
The Expo announcement of May 26, 2026 sums it up as native platform components from one JavaScript import, with no reimplementation in JS. On iOS they are SwiftUI views; on Android, Jetpack Compose. You write React; the system draws with its own controls.
The package has four entry points:
| Import | What it gives you | Where it runs |
|---|---|---|
@expo/ui | Universal components: one tree for every platform | iOS, Android and web (experimental) |
@expo/ui/swift-ui | The SwiftUI API | Apple platforms only |
@expo/ui/jetpack-compose | The Jetpack Compose API | Android |
@expo/ui/community/... | Replacements for community packages | Depends on the package |
The replacements are near-API-compatible. For example, the announcement swaps @react-native-community/datetimepicker for @expo/ui/community/datetime-picker; some props change because SwiftUI and Compose sit underneath instead of UIKit and Android views.
How Expo UI renders SwiftUI on iOS and Compose on Android
Universal components delegate. Per the docs, on Android they call @expo/ui/jetpack-compose, on iOS @expo/ui/swift-ui, and on web they use JavaScript implementations. That is why the same code looks different on each system:
Scroll the figure sideways to see all of it
The announcement's example shows it with FieldGroup: on iOS you get a SwiftUI Form with grouped sections and a system Switch and Slider; on Android, a Material 3 grouped list. There are no .ios.tsx and .android.tsx files.
Everything hangs from Host. According to the Expo UI SwiftUI guide, it is the bridge between React Native (UIKit) and SwiftUI, built on UIHostingController; the guide compares it to <svg> in the DOM. Three rules follow:
- Every Expo UI component goes inside a
Host. - Flexbox styles apply to the
Host; there is no Yoga inside, soRowandColumn(orHStackandVStackon iOS) do the layout. - You can nest React Native components, but SwiftUI controls their layout, and to get back to Expo UI you need another
Host.
Install @expo/ui
# new SDK 56 project: Expo UI ships in the default template
npx create-expo-app@latest --template default@sdk-56
# existing project
npx expo install @expo/ui
- The first line is a comment: the announcement says the default SDK 56 template already includes Expo UI.
npx create-expo-app@latest --template default@sdk-56creates the project from that template, exactly as the announcement gives it.npx expo install @expo/uiadds the package to a project that already exists; it is the command in the docs.
If your app is React Native without Expo, the docs ask you to install the expo package first. As for where to try it: both the announcement and the docs say Expo UI is included in Expo Go. The pages I read do not mention development builds for Expo UI, and I did not test it on a device.
An example screen with Expo UI
This settings screen is the one from the announcement, with a single change: I import ReactNode as a type. It has two sections, three controls and a button:
Scroll the figure sideways to see all of it
import { useState, type ReactNode } from 'react';
import { Button, FieldGroup, Host, Row, Slider, Spacer, Switch, Text } from '@expo/ui';
export default function SettingsScreen() {
const [notifications, setNotifications] = useState(true);
const [sounds, setSounds] = useState(false);
const [brightness, setBrightness] = useState(0.6);
return (
<Host style={{ flex: 1 }}>
<FieldGroup>
<FieldGroup.Section title="Notifications">
<LabeledRow label="Push notifications">
<Switch value={notifications} onValueChange={setNotifications} />
</LabeledRow>
<LabeledRow label="Sounds">
<Switch value={sounds} onValueChange={setSounds} />
</LabeledRow>
<FieldGroup.SectionFooter>
<Text textStyle={{ fontSize: 13, color: '#6c6c70' }}>
Notification previews can expose sensitive content on the lock screen.
</Text>
</FieldGroup.SectionFooter>
</FieldGroup.Section>
<FieldGroup.Section title="Display">
<LabeledRow label="Brightness">
<Slider value={brightness} onValueChange={setBrightness} />
</LabeledRow>
</FieldGroup.Section>
<FieldGroup.Section>
<Row alignment="center" style={{ padding: 12 }}>
<Spacer flexible />
<Button variant="outlined" onPress={() => alert('Signed out')} label="Sign out" />
<Spacer flexible />
</Row>
</FieldGroup.Section>
</FieldGroup>
</Host>
);
}
function LabeledRow({ label, children }: { label: string; children: ReactNode }) {
return (
<Row alignment="center" spacing={16}>
<Text>{label}</Text>
<Spacer flexible />
{children}
</Row>
);
}
- Every component comes from
@expo/ui, the universal import; there is noPlatform.OSand no per-platform file. - Three
useStatecalls hold the controls: two switches and a brightness from 0 to 1 (0.6). Host style={{ flex: 1 }}opens the native world and fills the screen: flexbox goes here.FieldGroupis the grouped settings list and eachFieldGroup.Sectionis one group, with an optionaltitle.LabeledRowputs the text on the left and the control on the right: aRowwith a flexibleSpacerbetween them.SwitchandSliderfollow thevalueplusonValueChangepattern, like a controlled input.FieldGroup.SectionFooteris the text under the section;textStyleisText's style prop.- The last section centers a
Buttonwithvariant="outlined",labelandonPress.
These are the universal components in the example, plus Column and Picker, with the role the docs give each one:
Scroll the figure sideways to see all of it
When to use Expo UI
Expo UI fits where the system look is an advantage: settings screens, forms, lists, pickers and bottom sheets. Switches, date pickers and menus are controls users already know, and you get them without writing Swift or Kotlin. It also works for migrating single pieces: according to the announcement, the @expo/ui/community replacements cover packages such as datetime-picker, slider, picker, segmented-control and bottom-sheet.
My judgment, not the source's: if your brand depends on an interface that should not look like the system, React Native's own components remain the more direct route. And if you are not sure your store needs an app at all, that decision comes first: read PWA vs native app for your store. Expo UI only matters once you have chosen React Native.
Current limits of Expo UI
- The universal layer is "a first iteration," says the announcement: some components exist on all three platforms and others do not, because the platforms do not share the same primitives.
- Web is experimental and, in the announcement's words, not yet at the same quality bar as native.
- Apple TV and Android TV work, but some native APIs are unavailable there.
- The community-package replacements are "near-API-compatible": some props differ.
- The
glassEffectmodifier needs Xcode 26 or later and iOS 26 or later. - In SwiftUI, text inside a
Linkneeds an explicit color. - The test that matters is missing: seeing the screen on a real iPhone and a real Android device. I did not do it.
Common mistakes
- Forgetting the Host. Without it, components have nowhere to draw. One
Hostat the top covers the whole tree. - Using flexbox inside the Host. There is no Yoga in there; use
Row,ColumnandSpacer. - Importing
@expo/ui/swift-uiin cross-platform code. It exists only on Apple platforms. For a tree that runs on Android, use the universal import or@expo/ui/jetpack-compose. - Mixing React Native components without another Host. Inside a SwiftUI tree, SwiftUI decides the layout, and going back to Expo UI takes a new
Host. - Assuming a community replacement is identical. It is near-compatible; check the props one by one.
- Leaving text color to chance. The current docs examples set the color of
TextfromuseColorScheme(); do the same and check dark mode on a device.
Frequently asked questions
Does Expo UI work in Expo Go?
Yes: the announcement says Expo UI is bundled into Expo Go, and the docs mark it the same way. The pages I read do not discuss development builds for Expo UI. If your project uses native modules that Expo Go does not ship, you will need a development build for those modules.
Does it replace React Native's components?
No. They coexist. Expo UI components go inside a Host; you can nest React Native components inside, but SwiftUI controls their layout and you need another Host to get back to Expo UI.
Does it work on the web?
There is experimental support. According to the docs, on web the universal components are JavaScript implementations built on react-dom or react-native-web, and the announcement warns they are not yet at native quality.
Do I have to write Swift or Kotlin?
Not to use the components: you import them from @expo/ui and write TypeScript. Still, the names in @expo/ui/swift-ui follow SwiftUI (HStack, VStack, NavigationStack), so Apple's documentation helps.
Checklist
- I know which Expo SDK my project uses and installed the package with
npx expo install @expo/ui. - Every screen with Expo UI starts in a
Host. - Layout inside the
HostusesRow,ColumnandSpacer, not flexbox. - Cross-platform code imports from
@expo/ui;swift-uiandjetpack-composestay in per-platform code. - I compared the props of every community replacement with the original package.
- I tested the screen on a real iPhone and a real Android device, in light and dark mode.
- I noted which components are missing on one of the three platforms before promising anything to the team.
One settings screen and one device per system tell you whether Expo UI fits. If you first have to choose between an app and an installable website, start with PWA vs native app. Sources: the Expo announcement of May 26, 2026 and the Expo UI SwiftUI guide, checked November 12, 2026.
Saw this on Instagram? Comment EXPOUI on the Reel and I'll send you the guide.
Written by

Published November 12, 2026 · updated November 18, 2026