Expo Exact: Write Once, Run Natively on Four Platforms

Expo · ax-trend issue #3908 · Repository created November 2, 2026

Title card: Expo Exact runtime, write once and run natively on web, macOS, iOS and Linux

Exact is a new runtime from Expo built around a simple claim: write an app once and 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 hosts. The repository was created on November 2, 2026 and had reached 2,154 stars and 47 forks by November 11, 2026, which is growth of more than 200 stars a day over its first nine days. The project is MIT licensed and its primary language is Rust.

The speed of that growth is worth reading carefully. Expo is the company behind the most widely used tooling in the React Native ecosystem, so a new runtime from this team gets attention on reputation alone. What makes Exact more than a reputation launch is the design premise underneath it: a large share of the code will be written by AI agents, so the runtime itself, not a plugin added later, gives those agents a way to run the app, look at the screen and prove the result with tests.

GitHub stars in nine days2,154 stars, 47 forks
Native hosts at launchWeb, macOS, iOS, Linux
Cold start budget, first frame100 ms at p50
Web runtime sizeAbout 20 KB

What Exact Is

The interface of an Exact app is written in Contract, a declarative language owned by the project, while data logic is written in TypeScript or Rust. That split is the core architectural choice. The interface is a description that a compiler can reason about and transform, and the logic stays in general purpose languages developers and agents already write well. Because the interface is declarative and compiled ahead of time, the runtime does not need to interpret a component tree at startup in the way a JavaScript framework does, which is where several of the performance budgets below come from.

Expo describes the v1 bar as already met on one point: the same Contract source runs on all four hosts, demonstrated with a Caltrain app. A claim of that kind is easy to make in a launch post and hard to fake in a public repository, because the hosts, the runner code and the sample apps are all in the open for anyone to build.

The Softwear demo app running from one Exact codebase on web, macOS and iOS screens
The Softwear demo store shown on web, desktop and phone screens from a single codebase. The demo catalog header, the category filters and the product cards stay consistent across hosts. (Photo: Expo, github.com/expo/exact)

How the Runtime Works

Diagram: write once in Contract, compile to a plan, run natively through the DOM or the Rust runner, then let the agent verify with the same tests on every host

The Contract compiler turns an interface into a plan. On the web, a runtime of about 20 KB executes that plan against the real DOM. On native platforms, a Rust runner executes the same plan. The README is explicit on two absences: there is no webview, and there is no JavaScript bridge for the UI. Both absences matter in practice. A webview would make the native result a wrapped web page, and a bridge would put a serialization boundary between the interface and the platform, which is the cost React Native developers have managed for years. Exact removes both by compiling the interface description into something each host can execute directly.

The tradeoff is equally clear. A compiled plan is only as expressive as the Contract language and its compiler, so interface patterns that fall outside the language have no escape hatch comparable to dropping into native code inside a mature framework. For a pre-1.0 runtime that tradeoff is acceptable for evaluation, but it is the first thing a team should probe with a real screen from its own product before drawing conclusions.

Agent-Native Design as the First Principle

Exact treats agent operation as its first principle rather than a feature. Ten operations, tree, screenshot, tap, type, state, layout, logs, clock, prefer and perf, drive every host through a single script, scripts/agent.mjs. A test file named app.test.contract runs unchanged when the host changes. That combination closes a loop that cross-platform development usually leaves open: the agent writes code, starts the app on a host, reads the interface tree, takes a screenshot, taps and types, checks state and layout, reads logs and performance data, and then runs the same tests on the next host without new tooling.

The README reports one concrete run of that loop. A fresh agent, given a prompt from an earlier version of the project, built an app from a clean clone in about 57 minutes, and the tests passed on three platforms: web, macOS and the iOS Simulator. A single vendor reported run proves the loop can close end to end at least once. It does not prove how often it closes on messier, real product requirements, and no independent reproduction has been published yet.

