longbridge/nsh

AI-generated UI, native in your app. Native Shell renders UI written in TSX and Tailwind with each platform's own UI: native views on iOS, Android, macOS, Windows and Linux, GPUI in GPUI apps and HTML on the web. Apps load these modules at run time, as plugins: written by a model or by your team, delivered as signed packages and run in a sandbox the host configures. The same module can also be a standalone app.

import { mount, signal, Text, View } from "nsh";

function App() {
  const count = signal(0);
  return (
    <View class="flex-1 items-center justify-center gap-4 bg-white dark:bg-zinc-900">
      <Text class="text-3xl font-semibold text-zinc-900 dark:text-white">{count()}</Text>
      <View class="rounded-xl bg-blue-600 px-5 py-3 active:opacity-60" onPress={() => count.update((c) => c + 1)}>
        <Text class="text-white">Tap</Text>
      </View>
    </View>
  );
}

mount(App);

Documentation, guides and live demos: nsh.dev.

• Real native UI. Every element is a platform view (UIKit, Android views, AppKit, Win32 drawn with Direct2D, GTK 4), a GPUI element or HTML, laid out with flexbox and grid (Taffy). The system's text, input, scrolling and accessibility just work, and native components such as maps and web views layer naturally with NSH's views.
• Plugins, or standalone apps. Put an NshAppView (iOS), NshView (Android) or AppView (desktop and GPUI) on any screen of an existing app, or createPlayer in a web page, and load modules into it at run time, from a bundle, the dev server or a downloaded signed package: features ship on your own schedule, next to the host's own native components. The same module also packages into an installable iOS, Android, macOS, Windows, Linux or GPUI app, or a static website, with one nsh package command.
• AI-friendly: TSX + Tailwind. A module is one TSX file of components, signals and Tailwind classes, the format models write best. Every element, prop and module has TypeScript declarations generated from the Rust sources, the docs are served to models as llms.txt, and nsh trace runs a module headless to check it without a device.
• Sandboxed and signed. Each view runs its module in its own QuickJS VM, with memory, call-time and node limits, reaching only the capabilities the host grants. Packages are signed with Ed25519 by release keys an offline root certifies, and the device checks a revocation list.
• Fast, all in Rust. Only the app's code is JavaScript: signals, the renderer, layout, animation and every module apps import are Rust, and each frame crosses to the UI thread as one batch. The single nsh binary bundles, type-checks, serves hot reload and packages: it is the whole toolchain module authors need.

The GPUI backend (nsh run --target gpui, nsh package --target gpui) draws apps with GPUI on all three desktops and embeds in GPUI and GPUI Kit apps. The web platform (nsh run --target web, nsh package --target web) publishes apps as static sites and runs the website's live demos.

Install the nsh command (other ways):

curl -fsSL https://nsh.dev/install.sh | sh     # macOS, Linux
irm https://nsh.dev/install.ps1 | iex          # Windows (PowerShell)
brew install longbridge/tap/nsh                         # Homebrew

Create an app and run it with hot reload:

nsh init my-app
nsh run my-app                     # a window on this machine (on macOS, an iPhone-sized Mac Catalyst window)
nsh run my-app --target ios        # iOS simulator (needs Xcode)
nsh run my-app --target android    # Android emulator or device (needs the Android SDK)
nsh run my-app --target macos      # an AppKit window
nsh run my-app --target gpui       # a GPUI window (macOS, Windows, Linux)
nsh run my-app --target web        # in the browser

nsh init writes App.tsx, nsh.json and a tsconfig.json, and keeps type declarations in .nsh/types, so any TypeScript editor checks the app on its own. On every save only the edited components render again; the rest of the app keeps its state. Logs and errors show in the terminal. What each platform needs: Installation.

iOS (Swift):

import NativeShell

let app = NshAppView()
view.addSubview(app)                      // constrain it like any view
#if DEBUG
try app.connectDevServer(URL(string: "ws://127.0.0.1:8790/ws")!)   // `nsh dev my-app`
#else
try app.loadBundle(at: Bundle.main.url(forResource: "bundle", withExtension: "qbc", subdirectory: "nsh")!)
#endif

Android (Kotlin):

val nsh = NshView(this)
setContentView(nsh)                       // or add it to any layout
if (BuildConfig.DEBUG) nsh.connectDevServer("ws://127.0.0.1:8790/ws") else nsh.loadAssetBundle("nsh")

nsh build my-app --release writes the bundle a release build loads. More: iOS, Android, desktops, native components, sandbox and capabilities.

nsh keygen keys/root && nsh keygen keys/release        # a root key kept offline, and a release key
nsh certify --root keys/root.secret --key keys/release.pub --apps 'com.example.*' -o keys/release.cert
nsh publish my-app --key keys/release.secret --cert keys/release.cert --build 2   # a signed .nshpkg

The app trusts the root's public key and loads what it downloads with loadPackage (Signed packages). To ship the module as an app of its own instead:

nsh package my-app --target ios-simulator --run        # also ios, android, macos, windows, linux, gpui, web

nsh run examples/gallery

With Rust (rustup; rust-toolchain.toml picks the toolchain):

git clone https://github.com/longbridge/nsh.git && cd nsh
cargo run                              # the gallery on this machine's backend, with hot reload
cargo run -- examples/counter          # another app
cargo run -- --target ios              # or catalyst, android
cargo xtask dist                       # the distribution (CLI, runtimes, SDKs) in dist/nsh

Installation lists the hosts and runtimes each target needs.

CONTRIBUTING.md covers pull requests, commits and testing; AGENTS.md the commands, rules and conventions; docs/dev the architecture and internals. The website's sources are in website/.

GPUI Kit is a sibling project: components and tools for desktop apps built with GPUI. NSH's theme colors follow its fields, and NSH's GPUI backend builds on it.

Licensed under the Apache License, Version 2.0.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this project by you, as defined in the Apache-2.0 license, shall be licensed under Apache-2.0, without any additional terms or conditions.