A preview of Exact
Charlie Cheever · November 9, 2026
I want to share a preview of something I've been working on called Exact. It's a new Agent Native app framework written in Rust. It's extremely fast and tries to let you build exactly the experience you want with no compromises.
On the web
On the web, Exact is faster than any other fully featured web framework that I've found. Exact's performance is like a static website but with the full dynamic power of a framework like React.
Here's web performance on a Pokédex benchmark proposed by Nolan Lawson from Socket. Neck and neck with Astro and meaningfully ahead of Next.js and SvelteKit.
On the authoring benchmarks, despite being a new framework that is not in the weights of any AI model, Exact already does surprisingly well -- producing a correct result faster than Next.js for about the same cost. A static site in Astro is still cheaper and faster but I think it's within striking distance if AI models learn Exact and it makes it into the weights.
Contract
The way you author UI in Exact is in a new language called Contract. Contract is designed from the ground up for AI agents.
Contract looks like Python -- indentation has meaning, fairly rigid about formatting, fairly sparse. And it is explicit and strongly typed and pulls complexity forward into authoring like Rust. Your Contract code describes both your UI like you would in React and also your state and data flow, the way you would with Redux or Zustand or TanStack Query.
Contract is a constrained language so it can be fully analyzed. A lot of the footguns that cause performance problems or make analysis hard with JS frameworks just don't exist in Contract -- you can't write recursive loops, useEffects, or arbitrary TypeScript/JavaScript. But you can efficiently express almost every common fixture of real UIs.
Since Contract is new, agents will just try guessing at its rules and syntax. Instead of filling up every context window by making your agent read a long manual, the Contract compiler returns useful error messages that teach your agent on-demand how to do what it's trying to do. Targeted error messages are one of the cheapest ways to make an agent efficiently read only the docs it needs.
![Terminal output of the Contract compiler refusing xs[i] and .sort(), and explaining what to write instead, such as xs.at(i) and sortBy.](assets/media/refusals.webp)
Built for agents
In Exact, your agent has control over the clock which makes testing and prodding faster and easier. Instead of sleeping and hoping an animation has finished, the agent advances the clock then reads the result, so its screenshots and state reads aren't racing timers or transitions. This reduces the possibility space of things an agent needs to check on as it tries to figure out why something is happening or isn't. There are a bunch of things like this that make it easier for agents to build and debug.
Exact also gives agents the ability to inspect the state of your app and complete the feedback loop in a variety of ways -- capturing screenshots and videos, inspecting the abstract state of the UI tree, asking for layout properties, etc.
Fast updates
Because it knows, at compile time, everything about how your data is laid out and related, Contract can be surgical and efficient with updates. There is no virtual DOM or re-rendering or separate hydration. This is why Exact can deliver a static website as fast as Astro but then update it dynamically like React.
When you change Contract code, your app can update live in a few ms. It can be sent over the air for OTA updates. Through these properties of Contract, Exact gives you the speed of a Rust-based native solution with the iteration speed and dynamism of a web app.
Rust and TypeScript
For app logic that is deeper than UI in Exact, you can write either Rust or TypeScript. If you work at Shopify or Linear where there is a kind of religion around being pure native, you can write your whole app in Rust and not even ship a JS VM and everything is pure native. For most real apps, I've found it's actually more practical to write most business logic in TS.
You can also mix and match. Ex. You could write everything that you measure to be a hotspot in Rust and everything else in TS. Even if your first screen gets its data from TypeScript, Exact can draw the first frame without waiting for the JS VM.
I really do think it makes sense to write larger apps in TypeScript because your ability -- and your agents' ability -- to work on and iterate on them pays off. I have a theory that this is one of the main reasons that the Claude Code CLI (TS) is a lot more polished and feels much better than the Codex CLI (Rust) right now. Either way, in Exact, you can always choose. Both Rust and TypeScript can run either on the main thread or another thread and you have control over that too.
Contract changes are mostly network bound. They take 10-20ms and generally preserve state. TypeScript changes happen in < 100ms typically. Rust updates get compiled to wasm and can be hot reloaded. On some native platforms, new dynamic libraries can be swapped in; where that's not supported, you can just run the wasm version of the new code until you rebuild.
Access Hatches
Of course, you can also write code in Swift or Obj-C or Kotlin or HTML or other languages native to your target platform. Like pretty much every other framework, you can have escape hatches in Exact. You can carve out a rectangular view and take it over with your own native code. But Exact gives you another level of control called "Access Hatches". Whenever the framework emits some kind of node on the target platform, say a UIKit UIView, you have access to it if you want, so you can write Swift code to attach a property or fill in a sync native callback, etc. One of the key goals for Exact is that you always feel like you have the precise control to get exactly the result that you want.
Here's an example -- the official Liquid Glass example app that Apple provides has a bug when you long-press a tile. The expanding tile gets clipped and flashes white when you release. In the Exact version, you have the control over each native element to be able to implement the correct behavior easily. It's a small detail but I built this framework for people who care about getting these kinds of details right (James Ide was the one who noticed this).
Native performance
There are two main things people care about with native performance: (1) smoothness/fps and (2) startup time. Re: smoothness, here's Exact vs SwiftUI scrolling through the same rich content feed. You can see Exact holds 120fps and drops zero frames while SwiftUI drops down into the 30-50fps range and is extremely late on many frames.
It's close enough that it's hard to tell the difference visually but Exact slightly outperforms idiomatic raw UIKit on fps. This is possible because Exact handles layout and view recycling in a way that is more optimized than most UIKit implementations. With enough work/tokens, you can achieve the same performance with UIKit. But with Exact, you just get it right out of the box.
One of the reasons Shopify rewrote their mobile apps from React Native into native was to improve performance metrics like startup time. Here's the new, optimized, native Shopify Shop app compared to the same thing in Exact. The Exact version is talking to the same GraphQL API and fetching the same data. (Yes, I'm sure Shopify could make their Swift app as fast to start up with some time and tokens.)
One part of why startup can be so fast is Contract. Because Contract is so explicit and analyzable, the build can bake your first screen's UI and any data it can compute ahead of time into the app, sort of the native equivalent of statically generated HTML. At launch, Rust draws that first frame without running any of your JavaScript. Data that needs the network fills in right after. It's also because Exact is powerful but compact, so you don't usually need to load lots of other stuff to do most things you want to do.
Layout and graphics
Exact does layout in Rust using Taffy, which is based on CSS. This means the shape of authoring in Exact is roughly web-like which makes it easier for agents to author it since they are familiar with CSS. Styling also works this way.
Rust code can also measure text with the same line-breaking code Exact itself uses. That makes effects similar to Cheng Lou's Pretext examples possible.
Exact also has GPU support built in, since rich animations and drawn graphics are more and more a standard part of apps and websites. You can also put live UI inside a GPU surface and run it through a shader, similar to HTML-in-Canvas.
Every platform
On iOS and macOS and the web, the platform provides familiar elements that users really love and want, and so it's important that Exact be able to use those. On Android, the platform is much more fragmented and on Windows and Linux, there really isn't much of a standard, so Exact takes over more of the drawing of pixels.
Exact implements its own renderer for drawing pixels on platforms like Linux and Windows called Ink. It's similar to GPUI or egui but works as a renderer under Exact's layout system and can include system native elements, etc. Ink, GPUI and egui perform about the same for users. Ink starts a bit faster but uses more GPU and peak memory.
I originally thought desktop would be a lower priority than mobile and web just because there are fewer desktop apps but it felt so good to play with and fun to develop for, I've come to believe that we're going to see an explosion of native desktop apps built on frameworks like this one. Especially on Mac, I've found you can make something that feels much lighter and faster and tighter than an Electron app.
Exact also comes with an agent native game engine that lets you write Contract for app-like UI and the ability to change state programmatically and quickly. It targets Metal and Vulkan on native platforms and WebGPU on web.
You can also build TUIs with Exact. It's good at UIs with rectangular panes, etc.
Since we are fully in the agentic era of software now, Exact apps also expect to be used by agents and provide a variety of APIs and a11y metadata, etc. to facilitate that.
Try it
iOS is the most mature platform. Web is pretty good and macOS is pretty good. Android and Windows and Linux work but are less mature. One of the first people to test it migrated their iOS app same day because the metrics were compelling enough.
Still a work in progress but I think it's ready for others to try it out. Here's the repo: github.com/expo/exact
James Ide started a repository of template apps you can use as a starting point for building with Exact: github.com/expo/exact-templates
I started this as a solo project but have lately gotten a lot of help from James Ide and additional contributions from Eliot Hertenstein, Krzysztof Magiera, Daehyeon Mun, Nathan Schroeder, Seth Webster and Doug Lowder.
The Expo framework isn't going away. Expo the company will continue to support it. It is growing faster than it ever has before. It is getting better quickly as AI makes huge performance improvements to React Native and the Expo SDK and Expo Modules continue to improve. Exact will work with Expo's cloud services for building, updating, observing, hosting your apps, etc.
This is a pre-alpha preview of Exact. Some things are definitely not complete and/or broken. I haven't decided what real release process will look like in the future yet. You're welcome and encouraged to report issues and request features and give feedback. Releasing with the MIT License so feel free to modify, fork, etc. however you like.
The most helpful thing you can do is probably to tell your agent to submit diaries of its experience building with Exact to the feedback endpoint. Detailed logs of agents' experience are gold for pinpointing what to fix and improve. Thanks for checking it out.