Exact – a new cross platform UI framework by the Expo team

The Expo team launched Exact, an open-source cross-platform application runtime that builds native applications for the web, macOS, iOS, and Linux from a single declarative codebase. The runtime allows developers to write interfaces in a compact declarative language called Contract while handling application data logic through TypeScript or Rust, entirely eliminating webviews and JavaScript UI bridges. More details can be found in github.com's report.

This report breaks down the architectural design of Exact, its automated testing system built for artificial intelligence coding agents, performance benchmarks, and multi-platform compilation mechanics. It is designed for systems engineers, mobile developers, and technical leads evaluating cross-platform UI runtimes and agent-assisted software workflows.

01Ten unified driver operations and deterministic clocks

Exact is designed around the principle of being native to artificial intelligence agents, enabling autonomous software tools to generate, execute, inspect, and verify applications without human intervention. The testing framework exposes exactly ten core operations across every supported host platform: tree, screenshot, tap, type, state, layout, logs, clock, prefer, and perf. All ten primitives are driven through a single script, scripts/agent.mjs, running against web browsers, AppKit on macOS, UIKit on the iOS Simulator or physical devices, and Linux.

The runtime eliminates animation timing flakes and sleeps by placing clock control entirely under the agent's command. An agent can advance the clock by a fixed interval or instruct it to settle, halting all execution between discrete operations. Tests are declared as scripts of these operations inside app.test.contract files, allowing an identical test suite to validate application state across all target platforms with no secondary evaluator required.

Command-line tooling communicates directly with machines via structured formats, where contract build provides JSON diagnostics with stable identifiers and source ranges, and contract symbols supplies syntax navigation. Source maps track screen nodes directly back to the line that declared them, while the driver automatically refuses to execute any build that is older than its source files. In an initial test run with Claude Code on macOS, a fresh clone constructed a fully tested todo list application across web, macOS, and iOS in approximately 57 minutes, with the first build consuming about 25 minutes.

02Zero JavaScript before the first pixel

Performance tracking in the framework enforces zero application JavaScript execution prior to the initial interactive frame. Contract source code compiles ahead of time into a compact plan of tables and bytecode, baking constant data directly into the binary so that the first frame requires no runtime compilation or script execution. TypeScript code compiles directly to Hermes bytecode at build time, deferring execution until after the first pixel appears on screen.

Internal engineering rules set a strict budget targeting a 100-millisecond median cold start to an interactive first frame, alongside a 100-millisecond median turn-around for development restarts. Rebuilding an individual modified crate is budgeted at 30 seconds, while the blocking check suite is budgeted at 65 seconds. On a freshly initialized project, saved Contract or TypeScript modifications rebuild and update live in the page within 99 milliseconds.

Web builds omit heavy dependencies to preserve network transfer and hydration speed. In the RealWorld Conduit benchmark, Exact's web runtime became interactive roughly 300 milliseconds before a React server-side rendering build hydrated, using a 20-kilobyte runtime package compared to React's 81 kilobytes. Optional system capabilities such as GPU rendering, Markdown editing, text flow, and browser SQLite are split into isolated, demand-loaded artifacts rather than compiled into core crates.

03CSS layout with native platform defaults

Developers structure layouts using standard CSS vocabulary, properties, and flexbox conventions, while unstyled visual presentation delegates directly to the host platform. A bare layout node behaves like an HTML div element, establishing display block, content-box sizing, flex direction row, and flex shrink of one. The Contract compiler rejects property aliases, requiring standard web naming conventions like font-size, object-fit, text-overflow, line-clamp, light-dark, and safe-area insets.

Where author styling leaves attributes unsaid, the runtime renders native platform components, system typography, motion, gestures, and accessibility controls. Body text defaults to system label styling, rendering at 17 points on iPhone, 13 points on Mac, and browser preference defaults on the web. Pushed views receive the host system's standard navigation and Back controls, producing user interfaces that match hand-crafted UIKit or AppKit applications.

The browser functions as the layout oracle, against which native platform rendering is verified for parity across Canvas 2D, SVG, gradients, and motion. Layout engines are customized to avoid artificial constraints, using a patched version of Taffy on native targets, while allowing platforms to leverage specific hardware features such as native MapKit on Apple devices or real HTML inside SVG foreignObject elements on the web.

04Four compiler passes and modular host presenters

Exact compiles Contract files through four sequential passes covering syntax parsing, type verification, dependency analysis, and plan lowering. The resulting plan is processed by a dedicated virtual machine runner that coordinates keyed component instances, incoming user events, clock-based timers, and a unified data seam. On native hosts, an arena-based kernel computes CSS box models using Taffy, while platform-specific subsystems measure typography using CoreText on Apple operating systems and cosmic-text on Linux.

Presenters render the final node tree according to each target operating system's native graphics layer. The web host manipulates real DOM nodes directly, letting the browser execute CSS transitions and layout without bundling an external layout engine. The Apple host links as a static C ABI library driving AppKit and UIKit native presenters, while the Linux host draws directly to DRM and KMS with evdev input, or outputs to offscreen buffers using vello GPU or tiny-skia CPU renderers.

Application data sources operate strictly beneath a declared data seam, supporting TypeScript execution via Hermes on native targets or the host JavaScript engine on the web. Rust modules compile natively and can be swapped live during development as shared libraries or compiled to WebAssembly for iOS and web targets. Access to the network, local file systems, SQLite databases, and secure keychains is strictly guarded through explicit capability grants.

05Daily pre-release changes and upgrade mechanics

Exact is currently classified as a pre-1.0 software project under active daily development. The Expo development team maintains no backwards compatibility guarantees, no stable public application programming interface, and no automated migration guides during this development cycle. Architectural changes deploy directly into the main repository tree as features evolve.

Recent structural updates have revised mutation protocols within the runtime packages. Mutations in snapback that return an ok false state now throw a refused error and expose an underlying failure slot. Commands to update legacy applications and review before-and-after usage examples are documented inside the snapback4 package instructions.

Project setup downloads and verifies pinned host and iOS bundles once during initial configuration, allowing subsequent development builds to proceed entirely offline. Developers can generate complete demonstration applications, including the Softwear catalog store, directly from the exact-templates repository to inspect production Contract implementations across web, mobile, and desktop environments.