Expo Exact: a React-free framework. Is React Native dead?
Expo Exact is an agent-native Rust framework with no React and a UI in Contract. What it is, what Expo said, and what to do with your React Native app.

Expo Exact is an app framework written in Rust, without React, that Charlie Cheever, co-founder of Expo, previewed as a pre-alpha on November 9, 2026. Its interface is written in a new language called Contract, and Cheever describes it as “agent native”: designed so that an AI agent can build, run, see and test the app. When Expo’s co-founder ships a React-free framework, those of us who maintain React Native apps are left with one question: is React Native dead? I read the announcement and the repository’s README. I did not build an app with Exact; what follows is a reading of what Expo published, from someone who ships React Native and Expo apps for clients, writes native Swift and builds agents.
TL;DR
- Expo Exact is a new, pre-alpha framework with no React, no webview and no JavaScript bridge in the interface: the UI is written in Contract, the logic in TypeScript or Rust, and it uses UIKit on iOS, AppKit on macOS, the DOM on the web and its own renderer (Ink) on Windows.
- React Native is not going away because of this announcement. Charlie Cheever, co-founder of Expo, wrote that the Expo framework isn't going away and that the company will continue to support it; React Native, which Meta maintains, does not depend on Exact.
- If you have an app in production or are about to start one for a client, stay with React Native and Expo. Today Exact is for experimenting on a project of your own: it has no stable API and no migration guide.
In this article:
- The essentials — What Expo Exact is · Is React Native dead?
- How it works — What agent-native means · The Contract language · Benchmarks and limits
- The decision — What it is missing today · What to do in your situation · Frequently asked questions
What Expo Exact is
Exact (published in the expo/exact repository; in this post I call it Expo Exact) is a framework for writing an app once and running it natively on several platforms. Charlie Cheever, co-founder of Expo, presented it on his blog under the title “A preview of Exact”, and the code is in the expo/exact repository under the MIT license. The README sums it up this way: you write the app once, it runs natively on the web, macOS, iOS and Linux, and an AI agent can build it, run it, see it and test it on every one of those platforms.
The README describes these architecture decisions:
- There is no React and no JSX. The interface is not described with React components.
- There is no webview and no JavaScript bridge in the interface, and according to the README no app JavaScript runs before the first pixel.
- The UI is written in Contract, a new language that describes the interface, the state and the data flow together.
- Logic that goes deeper than the UI is written in TypeScript or Rust. TypeScript data modules run on Hermes on native hosts; Rust logic runs without a JavaScript virtual machine.
- Layout is computed by a Rust kernel that uses Taffy and applies CSS rules.
- It uses each platform’s own controls: UIKit on iOS, AppKit on macOS and the real DOM on the web over a runtime of about 20 KB. The view names no colors, fonts or control sizes; each host decides those.
For the cases the framework does not cover there are two ways out: reaching the native node from Swift (for example, the UIKit UIView) or reserving a rectangle of the screen and controlling it with native code. For platforms like Windows, Exact also ships its own renderer, called Ink.
On platform maturity, Cheever is direct: iOS is the most mature, web and macOS are “pretty good”, and Android, Windows and Linux work but are less mature. The README states that Android support landed on October 7, 2026 (“admitted”, in the README’s words) and is at an early stage.
Is React Native dead? What Expo said
No. The announcement retires nothing, and it says the opposite about the Expo framework:
“The Expo framework isn’t going away. Expo the company will continue to support it.”
Charlie Cheever, co-founder of Expo, in “A preview of Exact”
Cheever adds that this framework “is getting better quickly as AI makes huge performance improvements to React Native and the Expo SDK and Expo Modules continue to improve”.
There are three reasons to take that statement seriously rather than as polite reassurance:
- Exact started as an individual project. It began as a solo project of Cheever’s, with help from James Ide and contributions from other people, among them Krzysztof Magiera of Software Mansion. It is not an announcement that the company is moving its whole team to a new product.
- Expo’s cloud would back both. Cheever announced that Exact will work with Expo’s cloud services for building, updating, observing and hosting apps.
- Exact is in pre-alpha. The README itself says it changes daily and has no API stability.
Exact answers a legitimate question: if more and more of the code is going to be written by an agent, is React still the best foundation? Expo’s answer is to explore another foundation without abandoning the current one.
Neither the announcement nor the README says that existing React Native code, npm packages or Expo Modules work inside Exact. Exact is not a new version of Expo that you upgrade to: it is a different framework, with a different language for the interface, and it has no migration guide. As a React Native alternative, today it is an option for new, experimental projects; I would not plan the migration of a production app on that information.
What it means for a framework to be agent-native
In Exact, “agent native” comes down to four design decisions that the README describes.
Ten operations, the same on every platform. The agent controls the app with the same set of operations on any host, from a single script: tree, screenshot, tap, type, state, layout, logs, clock, prefer and perf. With them the agent reads the interface tree, takes a screenshot, taps an element, types text and queries the state, the layout and the logs. Because they are the same on iOS, on the web and on macOS, the agent does not need a different automation tool per platform.
The clock belongs to the agent. Instead of waiting with a sleep for a minute to pass, the agent advances time with clock +60000. A test that depends on a timer no longer depends on real time.
Compiler errors that teach. The Contract compiler rejects constructs like xs[i] or .sort() and, in the same error, suggests the accepted form: xs.at(i) and sortBy. The model receives the correction in the message, without having to look it up in the documentation.
Diagnostics as JSON. contract build --json returns the diagnostics with stable IDs and source ranges, and a development source map links each on-screen node to the declaration that produced it.
If you read my series on agents, you will recognize the pattern. An agent loop is a cycle in which the model decides on an action, the program executes it and the result comes back as context. In the write-test-fix loop I showed that the quality of the cycle depends on the feedback: an error that only says “failed” does not help the model; one that says what it expected and what it received does. Exact applies that idea to the whole framework. This is how I read the way its pieces fit into that cycle:
-
Write — Contract for the UI, TypeScript or Rust for the logic
-
Build —
contract build --jsonThe diagnostics carry an ID and a source range; some suggest the correct form.
-
Observe —
tree·screenshot·state·layout·logsThe agent uses the same operations on every platform.
-
Act —
tap·type·clockIt interacts with the app and advances time instead of waiting.
-
Fix
What it observed goes back to the model as context for the next attempt.
In React Native that cycle exists, but the agent assembles it from separate tools: a UI test runner, the Metro logs and the simulator screenshots, each with its own interface. Exact’s bet is that the framework delivers all of that through a single interface. That is what interests me most: how it lets an agent check the code it generates. Design is not the same as results, though: the shared operations and the diagnostics explain how an agent can work with Exact, but what has been published does not measure whether it completes more tasks or needs fewer corrections than with another framework.

