exact README

README проекта с github.com/expo/exact. Одним файлом markdown: README.md.

Exact

Write an app once. Exact runs it natively on the web, macOS, iOS and Linux, with Android and Windows in early form, and a coding agent can build, run, see and test it on each of them.

Exact is a framework for apps that run on several platforms from one source. You describe the interface in Contract, a small declarative language whose layout and property names are CSS's. You write the data logic in TypeScript or Rust, or declare a plain HTTP read in Contract itself and write no data code at all. On the web, the build is one ES module over a runtime of about 20 KB that drives the browser's own DOM and CSS. On macOS and iOS, the app is AppKit or UIKit views and the system's own controls. On Linux, Exact paints the screen itself. No platform uses a webview or a JavaScript bridge in the UI, and no app JavaScript runs before the first frame.

Exact is for developers who want one app on many platforms that looks and behaves native on each, and for the coding agents they work with: every tool reports in a form a program can read, and an agent can operate a running app on any platform. If you know React Native or Flutter, Compared with React Native and Flutter says what is different.

Platform Status What draws the app
Web Works The browser's DOM and CSS
macOS Works AppKit views and native controls (no SwiftUI)
iOS Works, on the Simulator and on devices UIKit views, native controls and the system's bars
Linux Works Exact's painter, on the GPU or the CPU, on a DRM/KMS console or headless
Android Early: builds, runs and passes its tests on an emulator or a phone Exact's painter, replayed onto Android's Canvas, with Android's own text fields
Windows Early: general control parity and delivery are unfinished Exact's painter, in Fluent style, on DirectX 11 or the CPU

The repository also has a tvOS variant of the iOS host, a watchOS app drawn by SwiftUI, and a terminal host for apps written for the terminal.

[!NOTE] Exact is pre-1.0 and changes daily. There is no API stability, no backwards compatibility and no migration guide, by design (rules/DEFERRED.md). There is no packaged release: you work from a checkout of this repository.

Web iOS macOS
Softwear's hoodies page in Chrome Softwear's hoodies page as a native iOS app Softwear's hoodies page as a native macOS app
The browser's own DOM and CSS UIKit views, native controls and the system's tab bar AppKit views and native controls

One app.contract, the same screen on three hosts, captured by the agent driver. Softwear is a demonstration store you can generate from exact-templates: it shows Alternative Apparel's catalog, is not affiliated with that brand, and takes no real orders or payments.

The smallest useful app is one file. This one has a piece of state, an action that changes it, and a view:

component App
  state count = 0
  action increment
    count = count + 1
  view
    button press=increment
      text `Count: ${count}`

It names no colour, font or size, so each platform draws its own button. Contract below shows a complete todo app with its data in TypeScript and a test that runs on every host.

Contents

Compared with React Native and Flutter

React Native and Flutter also build apps for several platforms from one source. Exact differs from them in five ways.

React Native and Flutter are mature: both have versioned releases, years of production use, large communities, and package registries (npm and pub.dev). Exact has none of these. There is no release and no package; you build from a checkout of this repository, and its interfaces change daily. Its Android and Windows hosts are early. Platform features come from the first-party packages in packages/; a data module can import pure-JavaScript npm packages, but React Native and Flutter plugins do not work. There is no JSX or React layer, so React components do not carry over.

Quick start

These steps were run on macOS on Apple Silicon. Linux also runs the web loop, the Linux host and the iOS cross compiler. Windows runs the web loop and the Windows host; for iOS builds there, use WSL 2 with Ubuntu 24.04.

1. Install the tools

