nsh README

The project's README from github.com/longbridge/nsh. As one markdown file: README.md.

Native Shell (NSH)

Native UI in Rust and TSX, embedded in your app or shipped on its own. Native Shell is a Rust engine for cross-platform apps and AI-generated UI. Write your app in Rust, use TSX for dynamically delivered screens, or combine both with shared Rust components. Each platform renders with its own UI: native views on iOS, Android, macOS, Windows and Linux, GPUI in GPUI apps and HTML on the web.

Embed NSH in an existing app or package it as a standalone app. Hosts can load TSX modules at run time as plugins, delivered as signed packages and run in a sandbox the host configures.

Documentation, guides and live demos: nsh.dev.

Features

Platforms

Platform Drawn with Embed with Requires
iOS UIKit, CoreText NshAppView (Swift, NativeShell.xcframework) iOS 15+
Android Android views, StaticLayout NshView (Java / Kotlin, nsh.aar) Android 9 (API 28)+
macOS AppKit, Core Animation, CoreText AppView (Rust, nsh-platform-macos) macOS 14+
Windows Win32, Direct2D, DirectWrite AppView (Rust, nsh-platform-windows) Windows 10 1809+
Linux GTK 4, Pango AppView (Rust, nsh-platform-linux) GTK 4.14+
GPUI (macOS, Windows, Linux) GPUI (GPUI Fast) AppView (Rust, a GPUI view, nsh-platform-gpui) macOS, Windows; Linux with Vulkan
Web HTML, CSS createPlayer (JavaScript) or an iframe Modern browsers

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.

Quick start

Install the nsh command (other ways):

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

Choose how to write your app:

Rust TSX
Create nsh init my-app --template rust nsh init my-app --template ts
Write Rust components, typed styles and signals TSX components, Tailwind classes and signals
Iterate Rebuild and restart on Rust changes Hot updates that preserve state
Toolchain nsh and Rust nsh

You can also combine them (nsh init my-app --template mixed): TSX screens import your Rust components and modules. See Building with Rust for Rust apps and mixed projects.

Run either app on your chosen platform:

iOS 
nsh run my-app --target ios        # iOS simulator; requires Xcode
nsh run my-app --target catalyst   # Mac Catalyst window on macOS
Android 
nsh run my-app --target android    # emulator or device; requires the Android SDK
macOS 
nsh run my-app --target macos      # AppKit window
Windows 
nsh run my-app --target windows    # Win32 window
Linux 
nsh run my-app --target linux      # GTK 4 window
GPUI (macOS, Windows, Linux) 
nsh run my-app --target gpui
Web 
nsh run my-app --target web        # open in the browser

The Rust template includes a Cargo project with its root component in src/lib.rs. The TSX template includes App.tsx, nsh.json and tsconfig.json, with generated TypeScript declarations in .nsh/types for your editor. Logs and errors show in the terminal. What each platform needs: Installation.

Examples

Example What it shows
examples/gallery A tour of what NSH supports: lists, navigation, forms, controls, gestures, animation, images, styles, text, web view and video, fetch
examples/counter The smallest app
examples/hopper A dark, tabbed dashboard built only from primitives: interactive canvas charts, sliders, menus, animation
examples/desktop A desktop app with a title bar and menus of its own (nsh/desktop)
examples/gallery-rs The gallery written in Rust: an app with no TSX and no QuickJS
examples/rust-exports A TSX app using a component, a module and a class of its own Rust crate
examples/embed-ios, examples/embed-android NSH inside existing native apps, with a native component the app registers
examples/bench Rust components against the same components in TSX 
cargo run

License

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.

nsh (longbridge/nsh)

Searching Database…

402 ·GitHub
Nsh
What is this?NSH is a Rust engine for building cross-platform apps where screens are written in TSX (or Rust), and each platform renders them with its own native UI: UIKit on iOS, Android views on Android, AppKit on macOS, Win32/Direct2D on Windows, GTK 4 on Linux, GPUI on desktops, or HTML on the web.
Is this a framework I build my whole app with, or something I just embed?It works both ways: you can build a standalone app entirely with NSH, or embed NSH inside an existing native app alongside things like maps and web views.
How do I get started with it?Install the 'nsh' CLI via Homebrew on macOS/Linux or the PowerShell installer on Windows, then run 'nsh init my-app --template ts' (or '--template rust' / '--template mixed'), and 'nsh run --target ' to launch it.
What OS versions does each platform need?iOS 15+, Android 9 (API 28)+, macOS 14+, Windows 10 1809+, and GTK 4.14+ on Linux; the GPUI backend additionally needs Vulkan on Linux.
If TSX screens can be delivered at runtime, is that a security risk?Dynamically delivered TSX modules must be signed packages and they run inside a sandbox whose capabilities the host app configures, so hosts control what loaded screens are allowed to do.
Do I write my app in Rust or in TSX?Either, or both: Rust gives typed components and signals with rebuild-on-change, TSX gives Tailwind-styled components with hot updates that preserve state, and a 'mixed' template lets TSX screens import your Rust components.
What does the GPUI backend give me over plain native views?The GPUI backend renders the same app with GPUI on all three desktop OSes instead of each system's native toolkit, and it can embed directly inside other GPUI or GPUI Kit apps.
Can AI tools generate NSH screens?Yes — NSH generates TypeScript declarations and model-readable documentation specifically so AI-generated TSX and Tailwind screens can be produced and run natively on each platform.
What do the example apps cover?They range from a minimal 'counter' app to a full widget 'gallery', a Rust-only version of that gallery with no TSX/QuickJS, native-embedding demos for iOS and Android, and a benchmark comparing Rust components against the same components in TSX.
What are similar projects?react-native, perry, ng-native, expo, PakePlus, native, lynx, uni-app
Which topics is it in?generative-ui, jsx, native, mobile-app, sdk, mobile, ui, ios, rust, android, framework, gui
Creator
longbridge
Size
10.1 MB
Stars
402
Updated
CommitOct 20Releasev0.1.1Oct 18
Age
5d
Commits · 90 Days