इस पेज का अनुवाद मशीन द्वारा किया गया है और इसमें त्रुटियाँ हो सकती हैं। मूल अंग्रेज़ी पढ़ें
एक बार बनाएँ, हर जगह नेटिव
आपका ऐप बीच में है। उसके चारों ओर बना हर आर्क एक प्लेटफ़ॉर्म है।
सिर्फ़ TSX लिखें और ऐसे नेटिव क्लाइंट शिप करें जो Rust की रफ़्तार से चलते हैं। एक ही कोडबेस 8 प्लेटफ़ॉर्म पर चलता है, और हर जगह सिस्टम का अपना UI और इंटरैक्शन मिलता है।
NSH में केवल आपके ऐप का कोड JS है। रिएक्टिव ग्राफ़, रेंडरर, लेआउट और हर मॉड्यूल Rust में हैं। TSX और Rust ऐप एक ही नेटिव एक्ज़ीक्यूशन पाइपलाइन साझा करते हैं।
| TSX | Rust | सिस्टम की बेयर विंडो | |
|---|---|---|---|
| मेमोरी फ़ुटप्रिंट, macOS | ~20 MB | ~19 MB | ~17 MB |
| प्राइवेट डर्टी मेमोरी, Linux (GTK, GL) | ~48 MB | ~44 MB | ~38 MB |
| सिस्टम विंडो से ऊपर, macOS / Linux | +3 / +9 MB | +2 / +5 MB | |
| प्राइवेट वर्किंग सेट, Windows | ~15 MB | ~14 MB |
| TSX एक्ज़ीक्यूटेबल | TSX पैकेज | Rust एक्ज़ीक्यूटेबल | Rust पैकेज | |
|---|---|---|---|---|
| macOS (Apple silicon) | 19.8 MB | 9.5 MB | 12.4 MB | 6.0 MB |
| Linux (x86_64) | 25.7 MB | 11.6 MB | 16.5 MB | 7.5 MB |
| Windows (x86_64) | 28.6 MB | 12.4 MB | 15.0 MB | 6.7 MB |
| Web | — | ~1.1 MB डाउनलोड | — | — |
रिलीज़ बिल्ड। निष्क्रिय अवस्था में मेमोरी: Apple M3 पर macOS फ़ुटप्रिंट (काउंटर ऐप और Rust टेम्पलेट 1200 × 800 पर; सिस्टम विंडो में एक लेबल, 480 × 640 पर); NVIDIA RTX 3060 Ti पर Linux प्राइवेट डर्टी मेमोरी (nsh init के TSX और Rust टेम्पलेट और एक लेबल वाली GTK विंडो, सभी 480 × 640 पर); Windows प्राइवेट वर्किंग सेट। हर प्लेटफ़ॉर्म का माप, RSS और USS के साथ, रिपोर्ट में है। आकार: nsh package के रिलीज़ बिल्ड, लिंक-टाइम ऑप्टिमाइज़ेशन और stripped के साथ; TSX एक्ज़ीक्यूटेबल में QuickJS runtime शामिल है, ऐप का कोड 1 KB से कम है; पैकेज macOS पर zip किया हुआ .app, Linux पर .tar.gz और Windows पर .zip है; वेब पर वह जो ब्राउज़र डाउनलोड करता है, यानी runtime और ऐप। पूरी परफ़ॉर्मेंस रिपोर्ट
एक ऐप बस नीचे दी गई फ़ाइलें है। nsh कमांड लाइन अपना बंडलर और टूलचेन साथ लाती है, और आप जो मॉड्यूल इम्पोर्ट करते हैं वे नेटिव हैं।
$ nsh init my-app --template ts
$ nsh run my-app --target macos
my-app/
App.tsx
nsh.json
tsconfig.jsonimport { mount, signal, Text, View } from "nsh";
function App() {
const count = signal(0);
return (
<View class="items-center gap-4">
<Text>Count: {count()}</Text>
<View
class="rounded-lg bg-blue-600 px-5 py-3"
onPress={() => count.update((n) => n + 1)}
>
<Text class="text-white">Tap</Text>
</View>
</View>
);
}
mount(App);NSH हर UI को वही चीज़ें जोड़कर बनाता है जो उसके प्लेटफ़ॉर्म में पहले से मौजूद हैं। टेक्स्ट इनपुट, सेलेक्शन, इनपुट मेथड और एक्सेसिबिलिटी सिस्टम से आते हैं, और OS के नए रिलीज़ में इनके लिए जो कुछ आता है वह ऐप तक भी पहुँचता है।
| प्लेटफ़ॉर्म | Views | टेक्स्ट | टेक्स्ट इनपुट | आवश्यकता |
|---|---|---|---|---|
| macOS | AppKit | CoreText | NSTextView | macOS 14+ |
| Linux | GTK 4 | Pango | GtkTextView | GTK 4.14+ |
| Windows | Win32, Direct2D | DirectWrite | NSH का एडिटर, IMM32 | Windows 10 1809+ |
| Web | HTML, CSS | ब्राउज़र का | <input>, <textarea> | आधुनिक ब्राउज़र |
| iOS | UIKit | CoreText | UITextView | iOS 15+ |
| Android | Android views | StaticLayout | EditText | API 28+ |
| TUI | ratatui | टर्मिनल का फ़ॉन्ट | Readline कीज़, इनपुट मेथड | macOS, Windows, Linux |
| GPUI | GPUI | GPUI का टेक्स्ट सिस्टम | NSH का एडिटर | GPUI Kit ऐप्स में एम्बेडेड |
मैप, वेब व्यू, वीडियो और होस्ट द्वारा रजिस्टर किया गया कोई भी नेटिव व्यू उसी हायरार्की में एक और सबव्यू है: वे बाकी ऐप के साथ लेआउट होते हैं, क्लिप होते हैं, स्क्रॉल होते हैं और टच लेते हैं। हर प्लेटफ़ॉर्म का बैकएंड
वही कंपाइल किया हुआ कोड यहाँ दो बार चलता है, और केवल डिवाइस बदलता है। पॉइंटर के साथ यह एक विंडो है जिसमें बातचीतें किनारे पर हैं; फ़ोन पर बटन और कंपोज़र Liquid Glass में तैरते हैं और थ्रेड उनके नीचे स्क्रॉल होता है; टर्मिनल में यह कैरेक्टर ग्रिड पर बैठता है। ऐप सिर्फ़ एक बार लिखा गया है।
+ New chat │ What makes an NSH app native? Today │ A signal holds the count; only the Text that reads it updates │ What makes an NSH… │ when you press. ┃ Plot a week of NSH │ import { mount, signal, Text, View } from "nsh"; ┃ Signed packages,… │ ┃ A sheet with two… │ const count = signal(0); ┃ Taffy grid vs flex │ mount(() => ( ┃ │ <View onPress={() => count.set(count() + 1)}> ┃ │ <Text>{count()}</Text> ┃ │ </View> ┃ │ )); ┃ │ What makes an NSH app native? ┃ │ Every element is the platform's own view: UIKit on iOS, Android ┃ │ views, AppKit on macOS and GTK 4 on Linux. Your TSX describes ┃ │ them; layout, text and the reactive graph run in Rust. ┃ │ And the glass around this chat? ┃ │ It's Liquid Glass, one glassEffect style. iOS 26 and macOS 26 ┃ │ draw the system's material; elsewhere it blurs what scrolls ┃ │ beneath. ┃ │ • The buttons and the composer float over the thread ┃ │ • Messages pass under them as you scroll ┃ │ • The same code at every idiom ┃ │ ╭───────────────────────────────────────────────────────────────╮ │ │ › Ask anything │ │ ╰───────────────────────────────────────────────────────────────╯
डेस्कटॉप और फ़ोन आपके ब्राउज़र में Native Shell के वेब runtime पर लाइव चलते हैं। टर्मिनल nsh run --target tui का असली आउटपुट है।
Rust पूरे ऐप के लिए एक फ़र्स्ट-क्लास भाषा है: UI, लॉजिक और कंपोनेंट नेटिव कोड में कंपाइल होते हैं, जो भारी बिज़नेस लॉजिक के लिए तैयार हैं। दोनों एक ही एलिमेंट और सिग्नल इस्तेमाल करते हैं, और TSX स्क्रीन आपके Rust कंपोनेंट इम्पोर्ट करती हैं।
use nsh_core::element::prelude::*;
#[component]
pub fn App() -> impl IntoElement {
let count = signal(0);
view()
.items_center()
.gap_4()
.child(text(move || format!("Count: {}", count.get())))
.child(
view()
.rounded_lg().bg(rgb(0x2563eb)).px_5().py_3()
.on_press(move || count.update(|n| *n += 1))
.child(text("Tap").text_color(white())),
)
}हर एलिमेंट एक ऐसा व्यू है जिसे प्लेटफ़ॉर्म संभालकर रखता है। किसी बदलाव पर सिर्फ़ वे एक्सप्रेशन चलते हैं जो बदले हुए सिग्नल को पढ़ते हैं, हर फ़्रेम में एक बैच में। मुख्य थ्रेड कभी JS का इंतज़ार नहीं करता और नेटिव एनिमेशन उसके बिना चलते हैं, इसलिए स्क्रॉलिंग और एनिमेशन 120 FPS पर टिके रहते हैं और ऐप निष्क्रिय अवस्था में लगभग idle रहता है।
सिग्नल पढ़ने वाले दो टेक्स्ट बदलते हैं और हिस्ट्री में एक पंक्ति जुड़ती है; कोई और व्यू नहीं छुआ जाता।
$ nsh test examples/counter/App.tsx --trace
perf commit: 56 ops, 50 mount items, 21 nodes
press(+1)
perf commit: 10 ops, 7 mount items, 24 nodesआपकी टीम इसे लिख सकती है, या कोई मॉडल हर अनुरोध के लिए इसे जनरेट कर सकता है। यह डिवाइस तक एक साइन किए हुए मॉड्यूल के रूप में पहुँचता है, होस्ट द्वारा तय किए गए सैंडबॉक्स में चलता है, और नेटिव रूप में दिखता है।
आपकी टीम या कोई मॉडल एक TSX मॉड्यूल लिखता है।
App.tsxइसे टाइप-चेक करें, फिर इसके टेस्ट headless चलाएँ।
nsh check
nsh testEd25519 से साइन किया गया .nshpkg, जिसकी रिलीज़ की को ऑफ़लाइन रूट प्रमाणित करता है।
nsh publishडिवाइस सिग्नेचर, सर्टिफ़िकेट और रिवोकेशन की पुष्टि करता है। हर व्यू को मेमोरी, कॉल-टाइम और नोड की सीमाओं वाला एक VM मिलता है, और सिर्फ़ वही क्षमताएँ मिलती हैं जो होस्ट देता है।
NshAppView
NshView
AppViewइसे Rust, TSX या दोनों में लिखें, और इंस्टॉल होने वाला iOS, Android, macOS, Windows या Linux ऐप, या एक स्टैटिक वेबसाइट पैकेज करें।
$ nsh init my-app --template rust
$ nsh run my-app --target macos
$ nsh package my-app --target windows
# --template ts for TSX
# ios · android · macos · windows · linux · gpui · webकिसी भी स्क्रीन पर एक व्यू एम्बेड करें और रन टाइम पर उसमें साइन किए हुए TSX मॉड्यूल लोड करें, होस्ट के अपने नेटिव कंपोनेंट के बगल में।
let app = NshAppView()
try app.grantCapabilities(grants)
let info = try await app
.loadPackage(at: file, trust: trust)
// verified, sandboxed, running
// NshView on Android, AppView elsewhereएक मॉडल हर अनुरोध के लिए एक मॉड्यूल लिखता है, ताकि ऐप जवाब में एक इंटरफ़ेस दे। आपका सर्वर उसे जाँचता और साइन करता है।
import { mount, signal, View } from "nsh";
function Answer() {
const range = signal("1W");
return <View class="gap-3 p-4">…</View>;
}
mount(Answer);nsh/base में बिना स्टाइल वाले बेस कंपोनेंट हैं जो स्टेट, फ़ोकस, कीबोर्ड और एक्सेसिबिलिटी संभालते हैं, और ऐप हर हिस्से को स्टाइल करता है। बाकी सब कुछ एक nsh कमांड लाइन करती है।
नेविगेशन, डायलॉग, मेन्यू, पॉपओवर, टैब, सेलेक्ट, डेटा टेबल, एक कोड एडिटर और एक रिच टेक्स्ट कर्नेल। हर हिस्से को Tailwind क्लास या टाइप्ड स्टाइल से स्टाइल करें।
nsh/baseएक nsh एक्ज़ीक्यूटेबल बनाता, बिल्ड करता, टाइप-चेक करता, हॉट-रीलोड करता, टेस्ट करता, पैकेज करता और साइन करता है। डिक्लेरेशन Rust सोर्स से जनरेट होते हैं और डॉक्स llms.txt के रूप में उपलब्ध हैं, इसलिए एक एजेंट उन्हीं कमांड से पूरा लूप चला सकता है।
nsh run, nsh test, nsh packageवही टेस्ट headless चलते हैं, और असली विंडो, iOS सिम्युलेटर, Android डिवाइस या ब्राउज़र में भी, प्लेटफ़ॉर्म के अपने इनपुट के साथ।
nsh test --target iosnsh इंस्टॉल करें और एक मिनट में अपना पहला TSX ऐप चलाएँ।