platform

Neutron Native

Preact components rendered to real UIKit and Android views via React Native Fabric. Same components run on web, iOS, and Android. Develop through Expo Go, ship to both stores from one build.

Preact on the web. UIKit on the phone. Same code.

Available

3 KBUI Runtime

FabricNative Renderer

Expo GoDev Workflow

2App Stores

No WebView. No bridge tax.

Neutron Native renders Preact components through React Native's Fabric renderer — the same path React Native uses, but with a 3 KB runtime instead of React's 42 KB. You get real UIKit on iOS and real Android views on Android, not a WebView pretending to be an app. Components are the same ones your web build uses, so sharing UI between platforms is just an import.

src/routes/profile/[id].tsx
import { useLoaderData } from "@neutron-build/core";
import { View, Text, Image } from "@neutron-build/native";

export async function loader({ params, ctx }) {
  const user = await ctx.db.sql()
    .query("SELECT id, name, avatar_url FROM users WHERE id = $1", [params.id])
    .one();
  return { user };
}

export default function Profile() {
  const { user } = useLoaderData<typeof loader>();
  return (
    <View class="profile">
      <Image src={user.avatar_url} class="profile__avatar" />
      <Text class="profile__name">{user.name}</Text>
    </View>
  );
}
Same route. Web: DOM. iOS: UIKit. Android: Views.

Fabric renderer

React Native's new architecture renders Preact components to UIKit and Android views. No WebView, no bridge — synchronous native calls.

3 KB UI runtime

Preact instead of React. 14× smaller runtime means less cold-start time, smaller app binaries, and more room for your code.

Expo Go compatible

Use the Expo Go app for dev and preview — no custom native client to maintain. Scan a QR code, see your changes in under 500ms.

Unified file routing

One src/routes/ tree serves web, iOS, and Android. Platform-aware navigation, deep linking, and transitions handled by the framework.

Device modules

Camera, contacts, location, notifications, biometrics, haptics, share sheet. Typed APIs over React Native Turbo Modules.

Animation & gestures

Reanimated-backed worklet animations run on the UI thread. Gesture handler for pan, pinch, long-press, double-tap. Typed accessibility.

Feature	React Native	Neutron Native
UI framework	React (~42 KB runtime)	Preact (~3 KB runtime)
Web code sharing	Separate React Native Web lib	Same components, no adapter
Renderer	Fabric	Fabric
Build tool	Metro	Vite
Dev client	Expo Go or custom	Expo Go
Data layer	BYO (Redux, Zustand, …)	Loaders & actions (same as web)

What it's for

Cross-platform apps sharing the majority of UI code across web and mobile. Apps that ship as a marketing site on day one and an iOS/Android binary on day thirty, from the same codebase. Internal tools that have to work on a desktop browser and a field tech's Android tablet without maintaining two apps.

Why Fabric, not WebView?

Because WebView apps are obvious to users — scroll momentum is wrong, keyboards feel weird, native gestures don't work. Fabric renders to the actual OS controls, so your app feels like the platform. The tradeoff is a larger runtime than pure WebView, which Preact solves by being 3 KB instead of 42.

Part of a bigger system

Web + mobile + desktop from one codebase, all reading the same Nucleus database. Add a Rust service behind them for heavy lifting, Python for ML-backed features, Go for microservices — every platform front-end speaks the same protocol.