One v3
Video Beat 01 · 0:00 Opener

One v3

Built for the web. Aligned to HTML and CSS. Powered natively by one C++ core and Bun.

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

One v3 starts from a simple rule: build for the web first. On the web, your app uses plain HTML elements, ordinary CSS, and the browser's own platform with zero heavy Wasm runtime. On iOS, Android, and desktop, One brings that exact web-aligned model to real native OS controls through a small C++ core and Bun.

Everything you relied on in One v2 stays (typed file routes, loaders, SSR/SSG/SPA modes, One.* native APIs, and direct Swift and Kotlin imports), while React Native's Fabric, Metro, Vite, Hermes, CocoaPods, and React Navigation step out of the way.

How to read this draft: The sections follow the visual acts and beat pacing of the One v2 launch video (Yellow opener → Dark web-model and core act → Yellow Bun, web platform, and polyglot act → Rapid inventory finale → 1-ball outro), assuming all current v3 work lands.
Beat 02 · Built for the Web Web-aligned API + full CSS coverage

Write plain HTML and CSS. Ship anywhere.

React Native forced web developers into <View>, flex-column defaults, and a small subset of properties, then dragged a translation layer onto the web. One v3 flips that around.

Your default UI API is plain lowercase HTML elements (<div>, <span>, <section>, <button>) with standard CSS properties, <style> sheets, and className. Plain boxes default to display: block and spans flow inline, matching Chrome and Safari. On the web, there is zero translation overhead because the browser just runs your HTML and CSS. On iOS, Android, and desktop, One's C++ CSS and layout engine implements that same broad web surface natively.

Plain web elements, CSS Grid, Tailwind, variables, and light-dark() across web and iOS 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 }}>Built for the web.</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 03 · Lighter by Default, RN When You Need It Optional React Native compatibility layer

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

Writing plain web elements and CSS means you never pay for React Native's heavy react-native-web wrapper on websites or its Fabric shadow tree on mobile. Your default web bundle stays small, uses standard DOM elements, and maps directly to the browser.

When you are bringing over an existing mobile codebase or third-party UI code, One v3 includes an optional react-native compatibility layer right on top of the core. Those compatibility imports stay isolated to the files that import them: View keeps its flex-column default only there, while FlatList, FlashList, LegendList, Animated, Reanimated, GestureHandler, react-native-svg, and react-native-webview run cleanly through thin adapters over the core. Existing Nitro modules also keep working unchanged 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 mounts directly to One's C++ core 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-first pages.

Beat 04 · The Core Swap Replaces v2 "One Native: Do anything native"

The core decides. The OS draws.

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

One v3 deletes Fabric, the shadow tree, and the duplicate mirrors. On devices, React writes atomic transactions directly into one small C++ core (peach_core.h) with generational handles and typed style buffers. On the web, the browser already is the engine, so websites default to plain DOM and CSS with zero Wasm loaded.

Target What runs How pixels reach the screen
Web (Default) Browser DOM & CSS + lightweight JS runtime (~19 KB) Real HTML elements, native browser text, browser scrolling, zero Wasm engine.
Native Devices & Desktop One C++ Core + real OS views and controls Core owns tree, layout, gestures, accessibility, and values, and mounts CALayer/UIView/UIKit on iOS, Views/Compose on Android, AppKit on Mac, WinUI on Windows, GTK on Linux.
Drawn & WebGPU Surfaces (Opt-in) Skia + Dawn via webgpu.h on the shared GPU device (and Light Core Wasm on web) Optional canvases, games, shaders, and 3D scenes composited inside native scroll views and under glass toolbars with zero CPU copies.
Beat 05 · Native UI & 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 core with zero bridge glue.

Navigation and overlays use real platform controllers rather than simulated mobile 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 06 · What Got Deleted Replaces v2 "Before / Now it takes One" pill wipe

Half the stack is gone.

One v2 replaced a hundred third-party packages with built-in APIs. One v3 removes the legacy runtime and bundler stack underneath.