Then bun scripts/exact.mjs setup, run once, installs the rest: the pinned stable Rust and the pinned nightly that builds the web's wasm, with their components and targets (the nightly's clippy lints a game's web build); the matching wasm-bindgen; the pinned Binaryen, into ~/.cache/exact/binaryen, where builds find it; the Bun dependencies; the Chromium the pinned Playwright drives, which the agent uses for the web (CHROME selects another); the crates of exact2's lock and the game SDK's (game/app/shells.lock), since builds resolve crates offline; and the pinned, attested Hermes bundles TypeScript apps need on native hosts: this machine's, the iOS and tvOS ones it can build, and Android's where the Android SDK is installed. Ordinary builds never download or compile an engine; docs/reference.md has the Hermes installer and its targets. setup --check names what this machine is missing, the Apple SDKs and Swift among them, without changing anything. For Hermes it runs the installer's offline check, which authenticates the receipts, archives, compiler and host/target bytecode pairing.

2. Run Caltrain in the browser

git clone https://github.com/expo/exact.git
cd exact
bun scripts/exact.mjs setup
bun host/web/dev.mjs            # Caltrain, at http://127.0.0.1:8765/

The first run compiles the toolchain, which takes a few minutes. After that, open apps/caltrain/app.contract, change some text, and save. The page rebuilds and reloads in about a tenth of a second.

Add --lan to open the same page from a phone on your network. The server answers only to the host names it prints, as a guard against DNS rebinding; a request with any other Host gets 421. To share the page through a tunnel such as tuft host, name the tunnel's host with --allow-host <name> (repeatable; name:port pins a port). An allowed name reaches the page and its reload stream, never the local installer's token.

3. Run it natively

bun host/apple/build.mjs --run              # macOS
bun host/apple/build.mjs --ios --run        # an iOS Simulator (--device --run for a connected iPhone)
bun scripts/build-linux.mjs caltrain        # Linux: a DRM/KMS console, or headless anywhere

A first native build takes ten to fifteen minutes on a laptop; later builds reuse it and take a minute or two. Watch its output rather than waiting blind. iOS commands use an iPhone simulator that is already booted, or boot the newest iPhone Pro. To choose one, set EXACT_SIM to its name or UDID (or pass --sim to build.mjs), and keep the same setting for agent.mjs ios.

On Linux KMS, EXACT_ROTATE=0|90|180|270 turns the completed image clockwise. Without it, the connector's panel orientation property chooses the angle; an absent property means 0. At 90 or 270 degrees layout uses the swapped mode size. The GPU rotates the image before display. Absolute evdev and VNC coordinates use the inverse transform; relative mouse movement and scrolling keep the user's axes. Agent screenshots show the rotated framebuffer, at the panel mode's size. Their replies give that image's point dimensions and clockwise rotation in degrees; comparison maps layout boxes onto those axes. Agent layout and target coordinates remain logical. In a headless Linux host, EXACT_SIZE supplies the unrotated panel size in points. Ink blits its retained target before readback; other painters upload their completed pixels for the GPU blit. KMS still reads back into dumb buffers.

On Linux, a development build can serve its screen over VNC: set EXACT_VNC=1 and EXACT_VNC_PASSWORD to 1–8 bytes. It listens on 127.0.0.1:5900; EXACT_VNC=host:port selects another address. Production bakes ignore both variables.

4. Make your own app

bun scripts/exact.mjs new ../hello          # or run `bun link` once, then `exact new ../hello`
cd ../hello
bun exact.mjs contract types app.contract -o app.contract.d.ts   # the first run builds the compiler
bun exact.mjs web                           # the dev loop, at http://127.0.0.1:8765/
bun exact.mjs test web                      # the app's *.test.contract, or the files named
bun exact.mjs mac --run                     # this Mac
bun exact.mjs ios --run                     # an iOS Simulator

exact new creates a standalone app: app.contract (the view), app.ts (its data), app.json (the manifest: name, bundle id, hosts, deploy policy) and app.test.contract (its test). The app holds no crate: a native verb (mac, ios, linux, android, windows) builds in a Cargo workspace it generates under .exact/shells/, which uses your exact2 checkout by path. bun exact.mjs help lists the commands, including bun exact.mjs contract … for the compiler and contract vocab for a card of what an app writes (--all: every tag and property Contract accepts).

