write once, compile native
Nativ is a compiler, not a framework. One .nativ source becomes a real Xcode project and a real Gradle project — standalone SwiftUI and Jetpack Compose you own. No runtime. No bridge. No webview.
app Counter:
screen Home:
state count = 0
text "You tapped {count}×", big, bold
button "Tap me":
count += 1$ nativ build ✓ parsed 1 screen · 0 errors → ios/ SwiftUI · Xcode project → android/ Compose · Gradle project done in 0.18s
// Cargo package is public now · Homebrew and curl installers pending packaging
{{ installCmd }}
see it compile
Describe the app once. Nativ emits idiomatic SwiftUI and idiomatic Jetpack Compose — not one cross-platform skin, but two apps that each feel native to their platform.
model Tx:
merchant: text
amount: money
category: Category
screen Wallet:
state balance = 4820.50
state txns = Tx.recent()
text "Total balance", gray
text "{balance}", big, bold
row:
action "Add", action "Send", action "Request"
text "Recent activity", bold
each tx in txns:
TxRow(tx)
on tap: go to TxDetail(tx)Text(balance, format: .currency(code: "USD"))
.font(.largeTitle.bold())
ForEach(appState.txns) { tx in
TxRowView(tx: tx)
.onTapGesture { router.path.append(tx) }
}
Button { add() } label: {
Label("Add", systemImage: "plus")
}
.buttonStyle(.borderedProminent)Text(
text = formatCurrency(balance),
style = MaterialTheme.typography.headlineLarge
)
appState.txns.forEach { tx ->
TxRow(tx = tx, onClick = {
navController.navigate("tx/${tx.id}")
})
}
FilledTonalButton(onClick = ::add) {
Icon(Icons.Default.Add, null)
Text("Add")
}One source, two native apps — fully interactive. Tap actions, menus, transactions, and detail buttons.
why now
A new wave of tools generates mobile apps from a prompt. Almost all of them ship a webview, a cross-platform runtime, or a fragile interpreter you don't control. The intent is real — but the output is rented.
Nativ compiles that same intent into native source code you own, edit, and ship under your own name. As AI raises the supply of generated apps, the value moves to whoever owns real, native output. That's the layer Nativ builds.
why it matters
Every cross-platform tool taxes you somewhere. Nativ's answer is to disappear at build time.
Generated code has zero Nativ dependency. Delete the compiler and your app still builds — it's just SwiftUI and Compose.
No JS bridge, no serialization layer between UI and logic. Native views call native APIs directly, at full speed.
Nativ emits the platform's own toolkits — SwiftUI and Compose — not a reimplementation that drifts from the OS.
0 KB of Nativ ships in your binary. We can't meter it, deprecate it, or revoke it. The apps you build are yours.
how it compiles
Source parses to a typed intermediate representation, then lowers to two native backends. The same IR guarantees the iOS and Android apps stay in lockstep.
Written in Rust · golden-tested codegen · diagnostics source-mapped back to your .nativ line.
why this is a platform
The hard part of cross-platform isn't the editor — it's a correct compiler. That's the moat, and it compounds.
Native iOS and Android are the default surface for consumer and most B2B products. The market isn't a niche — it's the floor.
Teams maintain Swift and Kotlin in parallel — double the surface, double the bugs, permanent platform drift. One source removes the drift by construction.
As generation gets cheap, the scarce thing becomes real native output. A compiler that LLMs can target is the natural backend for AI app-building.
Correct lowering to two idiomatic backends is deep compiler engineering. It can't be cloned in a weekend, and every fixed edge case widens the lead.
Generated native code is something teams can keep, audit, and sell. That ownership is the wedge no runtime-based competitor can copy.
built like infrastructure
Nativ is built like a compiler, not a content generator — deterministic, tested, and transparent about every line it emits.
$ nativ check src/app.nativ app.nativ:8:3 error: unknown state `titel` 8 | button "Add", bind: titel | ^^^^^ did you mean `title`? ✓ mapped to source — not generated code
.nativ line — never at code you didn't write.nativ build and nativ preview, plus editor completion and diagnostics over LSP.where this goes
The compiler is the foundation. On top of it sits a path from idea to a shipped, owned native app — for engineers today and vibe-coders next.
Describe an app in plain language; get owned native code out — no platform expertise required.
Share a live build link of your screens before a single local toolchain is installed.
Compile to .ipa and .aab in CI — no local Xcode or Android Studio.
One pipeline from .nativ source to submitted builds on both stores.
LLMs target .nativ and get real SwiftUI and Compose out — Nativ as the native backend for AI.
honest status
We'd rather show you a real compiler that does a little than a demo that fakes a lot. Here's exactly where it stands.
.nativ compiles to SwiftUI + Compose sourcenativ build
One source. Two native platforms. Zero runtime between you and the apps you ship. Try the compiler and read the code it writes.