Compila TypeScript in codice nativo.
Un solo codice, ogni piattaforma.
Perry compila TypeScript in applicazioni GUI e CLI native su macOS, iPadOS, iOS, Android, Linux, Windows, watchOS, tvOS, HarmonyOS, WebAssembly e il Web. Nessun runtime. Nessun Electron. Solo binari nativi.
$ perry compile main.ts
Compilazione di main.ts...
✓ Eseguibile compilato: main (2,3 MB)
$ ./main
Hello, World!
App reali, compilate da TypeScript con Perry.
Perché Perry?
Tutto ciò che serve per compilare TypeScript in applicazioni native
Nessun runtime necessario
Produce eseguibili nativi autonomi. Nessun Node.js, nessun V8, nessuna dipendenza runtime. Solo un singolo binario che funziona ovunque.
Compilazione veloce
Compilazione diretta da TypeScript a codice nativo usando SWC per il parsing e LLVM per la generazione del codice ottimizzato. Nessun JavaScript intermedio.
Binari compatti
I binari di output sono tipicamente 2-5 MB. Con il runtime V8 opzionale per i pacchetti npm JS, 15-20 MB. Distribuisci meno, fai il deploy più velocemente.
Build deterministiche
Stesso input, stesso binario. Riproducibili su qualsiasi macchina, in qualsiasi esecuzione CI, in qualsiasi team. Niente rebuild misteriosi.
Libreria standard completa
Implementazioni native integrate di fs, path, crypto, os, Buffer, child_process e altro. Usa le API familiari di Node.js.
Veri pacchetti npm
axios, zod, express, fastify e hono compilano in binari nativi. I pacchetti JavaScript puro girano su un runtime embedded opzionale — autonomi, senza node_modules a runtime.
Oltre 35 widget UI nativi
Pulsanti, tabelle, date picker, drag & drop, grafici, mappe, command palette, codici QR, rich text e altro — tutto compilato in veri widget di piattaforma tramite AppKit, UIKit, GTK4, Win32 (Fluent/Mica) e JNI.
Sistema di plugin a tempo di compilazione
I moduli si compongono al momento del build — nessun overhead di plugin a runtime, nessun confine IPC. Le tue dipendenze diventano chiamate di funzione native dirette nel binario finale.
Vero multi-threading
Veri thread del sistema operativo con parallelMap, parallelFilter e spawn. Sicurezza a tempo di compilazione che rifiuta le catture mutabili — nessun SharedArrayBuffer, nessun worker, solo thread.
i18n a tempo di compilazione
Estrazione automatica delle stringhe, regole di plurale CLDR per oltre 30 lingue, validazione a tempo di compilazione. Le traduzioni vengono integrate nel binario con ricerca quasi nulla a runtime.
Approfondisci: come Perry compila TypeScript in un binario, cosa lo rende un compilatore nativo per TypeScript e come si confronta con le alternative a Electron.
Guarda cosa le persone costruiscono
App native reali, compilate da TypeScript. Niente Electron, niente web view — solo UI nativa su ogni piattaforma.
Mango
GUI MongoDB nativa — costruita interamente in TypeScript
Hone
Editor di codice nativo con IA — da TypeScript a binario nativo
Nativo su ogni piattaforma
Perry compila il tuo TypeScript in framework UI nativi, WebAssembly e JavaScript — niente web view, niente Electron. Veri widget nativi su ogni piattaforma, più il web.
macOS
AppKit
iOS
UIKit
iPadOS
UIKit
Android
Views
Linux
GTK4
Windows
Win32
watchOS
SwiftUI
tvOS
SwiftUI
WASM
WebAssembly
Web
JavaScript
Dal codice all’App Store
Perry non solo compila la tua app — la mette nelle mani dei tuoi utenti.
Compila e firma
Build multipiattaforma con un solo comando. La firma del codice per macOS, iOS, Android e Windows viene gestita per te. Niente più lotte con i profili di provisioning Xcode o i keystore Android.
Distribuisci
Pubblica sull'App Store, Play Store o distribuisci download diretti. Perry Publish gestisce il packaging, la notarizzazione e l'invio.
Verifica
Powered by Geisterhand. Test UI automatizzati su tutte le 6 piattaforme. Sappi che la tua app funziona ovunque prima che i tuoi utenti te lo facciano notare.
Gratuito per i progetti open source. Piani per i team → /publish
L'unico framework che soddisfa ogni requisito
TypeScript compilato in codice nativo. Veri widget di piattaforma. Zero overhead runtime.
| Framework | Linguaggio | Codice nativo | Widget nativi | Overhead runtime |
|---|---|---|---|---|
Perry★AOT compiled to native binary | TypeScript | None | ||
React NativeJIT / interpreted at runtime | JS / TypeScript | Hermes / V8 + Bridge | ||
FlutterAOT compiled, custom renderer | Dart | Dart VM + Skia engine | ||
KMP + ComposeJVM on Android, native on iOS | Kotlin | Parziale | Kotlin runtime + Skia | |
Swift for AndroidNative binary, no shared UI | Swift | Nessuna UI condivisa | Swift runtime on Android | |
.NET MAUIPartial AOT via Mono | C# | Parziale | .NET / Mono runtime | |
NativeScriptJS runtime, native widget access | JS / TypeScript | V8 / JavaScriptCore | ||
IonicWeb app in native wrapper | JS / TypeScript | WebView + Capacitor |
Scrivi TypeScript, distribuisci nativo
Usa la sintassi e le API TypeScript familiari. Perry fa il resto.
// hello.tsconst greeting = "Hello, World!";console.log(greeting); // Compiles to ~2MB native executable// No runtime needed!Confronto delle prestazioni
La compilazione nativa offre un'efficienza senza pari
| Metrica | Perry | Node.js | Bun |
|---|---|---|---|
| Dimensione binario | 2-5 MB | ~80 MB | ~90 MB |
| Tempo di avvio | ~1 ms | ~30 ms | ~10 ms |
| Dipendenze runtime | Nessuna | Node.js | Bun |
| Overhead memoria | Minimo | V8 + GC | JSC + GC |
Risultati benchmark: Fino a 18x più veloce
Perry v0.5.279 vs Node.js v25 — mediana RUNS=11, Apple M1 Max (più basso è meglio)
Inizia
Installa Perry e inizia a compilare TypeScript in eseguibili nativi
1Installazione
$ brew tap PerryTS/perry$ brew install perryRichiede Homebrew. Supporta macOS arm64 e x86_64.
2Utilizzo
perry compile main.tsCompila main.ts in un eseguibile nativo
perry compile main.ts -o myappSpecifica il nome dell'eseguibile di output
perry compile main.ts --enable-js-runtimeAbilita V8 per la compatibilità con i pacchetti npm JavaScript
perry check ./srcValida il codice TypeScript per la compilazione nativa
Supporto delle funzionalità
Copertura completa delle API TypeScript e Node.js
Core Language
- Numbers64-bit floating point (f64)
- StringsUTF-8, all common methods
- Booleanstrue/false, logical operators
- ArraysTyped and mixed-type arrays
- ObjectsObject literals and field access
- BigInt256-bit integer support
- EnumsNumeric and string enums
Functions
- Function DeclarationNamed functions
- Arrow Functions() => {} syntax
- Default ParametersParameters with defaults
- Rest Parameters...args syntax
- ClosuresIncluding mutable captures
- Higher-Order FunctionsFunctions as arguments/returns
- Async/AwaitAsync function support
Classes
- Class DeclarationBasic class syntax
- ConstructorsWith parameters
- Private Fields (#)ES2022 #privateField syntax
- Static Methods/FieldsClass-level members
- Getters/Settersget/set accessors
- Inheritanceextends keyword
- Super Callssuper() constructor calls
Type System
- Type AnnotationsExplicit type declarations
- Type InferenceAutomatic type detection
- GenericsMonomorphization (like Rust)
- InterfacesInterface declarations
- Union Typesstring | number support
- Type Guardstypeof operator
- Type Aliasestype X = ... declarations
Standard Library
- fsreadFileSync, writeFileSync, existsSync, etc.
- pathjoin, dirname, basename, extname, resolve
- cryptorandomBytes, randomUUID, sha256, md5
- osplatform, arch, hostname, memory info
- Bufferfrom, alloc, toString, slice, copy
- child_processexecSync, spawnSync
- JSON/Math/DateFull implementations
Oltre 30 pacchetti npm nativi
Pacchetti npm popolari reimplementati in Rust nativo. Nessun npm install, nessun node_modules, solo codice nativo veloce.
Database
Sicurezza
HTTP
Elaborazione dati
Data e ora
Utilità
Come funziona
Dal codice sorgente TypeScript all'eseguibile nativo in pochi secondi
Vuoi sapere come funziona il compilatore sotto il cofano? Meccanismi interni del compilatore
Approfondimento: TypeScript su LLVM — monomorfizzazione, NaN-boxing e perché Perry ha abbandonato Cranelift.
Domande frequenti
Tutto quello che si chiede prima di compilare il primo binario
Perry ha bisogno di Node.js o di un runtime?
No. Perry compila TypeScript ahead-of-time in un eseguibile nativo standalone. Il binario funziona senza Node.js, Bun, Deno o qualsiasi runtime JavaScript installato sulla macchina. Per i pacchetti npm che non possono ancora compilare nativamente, è disponibile un fallback V8 embedded opzionale tramite --enable-js-runtime.
Quanto sono grandi i binari compilati?
Un binario hello-world è di circa 330 KB. I tipici strumenti CLI si attestano su 2–5 MB. Le applicazioni complete che includono framework di grandi dimensioni (Fastify, mysql2, ecc.) sono di circa 48 MB — comunque molto al di sotto degli ~80–150 MB da cui parte un'app Electron o un binario con runtime embedded.
Posso usare i pacchetti npm?
Sì. I pacchetti TypeScript/JavaScript puro compilano nativamente tramite perry.compilePackages — axios, zod v4, express, fastify e hono compilano e funzionano già oggi. I pacchetti che necessitano della piena semantica di un motore JS possono girare tramite il fallback V8 opzionale con --enable-js-runtime.
Quali piattaforme supporta Perry?
Dieci target di compilazione: macOS, iOS, iPadOS, Android, Linux, Windows, watchOS, tvOS, WebAssembly e Web/JS. Le app GUI usano widget nativi della piattaforma — AppKit, UIKit, GTK4, Win32 e Android tramite JNI.
Perry è gratuito e open source?
Sì. Il compilatore è gratuito e open source. Compilare ed eseguire in locale non costa nulla e non richiede alcun account. Perry Publish — la pipeline hosted di build, firma e invio agli store — ha un livello gratuito (15 pubblicazioni al mese) e un piano Pro.
In cosa Perry è diverso da Bun o da deno compile?
Bun e Deno raggruppano il tuo JavaScript insieme al proprio runtime in un unico file — un hello world è di circa 60–100 MB a seconda della piattaforma, e il codice viene comunque eseguito tramite JIT. Perry compila TypeScript ahead-of-time in codice macchina tramite LLVM: nessun motore embedded, hello world di ~330 KB, avvio di ~1 ms. Guarda i confronti completi Perry vs Bun e Perry vs Deno.
In cosa Perry è diverso da Electron o Tauri?
Electron distribuisce Chromium e Node.js con ogni app, quindi gli installer partono da circa 80–150 MB. Tauri è molto più piccolo ma renderizza comunque un frontend web nella webview di sistema, con la logica dell'app in Rust. Perry non usa alcuna webview: TypeScript compila in codice macchina che pilota veri widget di piattaforma — AppKit, UIKit, GTK4, Win32 — in un unico processo. Guarda i confronti completi Perry vs Electron e Perry vs Tauri.
Quanto è maturo Perry?
Perry è pre-1.0 e si muove velocemente, ma app reali costruite con esso vengono già distribuite oggi — tra queste Bloom Engine, Mango, Hone, Pry e dB Meter. Guarda lo showcase per i dettagli.
Altre domande? Leggi la guida introduttiva o chiedi su GitHub Discussions.