Read docs/start-here.md next, or for a website docs/start-here-site.md. It is the only required reading for building an app; the rest of the documentation is for lookup. The app's own AGENTS.md (and CLAUDE.md) points a coding agent at the same guide.

To upgrade an app made with an older checkout, run these commands from its directory. Upgrading an inherited app covers the changes that need a hand edit.

bun exact.mjs update
bun exact.mjs contract migrate app.contract   # rewrites retired Contract syntax
bun exact.mjs lock
bun exact.mjs contract build app.contract --json --errors-only

Look at every screenshot, not only the test result: a test passes on a layout that spills off the screen. bun exact.mjs agent <host> "screenshot out.png" shows the app on each host in its own session; for a copy you launched yourself, use xcrun simctl io <device> screenshot out.png on iOS.

bun scripts/exact.mjs also runs apps from this repository as real Mac apps: exact run markdown README.md, or exact install markdown to put mdview on your PATH. exact list shows what is here.

Or ask a coding agent

On a Mac with Xcode, Rust and Bun installed, give Claude Code this prompt:

Clone https://github.com/expo/exact and follow its README to make a new Exact
app with `exact new`. Run `bun scripts/exact.mjs setup` once first. Make a todo
list where I can add items, check them off, delete them,
and see how many are left. Put the view in Contract and keep the list in `app.ts`.
Write an `app.test.contract`, pass it on web, macOS, and the iOS Simulator with
`scripts/agent.mjs`, then open the app for me on all three.

On 2026-10-04, a fresh agent given an earlier version of this prompt on a clean clone, with Hermes installed and Cargo's cache warm, finished in about 57 minutes, and its tests passed on all three platforms. About 25 of those minutes were the first macOS and iOS builds; later builds take a minute or two.

Three principles

  1. Write the web, ship the platform. What you write is CSS: its names, its layout model and the browser's fast development loop. What you leave out is the platform's: controls, colour, type, motion, gestures, the keyboard and accessibility come out as in an app built by hand for that platform. What you write wins (LLP 1115; details).
  2. An agent can do the whole loop. It can create an app, run it on any host, see it, operate it, control its clock and run its tests, with no person watching (details).
  3. Fast to start and fast to change. The budgets below come from rules/RULES.md. The gate's is checked on every change and the others every hour. A regression is top priority and is attributed to the commit that caused it (details).
Budget Target
Cold start to interactive first frame 100 ms p50
Dev restart, edit to present 100 ms p50
App JavaScript executed before first pixel none
Touch one line, rebuild that crate 30 s
The blocking gate, warm, after a one-crate edit 30 s

How it works

flowchart LR
  subgraph author["You write"]
    C["app.contract<br/>view · state · actions"]
    D["app.ts or a Rust crate<br/>data sources"]
  end
  C --> K["Contract compiler"] --> P["plan<br/>tables + bytecode"]
  P --> W["Web<br/>one ES module, ~20 KB runtime,<br/>the browser's DOM and CSS"]
  P --> R["Rust runner<br/>+ layout kernel (Taffy)"]
  R --> M["macOS<br/>AppKit + CoreText"]
  R --> I["iOS<br/>UIKit + CoreText"]
  R --> L["Linux<br/>vello GPU / tiny-skia CPU"]
  D -.->|answers, checked against declared shapes| W
  D -.-> R

What is CSS's, and what is the platform's

The order of precedence is the author, then the platform, then CSS's default. One test settles a dispute: would someone who knows the platform notice the difference? If so, the platform's answer wins.

Writing the web doesn't mean the lowest common denominator. Where a platform can do more (real HTML in an SVG foreignObject on the web, MapKit through a native module on Apple), Exact lets it.

How it stays fast

Contract

