Compile TypeScript para Nativo.
Um Único Código, Todas as Plataformas.
Perry compila TypeScript para aplicações GUI e CLI nativas em macOS, iPadOS, iOS, Android, Linux, Windows, watchOS, tvOS, HarmonyOS, WebAssembly e Web. Sem runtime. Sem Electron. Apenas binários nativos.
$ perry compile main.ts
Compilando main.ts...
✓ Executável compilado: main (2,3 MB)
$ ./main
Hello, World!
Apps reais, compiladas a partir de TypeScript com Perry.
Por que Perry?
Tudo o que você precisa para compilar TypeScript em aplicações nativas
Sem runtime necessário
Produz executáveis nativos independentes. Sem Node.js, sem V8, sem dependências de runtime. Apenas um binário que roda em qualquer lugar.
Compilação rápida
Compilação direta de TypeScript para código nativo usando SWC para análise e LLVM para geração de código otimizado. Sem JavaScript intermediário.
Binários pequenos
Os binários de saída são tipicamente 2-5 MB. Com o runtime V8 opcional para pacotes npm JS, 15-20 MB. Envie menos, faça deploy mais rápido.
Builds determinísticos
Mesma entrada, mesmo binário. Reproduzível em qualquer máquina, em qualquer execução de CI, em qualquer equipe. Sem rebuilds misteriosos.
Biblioteca padrão abrangente
Implementações nativas integradas de fs, path, crypto, os, Buffer, child_process e mais. Use as APIs familiares do Node.js.
Pacotes npm reais
axios, zod, express, fastify e hono compilam para binários nativos. Pacotes de JavaScript puro rodam em um runtime embutido opcional — autossuficientes, sem node_modules em runtime.
Mais de 35 widgets UI nativos
Botões, tabelas, date pickers, drag & drop, gráficos, mapas, paletas de comando, códigos QR, texto rico e mais — tudo compilando para widgets reais da plataforma via AppKit, UIKit, GTK4, Win32 (Fluent/Mica) e JNI.
Sistema de plugins em tempo de compilação
Módulos se compõem em tempo de build — sem overhead de plugins em runtime, sem fronteiras IPC. Suas dependências se tornam chamadas de função nativas diretas no binário final.
Multi-threading real
Threads reais do sistema operacional com parallelMap, parallelFilter e spawn. Segurança em tempo de compilação rejeita capturas mutáveis — sem SharedArrayBuffer, sem workers, apenas threads.
i18n em tempo de compilação
Extração automática de strings, regras de plural CLDR para mais de 30 idiomas, validação em tempo de compilação. Traduções integradas no binário com busca quase nula em runtime.
Aprofunde-se: como o Perry compila TypeScript para um binário, o que faz dele um compilador nativo de TypeScript, e como ele se compara a alternativas ao Electron.
Veja o que as pessoas constroem
Apps nativas reais, compiladas a partir de TypeScript. Sem Electron, sem web views — apenas UI nativa em cada plataforma.
Mango
GUI MongoDB nativa — construída inteiramente em TypeScript
Hone
Editor de código nativo com IA — TypeScript para binário nativo
Nativo em todas as plataformas
Perry compila seu TypeScript para frameworks UI nativos, WebAssembly e JavaScript — sem web views, sem Electron. Widgets nativos reais em cada plataforma, mais a web.
macOS
AppKit
iOS
UIKit
iPadOS
UIKit
Android
Views
Linux
GTK4
Windows
Win32
watchOS
SwiftUI
tvOS
SwiftUI
WASM
WebAssembly
Web
JavaScript
Do código à App Store
Perry não apenas compila sua app — coloca-a nas mãos dos seus usuários.
Compilar e assinar
Builds multiplataforma com um único comando. Assinatura de código para macOS, iOS, Android e Windows feita por você. Sem lutar com perfis de provisionamento do Xcode ou keystores do Android.
Distribuir
Publique na App Store, Play Store ou envie downloads diretos. Perry Publish cuida do empacotamento, notarização e envio.
Verificar
Powered by Geisterhand. Testes de UI automatizados em todas as 6 plataformas. Saiba que sua app funciona em todos os lugares antes que seus usuários digam o contrário.
Grátis para projetos de código aberto. Planos para equipes → /publish
O único framework que marca todas as caixas
TypeScript compilado para código nativo. Widgets reais da plataforma. Zero overhead de runtime.
| Framework | Linguagem | Código nativo | Widgets nativos | Overhead de 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 | Parcial | Kotlin runtime + Skia | |
Swift for AndroidNative binary, no shared UI | Swift | Sem UI compartilhada | Swift runtime on Android | |
.NET MAUIPartial AOT via Mono | C# | Parcial | .NET / Mono runtime | |
NativeScriptJS runtime, native widget access | JS / TypeScript | V8 / JavaScriptCore | ||
IonicWeb app in native wrapper | JS / TypeScript | WebView + Capacitor |
Escreva TypeScript, entregue nativo
Use a sintaxe e APIs familiares do TypeScript. Perry cuida do resto.
// hello.tsconst greeting = "Hello, World!";console.log(greeting); // Compiles to ~2MB native executable// No runtime needed!Comparação de desempenho
A compilação nativa oferece eficiência incomparável
| Métrica | Perry | Node.js | Bun |
|---|---|---|---|
| Tamanho do binário | 2-5 MB | ~80 MB | ~90 MB |
| Tempo de inicialização | ~1 ms | ~30 ms | ~10 ms |
| Dependências de runtime | Nenhuma | Node.js | Bun |
| Overhead de memória | Mínimo | V8 + GC | JSC + GC |
Resultados do benchmark: Até 18x mais rápido
Perry v0.5.279 vs Node.js v25 — mediana de RUNS=11, Apple M1 Max (menor é melhor)
Começar
Instale Perry e comece a compilar TypeScript para executáveis nativos
1Instalação
$ brew tap PerryTS/perry$ brew install perryRequer Homebrew. Suporta macOS arm64 e x86_64.
2Uso
perry compile main.tsCompila main.ts para um executável nativo
perry compile main.ts -o myappEspecificar o nome do executável de saída
perry compile main.ts --enable-js-runtimeAtivar V8 para compatibilidade com pacotes npm JavaScript
perry check ./srcValidar código TypeScript para compilação nativa
Suporte de funcionalidades
Cobertura abrangente de APIs 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
Mais de 30 pacotes npm nativos
Pacotes npm populares reimplementados em Rust nativo. Sem npm install, sem node_modules, apenas código nativo rápido.
Banco de dados
Segurança
HTTP
Processamento de dados
Data e hora
Utilitários
Como funciona
Do código-fonte TypeScript ao executável nativo em segundos
Quer saber como o compilador funciona por dentro? Internos do compilador
Aprofundamento: TypeScript sobre LLVM — monomorfização, NaN-boxing, e por que o Perry deixou o Cranelift.
Perguntas Frequentes
Tudo o que as pessoas perguntam antes de compilar seu primeiro binário
O Perry precisa de Node.js ou de um runtime?
Não. O Perry compila TypeScript ahead-of-time para um executável nativo standalone. O binário roda sem Node.js, Bun, Deno ou qualquer runtime JavaScript instalado na máquina. Para pacotes npm que ainda não compilam nativamente, um runtime V8 embutido opcional está disponível via --enable-js-runtime.
Qual é o tamanho dos binários compilados?
Um binário hello-world tem cerca de 330 KB. Ferramentas de CLI típicas ficam entre 2–5 MB. Aplicações completas que trazem frameworks grandes (Fastify, mysql2, etc.) ficam em torno de 48 MB — ainda bem abaixo dos ~80–150 MB em que um app Electron ou um binário com runtime embutido começa.
Posso usar pacotes npm?
Sim. Pacotes de TypeScript/JavaScript puro compilam nativamente via perry.compilePackages — axios, zod v4, express, fastify e hono compilam e rodam hoje. Pacotes que precisam da semântica completa de um motor JS podem rodar através do runtime V8 embutido opcional com --enable-js-runtime.
Quais plataformas o Perry suporta?
Dez alvos de compilação: macOS, iOS, iPadOS, Android, Linux, Windows, watchOS, tvOS, WebAssembly e Web/JS. Aplicações GUI usam widgets nativos da plataforma — AppKit, UIKit, GTK4, Win32 e Android via JNI.
O Perry é gratuito e de código aberto?
Sim. O compilador é gratuito e de código aberto. Compilar e rodar localmente não custa nada e não exige conta. O Perry Publish — o pipeline hospedado de build, assinatura de código e envio à loja — tem um nível gratuito (15 publicações por mês) e um plano Pro.
Como o Perry se diferencia do Bun ou do Deno compile?
Bun e Deno empacotam seu JavaScript junto com o runtime deles em um único arquivo — um hello world tem cerca de 60–100 MB dependendo da plataforma, e o código ainda é executado via JIT. O Perry compila TypeScript ahead-of-time para código de máquina via LLVM: sem motor embutido, ~330 KB para um hello world, ~1 ms de inicialização. Veja as comparações completas Perry vs Bun e Perry vs Deno.
Como o Perry se diferencia do Electron ou do Tauri?
O Electron distribui Chromium e Node.js com cada aplicação, então os instaladores começam em cerca de 80–150 MB. O Tauri é bem menor, mas ainda renderiza um frontend web na webview do sistema, com a lógica da aplicação em Rust. O Perry não usa webview alguma: o TypeScript compila para código de máquina que aciona widgets reais da plataforma — AppKit, UIKit, GTK4, Win32 — em um único processo. Veja as comparações completas Perry vs Electron e Perry vs Tauri.
Quão maduro é o Perry?
O Perry está pré-1.0 e avançando rápido, mas aplicações reais construídas com ele já estão sendo entregues hoje — entre elas Bloom Engine, Mango, Hone, Pry e dB Meter. Veja o showcase para mais detalhes.
Mais perguntas? Leia o guia de primeiros passos ou pergunte no GitHub Discussions.