One v3
Video Beat 01 · 0:00 Opener

One v3

A custom ahead-of-time compiled engine built for cross-platform speed: React, plain web HTML and CSS, and fully native apps in Swift and Kotlin.

npx one Adapted from the One v2 launch film · Working draft blog post + video pacing

One v3 introduces a fully custom, lightweight C++ engine paired with Bun's ahead-of-time compiler, engineered from the ground up to be the fastest cross-platform runtime. Right alongside React, it supports fully native apps written in each platform's own language (Swift on Apple platforms, Kotlin on Android, plus C++, Zig, or Rust) sharing real OS views, routing, and sync data.

TypeScript compiles ahead of time and writes straight to platform controls with zero React Native Fabric, Hermes, or bridge layers. Its UI surface is also web-aligned (plain <div>, standard CSS, Tailwind, plus an opt-in react-native compatibility layer), while websites ship pure browser HTML and CSS (~19 KB brotli JS, zero Wasm).

How to read this draft: The sections follow the visual acts and beat pacing of the One v2 launch video (Yellow opener → Dark custom AoT engine, native languages, React, and web alignment act → Yellow Bun builds, web platform, and scale act → Rapid inventory finale → 1-ball outro), assuming all current v3 work lands.
Beat 02 · Custom AoT Engine Custom, lightweight, compiled ahead of time

A custom ahead-of-time engine built for raw speed.

In One v2, every mobile screen update crossed React's reconciler, React Native's Fabric shadow tree, a duplicate Yoga mirror, view configs, Hermes bytecode interpretation, and bridge serialization before UIKit moved a pixel.

One v3 replaces that entire pipeline with a custom, lightweight C++ core (peach_core.h) and Bun ahead-of-time (AoT) compilation. Bun compiles your TypeScript into native machine code using real static types, and React writes atomic handle transactions and typed style buffers straight into the core. The core owns layout, gestures, accessibility, and reactive values, while the OS draws real native views with zero shadow tree mirrors or bridge glue.

Target What runs How pixels reach the screen
Native Apps (React + AoT) Bun AoT binary + custom One C++ core Core writes straight to CALayer/UIView/UIKit on iOS, Views/Compose on Android, AppKit on Mac, WinUI on Windows, and GTK on Linux.
Pure Native Files (.swift / .kt) Native Swift, Kotlin, C++, Zig, or Rust Native routes run as direct OS views (SwiftUI/UIKit or Jetpack Compose) with zero JS runtime booted until a TypeScript route mounts.
Web (Default) Browser DOM & CSS + lightweight JS runtime (~19 KB) Uses the browser's own HTML elements, native browser text, and browser scrolling with zero engine Wasm.
Drawn & WebGPU Surfaces (Opt-in) Skia + Dawn via webgpu.h on the shared GPU device (and Light Core Wasm on web) Canvases, shaders, games, and 3D scenes composited inside native scroll views and under glass toolbars with zero CPU copies.
Beat 03 · Native Apps in Native Languages Swift, Kotlin, C++, Zig & Rust alongside React

Write fully native apps in Swift or Kotlin, or mix them by file.

Most cross-platform frameworks force a binary choice: write 100% JS or leave the framework behind. One v3 treats each platform's own native language as a first-class citizen. You can build fully native apps written in Swift and Kotlin, keep a pure native entry point with TypeScript embedded only where you want it, or drop native screens beside React routes by file extension.

Put _layout.swift and index.swift at the root and One compiles a pure native @main App with a SwiftUI NavigationStack and zero JavaScript engine booted until a user navigates to a .tsx screen. Reverse-Nitro bindings let Swift, Kotlin, C++, Zig, Rust, and TypeScript share typed file routes, call each other directly, and observe the same native C++ Zero SQLite store as Swift @Observable models, Compose state, or React hooks.

File extensions pick each screen's language app/
app/
  _layout.swift       // Pure SwiftUI (0 ms JS)
  index.swift         // Native Swift home screen
  feed.kt             // Kotlin / Compose screen
  chat/[id].tsx       // React AoT in OneSurface
  api/messages+api.ts // Server API route
Direct imports + shared native Zero chat/[id].tsx
import { hello } from './Hello.swift'
import { vibrate } from './Motor.kt'

// Shared C++ Zero SQLite store:
const msgs = useZeroQuery(q.messages)
// In Swift: @Observable models
Beat 04 · Web Alignment Standard HTML elements + broad CSS coverage

Web-aligned React components. Standard HTML and CSS anywhere.