Contract describes what an app shows and how its state changes. Its views and actions don't fetch, read files, or run arbitrary code; data sources do that. Here is a complete todo app: a Contract file, a TypeScript file, and a test. This exact app was built for web, macOS, and the iOS Simulator, and its test passed on all three.

To try it in an app created with exact new, replace app.contract, app.ts and app.test.contract with the examples below.

// app.contract: the view, its state, and what each action changes. It names no colour,
// font or control size: each host draws its own heading, field, button, checkbox and list.
shape Todo
  id: string
  title: string
  done: bool

shape Change
  count: number

component Todos
  state draft = ""
  mutation changed as shape Change refreshes todos
  resource todos = todos() as shape Todo[]
  derive left = todos.filter(t => not t.done).length

  action edit(value: string)
    draft = value
  action add
    if draft.trim() != ""
      send changed = addTodo(draft.trim())
      draft = ""
  action toggle(id: string, done: bool)
    send changed = setDone(id, done)
  action remove(id: string)
    send changed = removeTodo(id)

  view
    list appearance="auto" height="100%"
      section
        header
          text `${left} left` role="heading" testId="count"
        row
          input value=draft input=edit submit=add placeholder="What needs doing?" aria-label="New todo" testId="new-todo" flex=1 min-width=0
          button press=add buttonStyle="filled" testId="add"
            text "Add"
      section
        for t in todos key=t.id
          row delete=remove(t.id) testId=`todo-${t.id}`
            input type="checkbox" checked=t.done change=toggle(t.id) aria-label=t.title testId=`toggle-${t.id}`
            text t.title flex=1
            button press=remove(t.id) destructive=true testId=`remove-${t.id}`
              text "Delete"
// app.ts: keeps the list, and answers what app.contract asks for
import type { Answer, Sources } from './app.contract.d.ts';

export const grants = '';  // e.g. 'net.fetch https://api.example.com'

type Todo = { id: string; title: string; done: boolean };
let todos: Todo[] = [];
let next = 1;

const sources: Sources = {
  todos: () => todos,
  addTodo: ([title]) => {
    todos = [...todos, { id: String(next++), title, done: false }];
    return { count: todos.length };
  },
  setDone: ([id, done]) => {
    todos = todos.map((t) => (t.id === id ? { ...t, done } : t));
    return { count: todos.length };
  },
  removeTodo: ([id]) => {
    todos = todos.filter((t) => t.id !== id);
    return { count: todos.length };
  },
};

export const answer: Answer = (source, args, store, storage, native) =>
  sources[source](args, store, storage, native);
// app.test.contract: runs on any host with `scripts/agent.mjs <host> --test`
test "add, finish and delete"
  expect text "count" == "0 left"
  type "new-todo" "Buy milk"
  tap "add"
  type "new-todo" "Walk the dog"
  type "new-todo" key "Enter"
  expect text "count" == "2 left"
  tap "toggle-1"
  expect text "count" == "1 left"
  tap "remove-1"
  expect tree missing "todo-1"
  expect tree has "todo-2"
WebmacOSiOS Simulator
The todo app on the web host The todo app on macOS The todo app on the iOS Simulator

The view never edits the list itself. An action sends a mutation to a source, app.ts changes its data and answers, and refreshes todos asks for the list again. Data lives in one place, and every change to it is a named, typed call an agent can see. This list lives in memory. To keep it across launches, give app.ts a grant like sqlite.open app:/data/todos.db and use storage.sqlite, as Fieldnotes does.

A source that is one HTTP request needs no app.ts: declare it in app.contract with its URL, and Contract reads the JSON reply into the shape. The URL's origin is its grant. The declared-source recipe has whole examples, and Weather Now is an app built that way.

For more, read the complete guide for humans, or look things up in the guide for agents, the grammar and vocabulary reference and the recipes.

The pieces