What the Contract language looks like
Contract is the language the interface is written in. According to Cheever, it is “designed from the ground up for AI agents”. It resembles Python in form: indentation is significant, formatting is strict and there is little punctuation. It is explicit and strongly typed. This is an excerpt from the README’s todo app, trimmed:
shape Todo
id: string
title: string
done: bool
component Todos
state draft = ""
mutation changed as shape Change refreshes todos
resource todos = todos() as shape Todo[]
derive left = todos.filter(t => not t.done).length
action add
if draft.trim() != ""
send changed = addTodo(draft.trim())
draft = ""
view
list appearance="auto" height="100%"
section
header
text `${left} left` role="heading" testId="count"
Here is how I read it, top to bottom:
shape Tododeclares the shape of a piece of data with its types:id,titleanddone.component Todosopens the component. Everything that follows, indented, belongs to it.state draft = ""is local state: the text the user is typing.resource todos = todos() as shape Todo[]declares where the data comes from and what shape it has. Thetodos()function does not live in Contract: it is a data source written in TypeScript, in anapp.tsfile.mutation changed … refreshes todos: judging by the syntax, it declares a write and which resource is reloaded when it happens; the excerpt gives no more detail.derive left = …is a derived value: how many todos are still not done.action add: if the draft is not empty, it callsaddTodowithsend(liketodos(), a data source defined inapp.ts) and clears the draft.viewdescribes the interface: a list, a section, a header and a text that shows the counter. The text carriesroleandtestId, and no color, font or size.
What matters most is what the language does not allow. In Contract you cannot write recursive loops, a useEffect, or arbitrary TypeScript or JavaScript. Contract does not make network requests, does not read files and does not run arbitrary code: the data sources handle that. The intent is that the agent has fewer ways to get it wrong and that the typical React errors around effects and dependencies cannot be written; what has been published does not yet let anyone measure whether that reduces errors in practice.
The cost is also clear: it is a new language, without the ecosystem, the third-party documentation or the years of accumulated answers that React has. A language published in November 2026 is also new to the models; Exact’s answer is for the compiler to teach the correct form in its errors, instead of depending on what the model already knows.
Expo Exact benchmarks: results and limits
Expo published three groups of figures. One caveat before the numbers: all of them are measurements by Expo or by Cheever on a pre-alpha, and the sources provide no independent benchmarks. I did not measure anything.
The first is a web benchmark: a Pokédex-style app built by agents, measured with Lighthouse in mobile mode, taking the median of five apps per framework.
| Framework | LCP | JavaScript shipped |
|---|---|---|
| Exact | 802 ms | 0 KiB |
| Astro | 805 ms | 0 KiB |
| SvelteKit | 1150 ms | 36 KiB |
| Next.js | 2014 ms | 142 KiB |
The second measures scrolling a list with live updates on an M1 iPad Pro with a 120 Hz display.
| Implementation | Frames per second |
|---|---|
| UIKit | 96.1 |
| SwiftUI | 68.4 |
| Exact | 120.0 |
The third is the case of an unnamed early tester who migrated an iOS app the same day.
| Measure | Before | With Exact |
|---|---|---|
| Memory after launch | 106 MB | 36 MB |
| App size in the simulator | 151 MB | 36 MB |
| Time until the splash screen is gone | 1.92 s | 0.40 s |
How to read them: they point in the direction the architecture suggests (no app JavaScript runs before the first pixel), but they do not isolate the cause of each difference. And none of the three tables compares Exact with React Native: the web benchmark compares other web frameworks, the scrolling test compares against UIKit and SwiftUI, and nothing is said about what the migrated app was built with. A benchmark chosen by the framework’s author, a single migrated app and one list on one device are not enough to decide a project. In addition, the apps in the web benchmark were built by agents: they measure what an agent produces in each framework, not the best each one can do. Since Exact draws with UIKit on iOS, more frames than the version labeled “UIKit” says something about that implementation of the list, not about a general advantage. The 0 KiB of JavaScript in the web table sits alongside the roughly 20 KB web runtime the README describes; without knowing what each figure counts, I would not read them as a total absence of JavaScript. Those are the results I would expect to see reproduced by third parties before citing them as fact.
What Exact is missing today
The README does not hide the state of the project: “Exact is pre-1.0 and changes daily. There is no API stability, no backwards compatibility, and no migration guide, by design.” Cheever is just as blunt in the announcement: “Some things are definitely not complete and/or broken.” Specifically:
- Pre-alpha, with no API stability. There is no backwards compatibility and no migration guide between versions, and that is a design decision.
- Android and Windows are at an early stage. According to the README, Android builds and runs on an emulator or a phone, but it only landed on October 7, 2026. For a product that needs iOS and Android at the same quality, this alone rules it out today.
- There is no packaged CLI. You work from a checkout of the source code. You need Rust, Bun, Chrome and Xcode 27.1 or later for the Apple platforms, and the README estimates that the first native build takes 10 to 15 minutes on a laptop.
- Left out of the first version are the general gesture system (gesture arena), general layout animation, grid and masonry virtualization, a general-purpose webview and a devtools interface.
- No reuse of React Native code is claimed. Not components, not npm packages, not Expo Modules.
- It originated as an individual project. It began as a solo project of Cheever’s, with help from James Ide and other contributors; for anyone adopting it today, that weighs as much as the lack of a stable API.
The missing code reuse is the point that weighs most for anyone who already has an app. In a real Expo project, a large part of the value is in the modules: camera, notifications, payments, authentication. In the React Native to Swift series I devoted an entire post to which Apple framework replaces each expo-* package, because when you leave Expo that is the first thing you lose. The README describes access to native nodes from Swift and the option of controlling a region of the screen with native code. That is not enough to know how camera, notifications, payments or authentication would be solved on each platform; before considering Exact for a product, I would verify those integrations one by one.
What to do in your situation
There are three situations, and in two of them the answer is to change nothing:
Your situation
- App in production — Stay on React Native and Expo. Do not migrate.
- New app for a client — Start with React Native and Expo, or with native if the product calls for it.
- Technical curiosity — Try Exact on a project of your own, not on a client’s.
You have an app in production with React Native or Expo. Do nothing differently because of this announcement. Expo stated that the framework continues and that it will keep supporting it. Keep your Expo SDK up to date and look at Exact again when it has a release with a stable API, a migration guide and Android on par with iOS. If you are a founder and someone proposes rewriting your app in Exact now, ask them to show you those three things first. Today they do not exist.
You are about to start an app for a client or for your business. React Native with Expo is still the decision I would make for a product that needs iOS and Android with a single team; it is what I use in the mobile apps I build for clients, such as ArcaVida or Pet-Meet. If the product is centered on iOS and depends on capabilities that only exist in native, I would evaluate Swift; the criteria for choosing are in why a senior React Native developer should learn native. A framework that changes daily and has no backwards compatibility is not a foundation for an app with a delivery date and real users.
Your team wants to experiment. This is the case where Exact makes sense today. Follow this order:
- Pick an internal or personal project, small and with no delivery date.
- Start with iOS, which Cheever identifies as the most mature platform; web and macOS, according to him, are “pretty good”.
- Let an agent write the app and watch the whole cycle: which errors the compiler returns, how it uses the ten operations, how many iterations it needs.
- Write down what you missed from the Expo ecosystem. That list tells you which integrations are missing before you consider Exact for a client.
What you learn there is useful even if Exact changes completely: how to design an environment so that an agent can verify its own work. It is the same problem I covered in who writes an agent’s tests.
Frequently asked questions
What is Expo Exact?
Expo Exact is an app framework written in Rust that Charlie Cheever, co-founder of Expo, previewed as a pre-alpha on November 9, 2026. It uses no React, no webview and no JavaScript bridge in the interface. The UI is written in a new language called Contract, the logic in TypeScript or Rust, and it uses each platform’s own controls (UIKit on iOS, AppKit on macOS, the DOM on the web). Cheever describes it as “agent native” because it is designed so that an AI agent can build, run, see and test the app on every platform.
Is Expo Exact a React Native alternative?
Expo Exact is an alternative for new, experimental projects, not a replacement for React Native. In the Exact announcement, Charlie Cheever wrote that the Expo framework isn’t going away and that Expo will continue to support it. Exact is a different framework, still in pre-alpha. Neither the announcement nor the README says that React Native code, npm packages or Expo Modules work inside Exact, so it is not an upgrade path for an existing app either.
Can I use Exact in production?
Not yet: Expo Exact is not ready for production. The Exact README says it is pre-1.0, that it changes daily and that it has no API stability, no backwards compatibility and no migration guide. Android and Windows are at an early stage, there is no packaged CLI and you work from the source code. Today it is suitable for experimenting on a project of your own, not for an app with users or with a client.
What is the Contract language?
Contract is the language the interface is written in in Exact. It has significant indentation like Python, is explicit and strongly typed, and describes the UI, the state and the data flow together, inside each component. It does not allow recursive loops, useEffect or arbitrary JavaScript, and it does not make network requests or read files: data sources written in TypeScript or Rust do that. Expo says it is designed from the ground up for AI agents.
Can I reuse my React Native code in Expo Exact?
Nothing Expo has published says you can reuse React Native code in Expo Exact. The Expo Exact announcement and README claim no compatibility with React Native components, npm packages or Expo Modules, and the interface is written in Contract, not in JSX. I would not assume that an existing app can move to Exact by updating dependencies.
What does Expo Exact mean for a React Native app in 2027?
For now, nothing that forces a change. As of November 2026, Charlie Cheever stated that Expo will continue to support its current framework, and Exact is in pre-alpha, with no stable API and no migration guide. For React Native in 2027, I would not change an app’s technology because of this announcement: I would review what the product needs and look at Exact again when it has a stable release and Android on par with iOS.
Conclusion
Expo Exact matters for cross-platform development, but not because React Native is going away. It opens a second line of work that starts from a different premise: that the framework should be designed for an agent to operate it. The ten shared operations, the clock controlled by the agent and the compiler errors that include the correction are concrete decisions that anyone building agents should study, whether or not they use Exact.
If you want to understand where development with agents is heading, clone the Expo Exact repository, build something small on iOS or the web and measure it yourself. For everything else, evaluate it again when Exact has three things: a stable API, Android on par with iOS and independent benchmarks.