Coderefercoderefer
CoursesWebinarsBlogAbout
Coderefercoderefer

Discover. Learn. Automate. Grow.

Learn

  • Courses
  • Webinars
  • Blog
  • Search

Company

  • About
  • Contact
  • FAQ

Legal

  • Privacy Policy
  • Terms of Service
  • Refund Policy
© 2026 Coderefer. All rights reserved.
HomeBlogExpo Exact Explained: One App for Web, macOS, iOS and Linux
ai-toolsNovember 15, 20267 min read

Expo Exact Explained: One App for Web, macOS, iOS and Linux

Expo's new Exact framework runs one Contract app natively on web, macOS, iOS and Linux in a ~20KB runtime, built for AI coding agents to write, run and test it.

V

Vamsi Tallapudi

Manager, Architect Technology at Cognizant

Expo Exact Explained: One App for Web, macOS, iOS and Linux

Expo just open-sourced Exact, a new app framework that lets you write one codebase and run it natively on the web, macOS, iOS and Linux, with Android and Windows landing in early form. The twist: it's built from day one to be written and tested by AI coding agents, not humans typing into a text editor.

Expo founder and CEO Charlie Cheever posted the preview on November 9, 2026, calling it "a new Agent Native app framework written in Rust." Within a week the repo had picked up over 4,200 stars and hit #5 on Trendshift's overall trending chart, #1 in the Rust category. That's a fast ramp for something its own creators call pre-alpha.

What Is Expo Exact?

Exact is a cross-platform app runtime written in Rust. You describe your UI once in a small declarative language called Contract, write your data logic in TypeScript or Rust, and the same source runs natively on four platforms without a shared web view underneath.

There's no JSX, no React, and no JavaScript bridge between your view and the screen. On web it compiles down to a compact "plan" executed by a roughly 20KB runtime that still drives real DOM and CSS. On macOS, iOS and Linux, a Rust runner interprets the same plan and hands drawing off to each platform's native toolkit: AppKit on Mac, UIKit on iOS, and a GPU/CPU painter on Linux.

That's a genuinely different bet than React Native or Flutter. Both of those still ship a layout engine or a JS runtime that has to boot before your first pixel shows up. Exact's whole pitch is that nothing runs before the first frame.

How Does Contract Work?

Contract is the piece people either love or bounce off immediately. It's a small, indentation-sensitive language, closer to Python than JSX, that defines state, actions and a tree of styled boxes. Each app ships three files working together:

  • app.contract — the view: layout, bindings, and what happens on interaction
  • app.ts — the data module: I/O, mutations, anything that touches the outside world
  • app.test.contract — tests that drive the app the same way an agent would

The design philosophy, in Cheever's words, is "write the web, ship the platform." You style things with CSS names and semantics, and each platform fills in its own defaults, system colors, native controls, native gestures. The browser acts as the parity oracle: if your layout matches there, it's supposed to match everywhere else too.

Here's the part that's harder to swallow if you've spent years in JSX: Contract is deliberately constrained so it can be fully statically analyzed. You can't drop arbitrary logic into the view layer. A few early reviewers, including a DEV Community post that called it a research toy pre-1.0, flagged that as the sharpest trade-off in the whole project. No arbitrary code in the view means agents can reason about every app the same way, but it also means you lose an escape hatch humans reach for constantly.

Why Build a Framework for AI Agents Instead of Developers?

Exact treats a coding agent as the primary author of your app, not an assistant typing suggestions into your editor. Every platform exposes the same 10 operations through one driver, run via scripts/agent.mjs:

OperationWhat it does
treeReads the current UI structure
screenshotCaptures what's on screen
tapSimulates a touch or click
typeEnters text into a field
stateInspects app state directly
layoutReports computed box positions
logsStreams runtime logs
clockAdvances or freezes time
preferToggles OS-level preferences
perfReports timing and frame data

That clock operation is the one I keep coming back to. The agent controls time instead of waiting on it, so tests can advance an animation or a timer deterministically rather than sleeping and hoping the UI settled. Anyone who has debugged a flaky Playwright or Detox test because of a stray setTimeout will get why that matters.

The same 10 commands work identically whether the agent is driving a Chrome tab, an iOS Simulator, a connected iPhone, or a headless Linux build. That uniformity is the actual product here, more than Contract itself.

How Fast Is It, Really?

Expo's numbers, straight from the README and its own benchmark run:

  • 100ms median (p50) from cold launch to the first operable screen
  • ~20KB web runtime size, versus React's 81KB on the same RealWorld benchmark app (26KB for Exact's full RealWorld build)
  • 120fps scrolling, per Expo's own announcement thread
  • No JavaScript executes before the first pixel renders

