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.
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).
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. |
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.
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
import { hello } from './Hello.swift' import { vibrate } from './Motor.kt' // Shared C++ Zero SQLite store: const msgs = useZeroQuery(q.messages) // In Swift: @Observable models
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.
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> ) }
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.
@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.
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.
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.
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.
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.
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.
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>
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.
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.
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.
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.
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.
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>
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.
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.
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.
~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.
~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.
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.
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.
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.
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.
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.
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.
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.
Every piece from One v2's checklist carries forward, paired with everything added in v3.
peach_core.h)bun compile AoT'use background' compiler splitCALayer leaves.swift / .tsx roots.swift & .kt imports@Observable bindingsOne.* Nitro APIsdiv & span defaults-O3, exact)fixed & sticky positionvar() & nested themeslight-dark() & color-schemeif(), @media, @containerreact-native layerFlatList / FlashList / ReanimatedDialog & SheetMenu & ContextMenu previewsSelect, Popover, AlertDialogSwitch, Slider, DateFieldField, Form, Toast, Tabs__TEXT,__one_startup framevalue() / derive() / useValue()webgpu.h on DawnAssets.car catalogs
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:
_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).npx one, and onestack.dev.