Compilez TypeScript en natif.
Un seul code, toutes les plateformes.
Perry compile TypeScript en applications GUI et CLI natives sur macOS, iPadOS, iOS, Android, Linux, Windows, watchOS, tvOS, HarmonyOS, WebAssembly et le Web. Pas de runtime. Pas d'Electron. Juste des binaires natifs.
$ perry compile main.ts
Compilation de main.ts...
✓ Exécutable compilé : main (2,3 Mo)
$ ./main
Hello, World!
De vraies apps, compilées depuis TypeScript avec Perry.
Pourquoi Perry ?
Tout ce dont vous avez besoin pour compiler TypeScript en applications natives
Aucun runtime nécessaire
Produit des exécutables natifs autonomes. Pas de Node.js, pas de V8, aucune dépendance runtime. Juste un binaire unique qui s'exécute partout.
Compilation rapide
Compilation directe de TypeScript en code natif avec SWC pour l'analyse et LLVM pour la génération de code optimisé. Pas de JavaScript intermédiaire.
Petits binaires
Les binaires de sortie font généralement 2 à 5 Mo. Avec le runtime V8 optionnel pour les paquets npm JS, 15 à 20 Mo. Livrez moins, déployez plus vite.
Builds déterministes
Même entrée, même binaire. Reproductible d'une machine à l'autre, d'un build CI à l'autre, d'une équipe à l'autre. Pas de rebuild mystérieux.
Bibliothèque standard complète
Implémentations natives intégrées de fs, path, crypto, os, Buffer, child_process et plus. Utilisez les APIs familières de Node.js.
De vrais packages npm
axios, zod, express, fastify et hono compilent en binaires natifs. Les packages en JavaScript pur tournent sur un runtime embarqué optionnel — autonomes, sans node_modules à l'exécution.
Plus de 35 widgets UI natifs
Boutons, tableaux, sélecteurs de date, drag & drop, graphiques, cartes, palettes de commandes, codes QR, texte enrichi et plus — le tout compilé en véritables widgets de plateforme via AppKit, UIKit, GTK4, Win32 (Fluent/Mica) et JNI.
Système de plugins au moment de la compilation
Les modules se composent au moment du build — aucun overhead de plugin à l'exécution, aucune frontière IPC. Vos dépendances deviennent des appels de fonction natifs directs dans le binaire final.
Vrai multi-threading
De vrais threads OS avec parallelMap, parallelFilter et spawn. La sûreté au moment de la compilation rejette les captures mutables — pas de SharedArrayBuffer, pas de workers, juste des threads.
i18n au moment de la compilation
Extraction automatique des chaînes, règles de pluriel CLDR pour plus de 30 langues, validation au moment de la compilation. Les traductions sont intégrées dans le binaire avec une recherche quasi nulle à l'exécution.
Pour aller plus loin : comment Perry compile TypeScript en binaire, ce qui en fait un compilateur TypeScript natif, et comment il se positionne face aux alternatives à Electron.
Voyez ce que les gens construisent
De vraies apps natives, compilées depuis TypeScript. Pas d'Electron, pas de web views — juste une UI native sur chaque plateforme.
Mango
GUI MongoDB native — entièrement construite en TypeScript
Hone
Éditeur de code natif propulsé par l'IA — TypeScript vers binaire natif
Natif sur toutes les plateformes
Perry compile votre TypeScript en frameworks UI natifs, WebAssembly et JavaScript — pas de web views, pas d'Electron. De vrais widgets natifs sur chaque plateforme, plus le web.
macOS
AppKit
iOS
UIKit
iPadOS
UIKit
Android
Views
Linux
GTK4
Windows
Win32
watchOS
SwiftUI
tvOS
SwiftUI
WASM
WebAssembly
Web
JavaScript
Du code à l’App Store
Perry ne fait pas que compiler votre app — il la met entre les mains de vos utilisateurs.
Compiler et signer
Des builds multiplateforme en une seule commande. La signature de code pour macOS, iOS, Android et Windows est gérée pour vous. Plus besoin de se battre avec les profils de provisionnement Xcode ou les keystores Android.
Distribuer
Publiez sur l'App Store, le Play Store ou envoyez des téléchargements directs. Perry Publish gère l'empaquetage, la notarisation et la soumission.
Vérifier
Propulsé par Geisterhand. Tests UI automatisés sur les 6 plateformes. Sachez que votre app fonctionne partout avant que vos utilisateurs ne vous disent le contraire.
Gratuit pour les projets open source. Plans pour les équipes → /publish
Le seul framework qui coche toutes les cases
TypeScript compilé en code natif. De vrais widgets de plateforme. Zéro overhead runtime.
| Framework | Langage | Code natif | Widgets natifs | 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 | Partiel | Kotlin runtime + Skia | |
Swift for AndroidNative binary, no shared UI | Swift | Pas d'UI partagée | Swift runtime on Android | |
.NET MAUIPartial AOT via Mono | C# | Partiel | .NET / Mono runtime | |
NativeScriptJS runtime, native widget access | JS / TypeScript | V8 / JavaScriptCore | ||
IonicWeb app in native wrapper | JS / TypeScript | WebView + Capacitor |
Écrivez du TypeScript, livrez en natif
Utilisez la syntaxe et les APIs TypeScript familières. Perry s'occupe du reste.
// hello.tsconst greeting = "Hello, World!";console.log(greeting); // Compiles to ~2MB native executable// No runtime needed!Comparaison des performances
La compilation native offre une efficacité inégalée
| Métrique | Perry | Node.js | Bun |
|---|---|---|---|
| Taille du binaire | 2-5 MB | ~80 MB | ~90 MB |
| Temps de démarrage | ~1 ms | ~30 ms | ~10 ms |
| Dépendances runtime | Aucune | Node.js | Bun |
| Overhead mémoire | Minimal | V8 + GC | JSC + GC |
Résultats du benchmark : Jusqu'à 18x plus rapide
Perry v0.5.279 vs Node.js v25 — médiane RUNS=11, Apple M1 Max (plus bas est mieux)
Commencer
Installez Perry et commencez à compiler TypeScript en exécutables natifs
1Installation
$ brew tap PerryTS/perry$ brew install perryNécessite Homebrew. Compatible macOS arm64 et x86_64.
2Utilisation
perry compile main.tsCompile main.ts en un exécutable natif
perry compile main.ts -o myappSpécifier le nom de l'exécutable de sortie
perry compile main.ts --enable-js-runtimeActiver V8 pour la compatibilité des paquets npm JavaScript
perry check ./srcValider le code TypeScript pour la compilation native
Support des fonctionnalités
Couverture complète des APIs TypeScript et 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
Plus de 30 paquets npm natifs
Des paquets npm populaires réimplémentés en Rust natif. Pas de npm install, pas de node_modules, juste du code natif rapide.
Base de données
Sécurité
HTTP
Traitement de données
Date et heure
Utilitaires
Comment ça fonctionne
Du code source TypeScript à l'exécutable natif en quelques secondes
Vous voulez savoir comment le compilateur fonctionne en coulisses ? Fonctionnement interne du compilateur
Plongée en profondeur : TypeScript sur LLVM — monomorphisation, NaN-boxing, et pourquoi Perry a quitté Cranelift.
Foire aux questions
Tout ce que les gens demandent avant de compiler leur premier binaire
Perry a-t-il besoin de Node.js ou d'un runtime ?
Non. Perry compile TypeScript à l'avance (AOT) en un exécutable natif autonome. Le binaire s'exécute sans Node.js, Bun, Deno, ni aucun runtime JavaScript installé sur la machine. Pour les paquets npm qui ne peuvent pas encore compiler nativement, un moteur V8 embarqué optionnel est disponible via --enable-js-runtime comme solution de repli.
Quelle est la taille des binaires compilés ?
Un binaire hello-world fait environ 330 Ko. Les outils CLI classiques se situent entre 2 et 5 Mo. Les applications complètes qui embarquent de gros frameworks (Fastify, mysql2, etc.) font environ 48 Mo — toujours bien en dessous des ~80–150 Mo d'où démarre une application Electron ou un binaire avec runtime embarqué.
Puis-je utiliser des paquets npm ?
Oui. Les paquets purement TypeScript/JavaScript compilent nativement via perry.compilePackages — axios, zod v4, express, fastify et hono compilent et s'exécutent dès aujourd'hui. Les paquets qui nécessitent la sémantique complète d'un moteur JS peuvent s'exécuter via le V8 optionnel avec --enable-js-runtime.
Quelles plateformes Perry prend-il en charge ?
Dix cibles de compilation : macOS, iOS, iPadOS, Android, Linux, Windows, watchOS, tvOS, WebAssembly et Web/JS. Les applications GUI utilisent des widgets natifs de plateforme — AppKit, UIKit, GTK4, Win32, et Android via JNI.
Perry est-il gratuit et open source ?
Oui. Le compilateur est gratuit et open source. Compiler et exécuter en local ne coûte rien et ne nécessite aucun compte. Perry Publish — le pipeline hébergé de compilation, signature et soumission aux stores — propose un palier gratuit (15 publications par mois) et un plan Pro.
En quoi Perry diffère-t-il de Bun ou de deno compile ?
Bun et Deno regroupent votre JavaScript avec leur runtime dans un seul fichier — un hello world pèse environ 60 à 100 Mo selon la plateforme, et le code reste exécuté en JIT. Perry compile TypeScript à l'avance en code machine via LLVM : aucun moteur embarqué, ~330 Ko pour un hello world, ~1 ms de démarrage. Voir les comparaisons complètes Perry vs Bun et Perry vs Deno.
En quoi Perry diffère-t-il d'Electron ou de Tauri ?
Electron livre Chromium et Node.js avec chaque application, si bien que les installeurs démarrent autour de 80 à 150 Mo. Tauri est bien plus léger mais rend toujours un frontend web dans la webview système, avec la logique applicative en Rust. Perry n'utilise aucune webview : TypeScript compile en code machine qui pilote de vrais widgets de plateforme — AppKit, UIKit, GTK4, Win32 — dans un seul processus. Voir les comparaisons complètes Perry vs Electron et Perry vs Tauri.
Quel est le niveau de maturité de Perry ?
Perry est en pré-1.0 et avance vite, mais de vraies applications construites avec sont livrées dès aujourd'hui — parmi elles Bloom Engine, Mango, Hone, Pry et dB Meter. Voir le showcase pour plus de détails.
D'autres questions ? Consultez le guide de prise en main ou posez votre question sur GitHub Discussions.