I haven't run these benchmarks myself yet, and until there's third-party reproduction I'd treat them as "vendor numbers, probably directionally true." A 20KB web runtime beating React's 81KB isn't shocking when you remember Exact isn't shipping a virtual DOM, a reconciler, or React itself. The comparison is closer to "framework with a VM" versus "no VM at all" than it is apples to apples.

What Platforms Actually Work Today?

PlatformStatus
WebFull support, DOM renderer
macOSFull support, AppKit
iOSFull support, UIKit (Simulator + device)
LinuxFull support, GPU/CPU painting, read-only editing
AndroidEarly, recently added
WindowsEarly, CPU/DirectX rendering
tvOS / watchOSNot yet

So "one app for web, macOS, iOS and Linux" is the honest claim right now. Android and Windows exist but aren't where the other four are. If you're a React Native shop with something already in the App Store, this isn't a migration target yet, it's a framework that changes shape daily with no backwards-compatibility promise.

Expo also quietly launched two alpha services alongside Exact: Exact Build, a Linux-based fast iOS build service, and AppDrop, a way to sign and distribute IPAs without going through TestFlight. Both point at the same goal: shrink the loop between an agent writing code and someone holding a working app on their phone.

Exact vs React Native vs Flutter

ExactReact NativeFlutter
View languageContract (new, Rust-compiled)JSX/ReactDart widgets
Native renderingAppKit/UIKit/DOM directlyNative views via bridgeOwn engine, custom painting
Web bundle (RealWorld)~26KB81KB (React)N/A
Agent-first tooling10 built-in operationsThird-party (Detox, Maestro)Third-party
MaturityPre-1.0, breaking changes dailyProduction, 10+ yearsProduction, mature

The honest takeaway: Exact isn't competing with React Native on maturity, it's competing on a different axis entirely, betting that the next few years of app development get written mostly by agents and designing the whole stack around that.

Should You Try Expo Exact Right Now?

If you're shipping to the App Store this quarter, no. The repo itself says there's no API stability, no migration guide, and the internals get rebuilt ("exact2" was a full rewrite) without warning. If you're curious about where agent-native tooling is headed, or you want to kick the tires on a Rust UI runtime that skips the JS bridge entirely, it's worth an afternoon.

My honest take: the performance story is credible given the architecture, but Contract's "no arbitrary code in the view" constraint is going to be the real fight. That's the same trade-off every declarative-but-constrained UI language has made, and it usually ends with either the language growing an escape hatch or developers walking away. I'd watch this one for six months before betting a real product on it. If you've been burned by AI-generated frontend code before, our guide to fixing vibe-coded UI covers a related problem: what happens after an agent writes the view layer and a human has to live with it.

If Rust-based tooling is new to you, it's worth getting comfortable with the language basics before you touch Exact's data layer; we cover some of the sharper edges in our Rust 1.100 cooldowns piece. And for a broader view of where agent-native tools like this stand right now, check our roundup of the top AI tools of 2026.

Watch and Read More

Testing Expo's new Exact framework with Convex
ai-tools expo rust cross-platform 2026

Comments

    Get AI tricks that save you hours every week

    New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.

    Read Next

    How to Run Qwen3.8-27B Locally With llama.cpp 1.0
    ai-tools

    How to Run Qwen3.8-27B Locally With llama.cpp 1.0

    Run Qwen3.8-27B on your own GPU using llama.cpp's new v1.0.0 release and Unsloth's Dynamic v3.1 GGUFs, with exact commands and quant picks.

    November 15, 20265 min read
    Lovable Apps Leaked Passports and 200K Messages: Check Your Supabase RLS in 10 Minutes
    ai-tools

    Lovable Apps Leaked Passports and 200K Messages: Check Your Supabase RLS in 10 Minutes

    Researchers found 24,664 Lovable apps leaking passports, payments, and 200K+ chat messages via open Supabase databases. Here's the 10-minute RLS check.

    November 15, 20266 min read
    Rust 1.100: The Never Type Is Finally Stable, Cargo Gets Dependency Cooldowns
    ai-tools

    Rust 1.100: The Never Type Is Finally Stable, Cargo Gets Dependency Cooldowns

    Rust 1.100 stabilizes the never type after 10 years and 5 attempts, and Cargo now supports dependency cooldowns to block fresh, potentially malicious crate versions.

    November 14, 20266 min read
    View all posts →