React Native Fabric Hermes & hermesc Metro bundler Vite & Rollup @react-navigation/* react-native-web CocoaPods Xcode project patching Duplicate Yoga mirrors
Plain Web DOM & CSS One C++ Core Bun Toolchain & AoT One Native + One UI Prebuilt App Shells
Beat 07 · Startup & Runtime Speed Beats custom non-React runtimes on real phones

First pixels before JavaScript even starts.

Custom non-React mobile frameworks claim sub-second cold starts by making you give up JSX and React. One v3 beats their startup numbers while keeping React and TypeScript.

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 Bun's JavaScriptCore VM 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 (React)
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 the web, Bun runs dev SSR in-process through Bun.plugin and compiles client and server bundles for Bun, Node, or Cloudflare Workers. 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 with real TypeScript types fed into compilation.

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.

For the web, One v3 focuses on one clean default: just use the web platform. Plain HTML elements, native browser CSS, browser text, and browser scrolling ship with zero C++ or Skia 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 penalizing 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 · Native-First & Polyglot Adapts v2 "Import any Swift or Kotlin file"

Mix TypeScript, Swift, Kotlin, C++, Zig, or Rust by file name.

One v2 let you import .swift and .kt files straight into TypeScript. One v3 goes both ways: routes decide their language by file extension.

Drop settings.swift next to chat.tsx, or make _layout.swift your app root. A Swift root compiles a pure native @main App with a SwiftUI NavigationStack and loads zero JavaScript engine until the user pushes a TypeScript route. Reverse-Nitro bindings let Swift and Kotlin share typed routes, call TypeScript functions, and share one native C++ Zero sync store over SQLite as Swift @Observable models, Compose state, or React hooks.

File extensions pick the root language app/
app/
  _layout.swift        // Pure native SwiftUI root (0 ms JS boot)
  index.swift          // Native home screen
  chat/[id].tsx        // Mounted lazily in OneSurface
  settings.tsx         // TypeScript screen with SSR loader
  api/messages+api.ts  // Server API route
Direct imports + shared native Zero chat/[id].tsx & Swift
import { hello } from './Hello.swift'
import { vibrate } from './Motor.kt'

// Same Zero SQLite store across languages:
const msgs = useZeroQuery(q.messages)
// In Swift: @Observable messages from C++ Zero
Beat 14 · 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 15 · 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.

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

Core, Threading & Compat

Tiny C ABI (peach_core.h)
Optional react-native layer
Sync app-thread React
Compositor render thread
'use background' compiler split
Flat CALayer leaves
Bounded view recycling
Viewport culling
Display link only on motion
Zero shadow tree mirrors

One UI & Native Controls

100% SwiftUI generated
100% Compose generated
56+ One.* Nitro APIs
Adaptive Dialog & Sheet
Menu & ContextMenu previews
Select, Popover, AlertDialog
Switch, Slider, DateField
Field, Form, Toast, Tabs
Standalone UI primitives
Real OS controllers only

Bun Toolchain & AoT

Zero Vite, zero Metro
Zero Hermes everywhere
Bun JSC in dev & release
Typed bun compile AoT
In-process Bun dev SSR
Shared CompilerPlugin API
Built-in React Compiler
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

Startup, Lists & Polyglot

__TEXT,__one_startup frame
Live React hydration
1M-row sum-tree lists
Native streaming markdown
12-lang fenced highlighting
File-decided .swift / .tsx roots
Zero-JS pure Swift apps
Native C++ Zero + SQLite
Swift @Observable bindings
C, Zig & Rust C ABI links

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 16 · 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. Built for the web. Plain HTML and CSS. One C++ core. One Bun toolchain."
  • 0:02-0:55 (Dark Act · Model & Core): Start with plain <div>, CSS Grid, Tailwind, and light-dark() code running across Chrome and iOS, note the lighter optional react-native compat layer, then show React → C++ Core → Real OS Layers, phone demos (Dialog card-to-sheet, instant cold start beating Exact, 1M-row fling, streaming markdown AI chat, 1,000/s value() table at 0 React renders), and strike through Fabric, Hermes, Metro, Vite, CocoaPods, and React Navigation.
  • 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 _layout.swift beside chat.tsx.
  • 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.