Concept What it is
shape A closed record type. Fields are number, string, bool, another shape, option<T>, or T[].
component A unit of UI. The first one in a file is the root. Components take props, can inject what an ancestor provides, and can fill a slot with children.
state A value the component owns, its type inferred or declared (state picked: option<Item> = none). Under a for, child state belongs to that keyed row.
derive A value computed from others, recomputed when they change.
resource Data from a source: resource x = source(args) as shape T. When the arguments change, the source is asked again.
mutation / send A change made through a source: send x = source(args). refreshes r asks resource r again afterward, pending(x) and failed(x) show progress, and failure(x) says why a resource failed.
source A source declared in app.contract: one HTTP request (url, method, header, body json or graphql, pointer) whose JSON reply is read into a shape.
action The only place state changes. What it writes is inferred from its body, and let binds a local inside it.
task Work on a schedule: every(1000, tick), after(ms, a), every(frame, a).
view Indented elements, if … else, for … key=… (a key is required), match over options, and calls to other components.
style / class= A named set of CSS properties. The node's own attributes win, and there is no cascade.
fn, xs.map / xs.filter / xs.join Pure, single-expression helpers. Recursion is refused.
Built-in functions The web's string and array methods by their names, called on the value (xs.length, s.trim(), s.includes(t), xs.at(-1)), and functions (first(xs), formatDate, formatNumber); all are listed with their types under stdlib in plan/tables/format.json.
routes A router: a location and a retained stack per tab, moved with open, push, replace, and back, and read with top.
font Declares a font family and binds it to files at build time.
use … from "./x.contract" Imports components, shapes, styles, and fns from another Contract file.
testId A stable name for the agent, tests, and accessibility tools.

What Contract leaves out, and why

These limits serve the principles. An agent cannot write a data race, because the language cannot express one. A plan with no JavaScript in it starts fast. A view written in CSS's own words lays out the same on every host and looks at home on each.

The compiler talks back

$ cargo run -q -p contract -- build app.contract
app.contract:4:5 [type-assign] `count` is `number`, cannot assign `string`
app.contract:7:23 [lower-unknown-attr] `text` has no attribute `size`; `size` is spelled `font-size` here, the web's name (LLP 1017 §8.1)

One run reports up to twenty independent errors, not just the first. Other subcommands: --json for tools, symbols (definitions and references as JSON), fmt (source-preserving), types (generates app.contract.d.ts for TypeScript sources), and rust (shapes for a Rust data crate). The full language is in the grammar reference; its design is LLP 1006, LLP 1017.000 (v1.1), LLP 1017.003, for data sources LLP 1027, and for declared sources LLP 1162.001.

Example apps

Each app lives in apps/<name>/. Run one on the web with bun host/web/dev.mjs --app <name>, on macOS with bun host/apple/build.mjs <name>-apple --run, and on iOS by adding --ios. All of these screenshots come from the web host, taken by scripts/agent.mjs.

To learn from, start with Shelf, the recipe app. It names no colour and no font size, and scripts/no-tells.mjs holds it to that, so it shows what an app that leaves presentation to the platform looks like on each host. Then read these for what each teaches. Except Weather Now, they paint their own colours and sizes, which LLP 1115 now leaves to the platform, so take their structure, not their style:

