A different bet on cross-platform apps

Most cross-platform UI frameworks ask you to write one application and then render it through a framework-specific runtime. Expo Exact makes a different bet: describe the interface in a small language called Contract, keep application logic in TypeScript or Rust, compile the interface into a plan, and let each host render it using its own platform controls.

The public expo/exact repository was created on November 2, 2026. At 10:56 UTC on November 14, GitHub showed 4,094 stars and a push from that morning. Its Hacker News launch discussion had 110 points and 70 comments when checked. This is early attention, not proof of production readiness: the README says Exact is pre-1.0, changes daily, and does not promise API stability or backwards compatibility.

What Exact is trying to solve

A web view inside a desktop or mobile wrapper can make one UI run on several platforms, but it does not automatically feel native. Exact separates the interface description from the host renderer.

Contract describes the view, layout, state, and actions using concepts such as rows, lists, buttons, routes, and ARIA roles.
TypeScript or Rust supplies data logic and application-specific behavior.
The compiler turns Contract source into a compact plan.
The host renders that plan. The web host uses the browser's DOM and CSS; Apple hosts use AppKit or UIKit; Linux uses a Rust renderer.

The repository says native hosts do not use a WebView or JavaScript bridge for the UI. That is the central distinction from Electron-style wrappers. It is also not React Native: you do not write a React component tree and expect it to render everywhere.

Image: the Softwear demo store in Chrome. The sample catalog is not affiliated with the apparel brand shown and does not take real orders. Source: Exact repository.

The host model

The public README describes four working hosts today:

Host	Rendering approach
Web	Browser DOM and CSS
macOS	AppKit and native controls
iOS	UIKit and native controls
Linux	Rust host with GPU or CPU painting; headless mode is documented

The same interface description is intended to work across these targets. The repository also includes an agent driver that can launch an app, inspect its tree, tap controls, resize the viewport, capture screenshots, and run tests. An agent can test the UI it just built instead of relying only on a successful compile.

Android and Windows appear in experimental tooling and documentation, but they are not part of the README's four-host v1 bar. Do not plan a production release for either target without checking the latest support matrix.

Image: the same sample app rendered with UIKit. Source: Exact repository.

Set up the project on Linux

Exact pins Bun 1.4.2 in its package manifest. Its getting-started guide also requires Rust through rustup and Google Chrome for the browser automation loop. Xcode is required for Apple builds on macOS, not for the basic Linux web workflow.

Clone the repository and install its pinned toolchain:

git clone https://github.com/expo/exact.git cd exact bun scripts/exact.mjs setup

Create a starter app from the repository checkout:

bun scripts/exact.mjs new ~/groceries cd ~/groceries

Start the web development loop:

bun exact.mjs web

For the Linux host, build first and then run the tests:

bun exact.mjs linux bun exact.mjs test linux

There is an important distinction: the current guide says Linux test and agent commands do not build the app for you. After editing Contract, run the Linux build again before testing. The Linux host is headless in this workflow; inspect its UI tree with:

bun exact.mjs agent linux tree

Use the setup check before attempting a platform build:

bun scripts/exact.mjs setup --check --platform linux

For iOS builds from Linux or WSL, the guide lists additional cross-compilation requirements, including Swift, xtool, LLVM, Apple SDK extraction, and signing utilities. Building an iOS simulator bundle on Linux is not the same as running the simulator: simulator execution still requires macOS or a physical iPhone. Read the official tool installation section before attempting that path.

Image: the same sample store rendered with AppKit. Source: Exact repository.

What the community is questioning

The Hacker News discussion is useful because it surfaces practical concerns: why Windows and Android are not ready, whether a custom declarative language will scale to complex interfaces, and whether the project is optimising too heavily for agents instead of human maintainers.

Those are fair questions. A DSL can make common layouts concise, but every new language introduces tooling, debugging, editor support, documentation, and long-term maintenance costs. Agent-native tests are valuable, but they do not remove the need for code humans can understand.

The repository is direct about the risk: it is pre-1.0, has no API stability promise, and has no migration guide. Treat it as an experiment, not a framework to adopt for a deadline-driven production app.

Exact versus React Native, Flutter, Electron, and Tauri

React Native is a mature choice for teams that want React and native mobile UI.
Flutter provides a mature cross-platform widget and rendering model.
Electron prioritises web compatibility and its desktop ecosystem.
Tauri keeps a web frontend but uses the system WebView with a Rust backend.
Exact explores a compiled Contract interface with separate native hosts and an agent-oriented testing loop.

Exact's potential advantage is a shared declarative interface without a WebView. Its current disadvantage is equally clear: the project is young, the host matrix is limited, and the language and APIs are still moving.

Who should experiment with it?

Try Exact if you are researching agent-assisted native app development, prototyping across web and Apple platforms, or interested in declarative UI compilers. Start with the web host, write a small screen, and run the provided tests before trying a native target.

Avoid depending on it for a production release that needs stable Android or Windows support today. A successful web build does not prove native parity; verify each host and report unavailable devices or tools as untested.

Sources and further reading:

Would you prototype a native app with a new agent-oriented UI runtime, or wait until Android, Windows, and API stability are clearly supported?

Written by Shaswat. Find more work on GitHub, LinkedIn, and StackShade on YouTube.