Once you look at React screens in One v3, the UI API matches the web. Previously, cross-platform React meant learning <View>, flex-column defaults, and a narrow subset of styles, then dragging a heavy wrapper back onto browsers.

In One v3, React uses plain lowercase HTML elements (<div>, <span>, <section>, <button>) with standard CSS properties, <style> sheets, className, and Tailwind. Boxes default to display: block and spans flow inline, matching Chrome and Safari. On iOS, Android, and desktop, the custom C++ engine implements that broad CSS and layout standard natively. On the web, the browser just runs your HTML and CSS directly.

Plain web elements, CSS Grid, Tailwind, variables, and light-dark() across iOS and web HelpCard.tsx
export function HelpCard({ children }: { children: React.ReactNode }) {
  return (
    <div
      className="grid gap-4 p-6 rounded-xl md:grid-cols-2"
      style={{
        display: 'grid',
        backgroundColor: 'light-dark(#ffffff, #191a1c)',
        color: 'var(--ink, light-dark(#141208, #f3f4f5))',
        backdropFilter: 'blur(12px)',
        paddingInline: 'if(media(width >= 48rem): 32px; else: 16px)',
      }}
    >
      <span style={{ fontWeight: 600 }}>Web-aligned UI.</span>
      {children}
    </div>
  )
}
Block, Inline, Flex & Grid

Full CSS2 block and inline flow (floats, clearance, intrinsic replaced images, RTL/bidi), Yoga flexbox compiled at -O3, CSS Grid and Subgrid, and position: fixed and sticky.

Cascade, Tokens & Tailwind

@layer, :is()/:where()/:not(), var() with nested overrides and cycle rules, light-dark(), color-scheme, @media, @container, inline if(), and full Tailwind default utilities graded against Chromium on WPT.

Modern Paint & Motion

Linear, radial, and conic gradients, multiple box shadows, 2D and 3D transforms, CSS filters, backdrop-filter, masks and clip-path, retargeted CSS transitions, and @keyframes.

Beat 05 · Lighter Web & RN Compat Optional React Native compatibility layer

Much lighter on the web, with React Native compatibility built in.

Because One v3 aligns directly with HTML and CSS, web builds never pay for react-native-web wrappers and mobile builds never pay for Fabric. Your default web pages stay tiny, render real DOM nodes directly in Chrome and Safari, and load zero Wasm.

When bringing over an existing mobile codebase or third-party UI package, One v3 includes an optional react-native compatibility layer straight on top of the custom core. Those imports stay scoped only to the files that import them: View keeps its flex-column default there, while FlatList, FlashList, LegendList, Animated, Reanimated, GestureHandler, react-native-svg, and react-native-webview map through thin adapters over the core. Existing Nitro modules also keep working over JSI.

Web-aligned default (lightest)

Use <div>, <span>, CSS, Tailwind, and one/ui. Ships zero React Native runtime on web (~19 KB brotli JS) and drives One's C++ core directly on phones.

Opt-in compatibility layer

Import View, Text, ScrollView, FlatList, or Reanimated from react-native. Linked only when imported, preserving flex-column semantics for migration without bloating web-aligned pages.

Beat 06 · Native Controls & One UI Replaces v2 "One.* / SwiftUI & Compose auto-generated"

Real native controls, plus One UI.

One v3 keeps every auto-generated SwiftUI and Jetpack Compose view and all 56+ One.* services (haptics, Face ID, StoreKit purchases, notifications, SQLite, secure storage, widgets, Live Activities, Quick Actions, maps, camera). Instead of wrapping them in 133 Fabric specs and 40 C++ shadow nodes, the host reads One's schema directly and mounts every native control on the custom core with zero bridge glue.

Navigation and overlays use real platform controllers rather than simulated UI: UINavigationController stacks with large titles and search bars, UITabBarController, UISplitViewController, UISheetPresentationController with detents and fit-to-contents, UIMenu and context menus with live React previews, and native alerts. If a platform has no native drawer (like iOS), One v3 does not invent one.

One UI: native <dialog> and scroll-snap sheets on web, UISheetPresentationController on iOS SettingsModal.tsx
import { Dialog } from 'one/ui'

<Dialog.Root>
  <Dialog.Trigger>Open settings</Dialog.Trigger>
  <Dialog.Popup snapPoints={[0.5, 1]}>
    <Dialog.Title>Preferences</Dialog.Title>
    {/* Centered modal on desktop, CSS scroll-snap sheet on mobile web, */}
    {/* and real UISheetPresentationController on iOS. Zero reparenting. */}
  </Dialog.Popup>