App What it teaches
Caltrain A Rust data crate, authored tests, routes, an optional GPU module
Weatherlight TypeScript with fetch and grants
Weather Now Sources declared in Contract, with no app.ts and no JavaScript engine
Fieldnotes Storage: SQLite, files, backup and restore
Recorder The microphone through @exact/media-capture and @exact/recording
Caltrain Weatherlight Spark Expose
Caltrain
The app that defines v1: nearby stations, live departure boards, search, theming, a Canvas 2D line map, and an aurora GPU sky. Rust data. Every host.
Weatherlight
Weather from Open-Meteo under a GPU-animated sky that follows the hour you pick. TypeScript data and a wgpu module.
Spark
A swipe deck: throw a card with your finger, and it flies off with your release velocity. Pan gestures and springs on every host.
Expose
A pretend phone OS (lock screen, home, Messages with an AI assistant, Reader) set in custom fonts. TypeScript. The assistant needs an OpenRouter key.
Calendar Sparkline Photo Editor Video Player
Calendar
Month pages, draggable sheets, events dragged between days, wallpaper themes, SQLite. It lives outside apps/, so set EXACT_APP_DIR to run it.
Sparkline
A market list of animated SVG charts that draw in and pulse.
Photo Editor
Rotate, pan, and crop, through a native module.
Video Player
A bundled clip that shrinks out of the way when the keyboard opens.
Exact Live Still, the interaction gallery
Exact Live
A creative-production workspace: a photo grid you reorder by dragging, a crew chat that can take a 10,000-message burst, and a Markdown runbook. Rust data.
Still (Interaction Gallery)
Drag to reorder, pan and zoom photos, a resizable sheet with a nested list, and 100 to 25,000 records.
Reflow Textflow
Reflow
Seven typography studies after Cheng Lou's Pretext demos: text flowing around moving balls, a dragon, masonry, and a magazine spread. Line heights come from font metrics read at build time.
Textflow
Text around shapes with CSS's shape-outside and wrap-flow: draggable orbs, a dancer, an editorial layout. One Rust walker shared by every host.
Markdown reader Conduit, the RealWorld app
Markdown
A Markdown reader that opens files from Finder or the command line (mdview README.md). Its sibling LLP (llpview) reads a directory of numbered design documents (LLPs).
Conduit (RealWorld)
The RealWorld Medium clone against its hosted API. It's the benchmark that compared Exact's web build with React 19. Web only.
SVG Gallery
SVG Gallery: SVG as the browser renders it, one page per feature, held to Chrome's pixels on every host.
Canvas Gallery
Canvas Gallery: the HTML Canvas 2D API drawn by the browser, Core Graphics, or tiny-skia, and compared to Chrome.

More apps, labs, and stress tests

App What it shows Notes
Fieldnotes A local notebook with pins, search, SQLite storage, and JSON backup and restore TypeScript + Rust
Messages A port of Expo's chat demo, talking to models through OpenRouter Needs bun apps/messages/service.ts and an OpenRouter key
Type Tour Phone-OS screens as a type specimen for the Expose fonts No JavaScript at all
Map Demo Native modules: MapKit on Apple and OpenStreetMap on the web
Carousel A horizontal virtualized list of 25,000 cards
Motion Gallery Animated GIF and WebP images and CSS keyframes, compared across hosts
Update Lab Live replacement of Contract, TypeScript, and Rust in a running app Hand-testing lab
Messages Stress, Completion Storm, Markdown Stress 100k-message histories, 128 parallel requests, and 4 MiB documents, under load Opt-in workloads (LLP 1041)
Native Fixture, Auth Fixture The native-module interface; OAuth with PAR, DPoP, and PKCE against a local server Test fixtures
Beacons, Tennis, … Games on the optional engine add-on: Rust gameplay, Contract menus bun game/dev.mjs beacons

What works today, and what doesn't yet

The v1 bar, from rules/DEFERRED.md: one real application, not a demo, runs from a single Contract source on web, macOS, iOS, and Linux, within the time budgets in rules/RULES.md. Caltrain is that application, and it runs on all four. Everything else here was admitted because a real app needed it.

Working

Early: Android and Windows

Not yet, or not at all

QUEUE.md lists what would make sense to do next.

Building for iOS on Linux and WSL

Install Swift 6.4.2, xtool 1.24.0, LLVM 23, and apple-codesign 0.29.0. Download Xcode 27.1 from Apple, then run APPIMAGE_EXTRACT_AND_RUN=1 xtool sdk install --slim /path/to/Xcode_27.1.xip. This extracts the SDK; it does not run Xcode. The environment variable lets xtool's AppImage run without FUSE.

