Built for the web. Aligned to HTML and CSS. Powered natively by one C++ core and Bun.
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.
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.
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> ) }
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.
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.
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.
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.
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. |
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.
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 removes the legacy runtime and bundler stack underneath.
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.
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 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.
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.
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.
~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 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.
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
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
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.
div & span defaults-O3, exact)fixed & sticky positionvar() & nested themeslight-dark() & color-schemeif(), @media, @containerpeach_core.h)react-native layer'use background' compiler splitCALayer leavesOne.* Nitro APIsDialog & SheetMenu & ContextMenu previewsSelect, Popover, AlertDialogSwitch, Slider, DateFieldField, Form, Toast, Tabsbun compile AoTCompilerPlugin APIvalue() / derive() / useValue()webgpu.h on Dawn__TEXT,__one_startup frame.swift / .tsx roots@Observable bindingsAssets.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:
<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._layout.swift beside chat.tsx.npx one, and onestack.dev.