</Dialog.Root>
Beat 07 · Half the Stack Deleted Replaces v2 "Before / Now it takes One" pill wipe

Half the stack is gone, and React beats native cold starts.

One v2 replaced a hundred third-party packages with built-in APIs. One v3 deletes the legacy runtime and bundler stack underneath, then uses AoT startup pre-baking so React beats custom non-React frameworks on cold launch.

React Native Fabric Hermes & hermesc Metro bundler Vite & Rollup @react-navigation/* react-native-web CocoaPods Xcode project patching Duplicate Yoga mirrors
Custom One C++ Core Bun Toolchain & AoT Swift / Kotlin / C ABI Native Apps Web-Aligned HTML & CSS Prebuilt App Shells

At build time, One runs your initial route against the core, serializes the committed tree, layout, text records, and image refs into a flat binary startup image, and links it directly into the binary's __TEXT,__one_startup section. On launch, UIKit mounts that frame on the very first layout pass before JavaScript finishes booting, then React hydrates onto the live core handles without remounting a single view.

Cold start to first filled frame (iPhone Air)
One v3 (AoT)
187 ms
Expo Exact
274 ms
Bun AoT vs Hermes (React 19, 1,000-row list updates, shorter is faster)
Bun AoT
1x (~8x faster)
Static Hermes
~5x slower
Hermes V1
~8x baseline
1,000,000-row virtual lists

Virtualization runs inside the core directly off the native scroll offset using sum-tree extent indexing (no subtractive drift), measurement epochs, followEnd anchoring, viewport culling, and bounded 4 ms mount batches. Memory stays flat whether a list has 30 rows or a million.

Native streaming markdown

A built-in C++ markdown module (MD4C) incrementally parses only the open trailing block, keeps multiline syntax highlighting state across 12 languages, and virtualizes long AI answers by block so React never re-renders settled tokens while you scroll.

Beat 08 · Threads, Workers & Values Why motion holds 120 Hz and reads are synchronous

One app thread, one compositor, one reactive primitive.

Every major UI runtime (UIKit, SwiftUI, Compose, browsers, and recent Flutter) runs UI and layout on the main thread because platform APIs belong there. Because React and One's C++ core share that same app thread, layout queries like measure() and onLayout read the store synchronously in place instead of bouncing asynchronously across a JS-to-native bridge.

Meanwhile, the compositor thread and Core Animation render server own retained layers, scroll momentum, glass, and animations independently at 120 Hz. Heavy JavaScript computation moves off the main thread through a compiler-owned 'use background' directive ("reverse worklets") that splits functions into workers automatically. And for high-frequency UI updates, one core-native value() primitive replaces Animated.Value, Reanimated shared values, and signals.

1,000 updates/sec with zero React commits + automatic background offload Ticker.tsx
import { value, derive } from 'one/values'

async function crunchHistory(points: number[]) {
  'use background' // compiler splits this off the main app thread
  return points.reduce((a, b) => a + b, 0)
}

const price = value(100)
const label = derive(() => `$` + price.get().toFixed(2))
const tint = derive(() => (price.get() >= 100 ? '#16a34a' : '#dc2626'))

// Updates color and text in C++ / Core Animation / WGSL without re-rendering React:
<span style={{ color: tint }}>{label}</span>
Beat 09 · Bun Everywhere & Instant Builds Replaces v2 "Bundled in Rust" + Metro chart

No Vite. No Metro. No Hermes. Seconds to an IPA.

One v2 needed Vite and Rolldown for web and native bundling, plus Hermes for native execution and Xcode or Gradle to build apps. One v3 unifies everything on Bun.

On native, Bun's JavaScriptCore runs live Fast Refresh over WebSocket during development, and bun compile builds ahead-of-time native machine code for App Store releases using real TypeScript types. On the web, Bun runs dev SSR in-process through Bun.plugin and compiles client and server bundles for Bun, Node, or Cloudflare Workers.

One v3 also drops Xcode project patching and CocoaPods entirely. Prebuilt, content-hashed native modules (core, one-services, host-ios) pair with a direct app-shell assembler that reads your native.app manifest and writes Info.plist, entitlements, Assets.car icons (light, dark, tinted, alternates), launch storyboards, widgets, Live Activities, and App Intents directly.

iOS app packaging & build time (unchanged native boundary)
One v3 repack
~0.6–0.8 s
One v3 cloud IPA
seconds
v2 prebuild + Xcode
32.5 min

Over-The-Air updates also work directly with ahead-of-time binaries: signed Ed25519 JS updates download, verify, stage offline, run on the same embedded Bun interpreter until the next store binary, and roll back automatically if an update crashes before first paint.

Beat 10 · Web Platform Default Zero engine Wasm on websites

On the web, it just uses the web platform.

Because One v3's authoring model already matches HTML and CSS, deploying to the web skips the C++ runtime completely by default: websites just use the web platform. Plain HTML elements, native browser CSS, browser text, and browser scrolling ship with zero engine Wasm (~19 KB brotli runtime JS).

When a specific surface explicitly wants WebGPU composition with the C++ layout and gesture core, an optional light Wasm mode (~105 KB brotli) is available per surface without adding weight to normal web pages.

Default · Web Platform (Tier 1)

~19 KB brotli JS, 0 Wasm. Real HTML and CSS, native browser text and scrolling, SSR/SSG/SPA routes, and One's lightweight JS gesture and kernel runner. What every normal web app ships.

Optional · Light Core Wasm (Tier 2)

~105 KB brotli Wasm. Opt-in mode running C++ layout, scene, scroll physics, and gestures in Wasm, compositing browser text via HTML-in-Canvas on WebGPU.

Beat 11 · Unified Gestures Hit-test once across every host

One gesture arena, everywhere.

DOM event propagation is slow and breaks down when multi-touch, nested scrollers, and native gestures collide. One v3 runs a single gesture arena across iOS, Android, desktop, and web. At pointer down, it hit-tests once, collects candidate recognizers on that path, and sends move events only to active candidates.

Four decisions, not one winner

Separates eligibility (requireToFail), coexistence (simultaneousWith), native touch delivery (delaysTouchesBegan / cancelsTouchesInView), and nested delta consumption so a scroll view inside a sheet inside a pager hands off scroll deltas cleanly.

Native peer arbitration

Each recognizer exposes a real UIGestureRecognizer peer to UIKit on iOS, intercepts touch on Android, maps to AppKit on Mac, and derives touch-action on web so browser scrolling stays fast. Supports multi-touch joins (pan becoming pinch) and async pointer loops in TypeScript, Swift, and Kotlin.

Beat 12 · Shaders, GPU & 3D Write WGSL or TypeGPU once

One GPU device. Mix 3D, shaders, and UI freely.

Custom graphics run through webgpu.h on Dawn: Metal on iOS and macOS, Vulkan on Android and Linux, D3D12 on Windows, and WebGPU in browsers. Authors write shaders once in WGSL or TypeGPU, or drop Filament and Three.js 3D scenes straight into a layer inside a scrollable list under a Liquid Glass toolbar. Because everything records on one shared device, there are no intermediate texture copies and effects can sample native views directly behind them.

Beat 13 · Owned Routing, Web Stack, Desktop & Dev Loop Adapts v2 "Full stack / React Navigation 8 / Deploy anywhere"

Owned routing, full-stack web, desktop, accessibility, and device dev loop.

One v3 drops @react-navigation/* completely. File-system routes, typed <Link>, <Stack>, <Tabs>, <Protected>, intercepting routes, route masks, and scroll groups now compile to One's own lightweight controller contract driving UIKit, Compose, DOM history, and the runtime core directly.

Everything from One v2's web stack carries over on Bun: per-route SSG, SSR, SPA, and API modes, typed loaders, cursor-intent link prefetching, ?imagedata blur placeholders, automatic critical CSS inlining, skew protection so deploys never break open tabs, shared native asset catalogs across native builds and browser previews, and single-line deployment to Node, Bun, Vercel, or Cloudflare Workers.

Native Desktop & Android

AppKit + SwiftUI on macOS (reflowing live at display refresh rate while you resize windows alongside WGSL shaders), WinUI Composition on Windows, and GTK on Linux without building React Native's C++, Folly, or Boost. Experimental Android Views + Compose host ships with native stacks and hardware back.

Accessibility & Device Dev Loop

Full UIAccessibility tree driven from the core: VoiceOver order, custom actions, magic tap, Dynamic Type up to 3.57x, Bold Text, Reduce Motion, Increase Contrast, Smart Invert, AutoFill, and dictation. Plus Fast Refresh over WebSocket on physical phones, breakpoints, element inspector, and source-mapped crash stacks even inside AoT binaries.

Beat 14 · 1:56–2:30 Finale Roll

And a whole lot more.

Every piece from One v2's checklist carries forward, paired with everything added in v3.

Custom AoT Engine & Core

Tiny C ABI (peach_core.h)
Typed bun compile AoT
Bun JSC in dev & release
Sync app-thread React
Compositor render thread
'use background' compiler split
Flat CALayer leaves
Bounded view recycling
Viewport culling
Zero shadow tree mirrors

Native Languages & Polyglot

File-decided .swift / .tsx roots
Zero-JS pure Swift apps
Pure Kotlin / Compose screens
Direct .swift & .kt imports
Reverse-Nitro callbacks
Native C++ Zero + SQLite
Swift @Observable bindings
C, Zig & Rust C ABI links
100% SwiftUI & Compose
56+ One.* Nitro APIs

Web-Aligned API & CSS

Plain div & span defaults
CSS2 block & inline flow
CSS Grid & Subgrid
Yoga flex (-O3, exact)
fixed & sticky position
var() & nested themes
light-dark() & color-scheme
Inline if(), @media, @container
Tailwind v4 utility classes
Gradients, filters, masks, RTL

One UI & Compatibility

Optional react-native layer
FlatList / FlashList / Reanimated
Adaptive Dialog & Sheet
Menu & ContextMenu previews
Select, Popover, AlertDialog
Switch, Slider, DateField
Field, Form, Toast, Tabs
Standalone UI primitives
Real OS controllers only
Existing Nitro modules kept

Startup, Lists & Toolchain

Zero Vite, zero Metro
Zero Hermes everywhere
__TEXT,__one_startup frame
Live React hydration
1M-row sum-tree lists
Native streaming markdown
12-lang fenced highlighting
Fast Refresh on device
Signed OTA + AoT fallback
Auto crash rollback

Gestures, Values & Graphics

Hit-test once at down
Nested delta handoff
Multi-touch joins
UIKit & Android peer bridge
value() / derive() / useValue()
Zero-commit bindings
Unified Kernel IR
webgpu.h on Dawn
WGSL & TypeGPU once
Filament & Three.js layers

Routing, Web & App Shell

Zero React Navigation
Owned stack & tab controllers
SSG, SSR, SPA, API per route
Pure web platform default
Zero Wasm on websites (~19 KB)
Opt-in Light WebGPU Wasm (~105 KB)
No Xcode or CocoaPods
Sub-second shell repack
Shared Assets.car catalogs
Widgets & App Intents

Platforms, Accessibility & Dev

iOS production host
macOS AppKit live resize
Windows WinUI & Linux GTK
Android Compose (experimental)
VoiceOver & Dynamic Type
Voice & Switch Control
Source-mapped AoT crashes
Device DevTools & inspector
Pure web + native parity
Node, Vercel & CF deploy
Beat 15 · 2:31–2:36 Outro

One v3

npx one
onestack.dev
Video Adaptation Notes · v2 → v3

How this maps onto the One v2 launch film format

one-v2.mp4 is 157 seconds at 60 fps: yellow opener → 54s dark act → 58s yellow act → 35s rapid two-column checklist → 5s 1-ball outro. Here is the clean visual shot list to adapt it for v3:

  • 0:00-0:02 (Yellow Opener): 1-ball drops in → "One v3. A custom ahead-of-time engine. The fastest way to ship React, plain web HTML and CSS, and fully native Swift and Kotlin apps."
  • 0:02-0:55 (Dark Act · Engine, Native & Model): Open with Bun AoT + C++ core driving real OS views directly, cut straight into _layout.swift and feed.kt running purely native alongside React, then show web-aligned <div>, CSS Grid, Tailwind, and light-dark() plus the lighter opt-in react-native layer, strike through Fabric, Hermes, Metro, Vite, CocoaPods, and React Navigation, and finish the act with phone demos (instant 187 ms cold start beating Exact, Bun AoT ~8x faster than Hermes, 1M-row fling, streaming markdown AI chat, and 1,000/s value() table at 0 React renders).
  • 0:55-1:55 (Yellow Act · Bun, Web & Scale): Bun + prebuilt shell repack bar chart (seconds vs 32 min), zero-Wasm web platform default (~19 KB JS, plus optional ~105 KB Light WebGPU Wasm when needed), one-gesture nested sheet/scroll/pager demo, Mac window resize with live WGSL shader and 3D, and owned routing + full-stack deploy.
  • 1:55-2:30 (Rapid Checklist + 1-Ball Outro): The 8 two-column inventory cards above flashing on the beat, snapping back to the 1-ball, npx one, and onestack.dev.