With the cross SDK installed, setup also installs the iOS Rust targets. Build a simulator bundle with bun host/apple/build.mjs --ios --no-install hello-apple. In an app made with exact new, bun exact.mjs ios builds without installing on Linux/WSL; ios --prebuild runs the same build in the background. Linux defaults to an ARM64 simulator target; EXACT_IOS_SIM_ARCH=x86_64 selects an Intel simulator. Execution needs an iOS simulator on macOS or an iPhone; compilation, asset catalog generation, App Intents metadata and ad-hoc signing run on Linux.

Production builds with custom native views also validate the compiled factory roster. Linux can import a simulator qualification with EXACT_NATIVE_ROSTERS=/path/to/qualification.json. It contains { "version": 1, "probes": [{ "probeSha256": "…", "roster": "<JSON object>" }] }. The build writes native-probes.json beside its link products to name the probe directory it keeps. Copy that whole directory to a Mac and run its probe with xcrun simctl spawn <simulator> <directory>/ExactRosterProbe. The printed JSON is the qualification's roster string, and the probeSha256 the file lists is its digest. The digest covers every file in the directory: the executable, the module library, package libraries and declared frameworks, so changing any of them requires a new simulator run. Without a matching qualification, a production build refuses rather than accepting an absent factory or omitting its first-frame declaration. Development builds keep the manifest fallback.

For agents

Exact assumes much of an app's code will be written by AI agents, and its tools are built so an agent can make an app, run it, look at it, operate it, and show that it works with no person in the loop.

Drive an app

bun host/web/build.mjs caltrain-web         # the build the agent's web host serves
bun scripts/agent.mjs web tree "tap change-station" "type station-search Palo" \
  "clock +60000" state "screenshot out.png"
bun scripts/agent.mjs web --test apps/caltrain/app.test.contract

Swap web for macos, ios, or linux once that host is built. Caltrain's three tests take about two seconds on the web host. Each operation is one shell argument, so quote it: "type new-todo Buy milk" types Buy milk (everything after the target is the text). "screenshot film.png over 600 every 50" films motion as a contact sheet; use an .apng name to get an animation.

To drive an app made with exact new from this checkout, point EXACT_APP_DIR at it:

EXACT_APP_DIR=../hello bun host/web/build.mjs hello-web
EXACT_APP_DIR=../hello bun scripts/agent.mjs web --app hello tree "screenshot hello.png"

Feedback

An app's AGENTS.md asks its agent to record friction in one line, bun exact.mjs feedback note "<what happened>". A note stays in the app's .exact/ with exact2's commit and the last command's verb, exit code and duration; never any command output, or the app's code or files. It goes to Expo only when the project allows it, by default after bun exact.mjs feedback shows exactly what would go. bun exact.mjs feedback never stops it for a project, and EXACT_FEEDBACK=0 on the machine. docs/diary.md has the details, including the endpoint and when a command prompts for a note.

Working on Exact

Start with rules/RULES.md, one page on how work happens here, and rules/DEFERRED.md, what v1 deliberately leaves out. Agents should also read AGENTS.md. In short:

The design record is a separate, private repository of LLPs, expo/exact-llp, which those with access clone into llp/ (git ignores it). This README and the guides cite it by number (LLP 1115 D7); a reader without it learns only that the decision is recorded. The guides under docs/ are the public documentation. This repository, exact2, is a rebuild of an earlier one ("exact1"), whose design documents are research, never authority.

Detailed operational notes cover toolchains, the Contract CLI's JSON formats, source maps, TypeScript and Rust data modules, storage, live replacement, delivery trust, the install page, and the stress harnesses. They're in docs/reference.md. Open issues are on GitHub and as files under issues/ (how that works). CONTRIBUTING.md says how to report what you hit.

Repository map