Performance Budgets and the RealWorld Result

Bar chart: RealWorld build size, 26 KB for the Exact build against 81 KB for the React build

Exact states its speed targets as budgets instead of adjectives. The goals are a cold start first frame of 100 ms at p50, a development restart of 100 ms at p50, and no app JavaScript executing before the first pixel. In the RealWorld benchmark, which implements the Conduit sample app, the README says the React server rendered build was visible about 300 ms before it hydrated, and that the code size was 26 KB for Exact against 81 KB for React. The size gap follows directly from the architecture: a 20 KB class runtime executing a compiled plan ships less code than a framework runtime plus component code.

The RealWorld Conduit app, the benchmark sample used for the Exact and React comparison
The RealWorld (Conduit) feed used as the shared benchmark sample, with the article list and popular tags visible. It is the app behind the 26 KB and 81 KB build size comparison. (Photo: Expo, github.com/expo/exact)

These numbers are project reported, and the article treats them that way throughout. The 300 ms figure compares visibility against hydration in a server rendered React build, which is a specific and favorable framing. A third party benchmark with published hardware, build settings and repeat runs is still missing, so the budgets are best read as design targets the architecture makes plausible, not as measured results a team can bank on.

Platform Support and the Android Gap

Support is uneven across platforms, and the README says so plainly. Android was accepted on October 7, 2026 and is at an early stage: apps build, run and test on emulators and real devices and agents can drive them, but distribution and store packaging do not exist yet. Windows is also unfinished, with general control parity and distribution incomplete and no packaged CLI, so work there starts from a source checkout. For an Android developer, that makes Exact a design direction to study today rather than a toolchain to adopt: the platform that matters most to that workflow is the one with the largest stated gap.

Exact is pre-1.0 and changes daily. The README states, by design, that there is no API stability, no backwards compatibility and no migration guide. Any app built on it now should be treated as an experiment whose code may need to be rewritten as the runtime settles.

Why Exact Matters for Agent-Built Apps

Most agent tooling stops at generating code and leaves a human to run the app on each platform, look at the screens and decide whether the result is right. Exact moves that verification inside the runtime: one test file, one driver script and ten host operations that an agent can call the same way everywhere. If that loop holds up outside the sample apps, the limiting factor in cross-platform work shifts from checking four builds by hand to writing a Contract interface and tests that describe the result well enough for an agent to prove it.

The realistic way to evaluate Exact now is narrow. Take one simple, real screen, build it in Contract, run the agent loop on web and one native host, and time the budgets on your own hardware. That experiment tests the three claims that matter, the write once model, the agent verification loop and the startup budgets, without betting a product on a pre-1.0 runtime with no stability promise.

FAQ

What is Expo Exact?

Exact is a new app runtime from Expo. An app is written once, with its interface in a declarative language called Contract and its data logic in TypeScript or Rust, and the same app then runs natively on the web, macOS, iOS and Linux.

How does Exact run the same app on every platform?

The Contract compiler turns the interface into a plan. On the web, a runtime of about 20 KB executes that plan against the real DOM. On native platforms, a Rust runner executes the same plan. The README states that there is no webview and no JavaScript bridge for the UI.

How do AI agents build and test Exact apps?

Ten operations, tree, screenshot, tap, type, state, layout, logs, clock, prefer and perf, drive every host through one script, scripts/agent.mjs. A test file named app.test.contract runs unchanged when the host changes, so an agent can build an app, run it, see it and test it on each platform.

Is Android supported in Exact?

Android support is at an early stage. The README says apps build, run and test on emulators and real devices and that agents can drive them, but distribution and store packaging are not available yet.

Is Exact ready for production use?

Exact is pre-1.0 and changes daily. The README states by design that there is no API stability, no backwards compatibility and no migration guide, so it suits evaluation and experiments rather than production commitments.

Related Reading

Sources

AI CodingE2E TestAX Trend