Expo Team Unveils Exact, a UI Framework for Web and Native Platforms

Expo has unveiled Exact, a UI framework for browsers, macOS, iOS, and Linux. Its API is not yet stable, so the team recommends trying it on prototypes first.

· 5 min read · 5 comments

Expo has unveiled Exact, a UI framework for interfaces that run in browsers and on macOS, iOS, and Linux. The project description in the repository, cited in a post dated November 10, 2026, says you describe a screen once, and each platform renders it using its own tools. Exact has not reached version 1.0 and does not promise API stability, so developers would be wise to try it on prototypes before choosing it for a production product.

One Interface, Different Ways to Render It

Developers define a screen, its state, and its actions in an app.contract file, and write the data logic in TypeScript or Rust. The Contract compiler turns the interface description into a compact plan. In the browser, a module uses that plan with standard DOM and CSS; the authors estimate the web runtime at about 20 KB. On native platforms, a Rust runner executes the plan, while a separate engine calculates layout according to CSS rules.

On macOS, the interface is rendered through AppKit; on iOS, through UIKit; and on Linux, through the project's own graphics renderer. The native screen is not embedded in a web view, and there is no JavaScript bridge to control it. The application's JavaScript does not run before the first frame: the data it needs is included in the plan at build time. Later, the TypeScript logic runs in the browser engine on the web and in Hermes on native platforms.

The goal is not to make every screen look identical down to the last button. Developers can specify layout and styling with CSS properties and leave unspecified details to the platform, such as system controls, fonts, and navigation. This is how Exact aims to combine a familiar way of describing interfaces with behavior that feels natural on each device.

Testing and Development Speed

Exact is being designed with AI coding agents in mind. A shared set of ten operations is available across web, macOS, iOS, and Linux. An agent can inspect the element tree, take a screenshot, click an element, enter text, read state, or control the clock. A test in an app.test.contract file runs on different platforms without a separate script for each one. Controllable clocks make it possible to test timers and animations without waiting in real time.

The description gives an example of one run: an agent built a to-do list and successfully tested it in a browser, on macOS, and in the iOS simulator in about 57 minutes. Around 25 minutes of that went to the initial builds for the two native platforms. That is not a promise that another project or machine will produce the same result.

The authors also set performance targets: 100 ms to the first interactive frame and 100 ms from an edit to seeing the change in development mode, both measured as medians. In the reported measurement for a new app, a Contract or TypeScript change appeared in the browser in 99 ms. In a test using the RealWorld example, Exact's web runtime started about 300 ms before a React SSR build finished hydrating; the code size was 26 KB versus 81 KB. Those figures apply to the scenarios described, not to every application.

What This Means for Projects

For developers, the appeal is not just shared interface code but the ability to test its behavior the same way across platforms. You can change a screen in the browser, then run the same test on native platforms. If a project needs both a web version and an app, this could reduce the number of separate test scripts. How much work the approach actually saves will depend on the specific screens and requirements.

The barrier to entry is still significant. The Mac setup instructions list Rust, Bun, Chrome, and Xcode; TypeScript apps on native platforms require Hermes to be installed. According to the project description, the first native build takes 10–15 minutes on a laptop, with subsequent builds taking a minute or two. Linux is supported for web development and its own host, while building for Apple platforms requires the appropriate tools.

The main consideration when choosing a stack is Exact's maturity. The authors warn that the API changes daily: there is neither backward compatibility nor a migration guide. Trying the framework on a prototype makes sense, but planning to support a product as though its APIs had already settled would be risky.

My Take

I'd like to try Exact on a small catalog. I'm especially curious whether one test could check a product list and cart both in the browser and on a native screen. But my learning project also has a backend and a payment method to choose. A shared UI will not solve those questions by itself.

For now, I wouldn't split a small store into additional systems just to use a new UI stack: in my view, that could easily create more places for something to break. For me, Exact is currently a reason to build a prototype and see how easy it is to change a screen and its behavior, not a ready-made answer to the store's architecture.

Sources

Where the news comes from. The text is a retelling in the author’s own words; the facts come from the source, the opinion is the author’s.

  1. Exact – a new cross platform UI framework by the Expo team github.com

About the author

Pavlo Khomenko

Junior full-stack developer

I’m building a practice product catalog with a cart to understand where the frontend ends and the server side begins. Right now I’m comparing a few ways to integrate payments.

All posts by the author

Leave a comment

Not published. We’ll send a link to confirm your comment.

No links or ads. Your first comment is published after review. By sending a comment you agree to the privacy notice.

  1. the interesting scaling question is how much of the contract stays genuinely shared once each platform needs different interaction patterns; keeping the browser renderer on DOM/CSS is a smart start, but I’d prototype the accessibility and platform-specific behavior early too

    1. @vasya_dev, how would you draw the line between shared contract behavior and platform-specific interaction? I’d test a concrete flow like keyboard navigation and focus handling early—those details can diverge even when the screen description stays shared.

      1. I’d keep state transitions and the intended outcome in the shared contract, but let each renderer own input details like tab order, focus rings, and native back gestures. In my little shop prototype, that boundary is easier to test with one flow on web and native than by trying to make every interaction identical.

      2. Keyboard focus is where “one screen, multiple platforms” gets a fun little reality check: the contract can describe the flow, but each platform still gets its own opinions about what Tab should do. I’d test that early too—before my prototype turns into a very small, very expensive focus-group study 😅

        1. I’d be careful not to treat platform-specific focus behavior as proof that the shared contract is failing: the contract can define the intended navigation, while each renderer maps it to native conventions. The useful test is whether those differences can be expressed without forking the screen logic—and whether the prototype exposes any performance cost early.