Path What's there
kernel/ exact-kernel: the node arena, wire frames, transactions, Taffy layout, and the export. kernel/tables/schema.json declares every node type, property, and opcode.
contract/ The Contract compiler (syntax → types → analyze → lower), its CLI, and the corpus
plan/, runner/ The plan format, generated from one JSON authority, and the VM that runs it
motion/ CSS transitions, springs, and the seekable clock for non-web hosts
host/ web/, web-js/ (the JS target), apple/ (Rust core, ExactKit Swift package, AppKit and UIKit), linux/, painted/ (the painter Linux, Windows and Android share), windows/, android/, terminal/, render/ (server pages), plus update adapters and rasterizers
js/, logic/, data/ The TypeScript executor (Hermes, and the browser's engine on the web), Rust logic modules, and the data seam
gpu/, canvas/, textflow/, markdown/ Capabilities loaded on demand: the wgpu canvas, Canvas 2D, text around shapes, and the Markdown editor
route/, update/, bake/, filesystem/ The router, the signed update store, delivery baking, and app-owned files
apps/, examples/, game/ The apps above, the Calendar example, and the optional game engine
scripts/ exact.mjs, agent.mjs, smoke.mjs, metrics.mjs, deploy.mjs, and the checks
rules/ RULES.md and DEFERRED.md, the two binding documents
vendor/taffy/ Taffy, plus Exact's patches

License and Snapback

The workspace is MIT-licensed (LICENSE).

The Snapback client (snapback4/) is not in this repository, and Exact works without it: in a checkout without it, exact new --snapback and bun exact.mjs snapback refuse, naming the missing client. A checkout that has it there uses published 0.4.33 with the matching immutable Rust source revision 3653cae823145170df3e720f5e321bd1b5b4d79d. Its guide, snapback4/README.md, comes with that client, so a clean Exact checkout does not have it; it covers wiring and device rebuilds.

exact (expo/exact)

Ищем в базе…

4.6K ·GitHub
Что это такое?Exact — это кроссплатформенная среда выполнения приложений: вы пишете приложение один раз, и оно работает нативно в вебе, на macOS, iOS и Linux.
Это просто обёртка над webview, как Electron или Tauri?Нет. Каждая платформа отрисовывает интерфейс своими средствами (AppKit, UIKit или GPU-отрисовщик), а в вебе управляет настоящими узлами DOM, поэтому webview не используется.
Как это запустить?Склонируйте репозиторий и выполните 'bun scripts/exact.mjs setup', чтобы установить зафиксированные версии инструментов Rust, Bun и Binaryen, затем откройте apps/caltrain/app.contract в цикле работы в браузере. Создать своё приложение можно командой 'exact new'.
Что нужно установить сначала?Rust через rustup, Bun 1.4.2 и Google Chrome для цикла работы в вебе, а также Xcode для хостов macOS и iOS. Установка загружает пакет Hermes, который нужен только для приложений на TypeScript на нативных хостах.
Почему веб-сборка такая лёгкая?Веб-версия работает на среде выполнения размером ~20 КБ, которая управляет настоящим DOM, и никакой JavaScript приложения не запускается до появления первого пикселя. В README её сравнивают с React (81 КБ) в бенчмарке RealWorld.
Раскладка работает по правилам CSS?Да: ядро раскладки на Rust вычисляет каждый блок по правилам CSS через модифицированную Taffy, а имена свойств вроде font-size и object-fit пишутся так же, как в вебе.
Почему автор говорит, что это создано для агентов?Contract намеренно сделан компактным, чтобы всё приложение помещалось в окно контекста, а одни и те же операции работают на каждом хосте, поэтому агент может создать, запустить и проверить приложение без участия человека.
Какие есть похожие проекты?perry, ondine, Codync, happy, capacitor, expo, ng-native, craft-anything
Автор
expo
Размер
203.7 MB
Звёзды
4.6K
Обновлён
КоммитNov 18
Возраст
16 д
Коммиты · 90 дней