Perry Kapsamlı İnceleme: TypeScript'ten Native Makine Koduna Uzanan V8'siz Devrim

Modern yazılım geliştirme dünyasında JavaScript ve TypeScript’in hakimiyeti tartışılmaz. Ancak bu dilleri masaüstünde veya sunucuda çalıştırmak istediğimizde, devasa bir bedel ödüyoruz: V8 motoru ve Node.js/Deno/Bun gibi çalışma zamanı (runtime) ortamları.

Sadece basit bir “Hello World” yazdırmak için bile onlarca megabayt belleğe ihtiyaç duyan, Electron veya Tauri gibi araçlarla masaüstü uygulaması geliştirdiğimizde Chromium motorunu projemize dahil eden bu yapıların “hantal” olduğu bir sır değil.

Peki ya size TypeScript kodunuzu, tıpkı C, C++ veya Rust gibi doğrudan işletim sisteminin anladığı makine koduna (native binary) çevirebilen, çalışma zamanı bağımlılığı olmayan ve sadece ~330 KB boyutunda çalıştırılabilir dosyalar üreten bir derleyici var desem?

Karşınızda, modern web geliştiricilerinin “hız ve boyut” zincirlerini kıran, Rust ve LLVM’in inanılmaz gücünü arkasına alan, TypeScript’i makine koduna derleyen native derleyici: Perry!

Bu kapsamlı teknik incelememizde, Perry’nin sadece yüzeysel bir tanıtımını yapmayacak; kod tabanının (codebase) derinliklerine inerek NaN-boxing mimarisi, thread-local Arena bellek tahsisatı (allocation) ve LLVM optimizasyonlarının kaputun altında nasıl çalıştığına satır satır şahitlik edeceğiz. Gea.js’in Virtual DOM’u tarihe gömdüğü gibi, Perry de V8 motorunu masaüstü ve sunucu uygulamalarında tarihe gömmeye hazırlanıyor.

1. V8 ve Node.js Çağının Ötesi: Perry Nedir? 🤔

TypeScript, esasen JavaScript’e derlenen (transpile) bir dildir. Geleneksel akışta tsc veya esbuild kodunuzu JavaScript’e çevirir, ardından V8 veya JavaScriptCore gibi bir JIT (Just-In-Time) derleyicisi bu kodu çalışma anında makine koduna dönüştürür.

Perry’nin savunduğu temel felsefe şudur: “Neden kodu makine diline çevirmek için kullanıcının bilgisayarında devasa bir derleyici (V8) çalıştıralım? Neden bunu geliştiricinin bilgisayarında (Ahead-Of-Time) yapmayalım?”

Perry, bir yorumlayıcı (interpreter) veya sanal makine değildir. Saf, gerçek ve acımasız bir derleyicidir (compiler). TypeScript kodunuzu alır ve Windows (.exe), macOS, Linux ve hatta iOS/Android için doğrudan çalıştırılabilir ikili (binary) dosyalara dönüştürür.

Bunun size sağladığı temel avantajlar:

• Sıfır Bağımlılık (Zero Dependency): Kullanıcının sisteminde Node.js, JRE veya .NET kurulu olmasına gerek yoktur. Tıpkı Go veya Rust gibi tek bir dosya (single executable) üretir.
• Anında Başlama (Instant Startup): JIT “ısınma” süresi (warmup) yoktur. Uygulamanız milisaniyeler içinde başlar.
• Küçük Boyut: Klasik Electron uygulamaları 150 MB’tan başlarken, Perry’nin native UI barındıran Hello World uygulamaları yüzlerce kilobayt boyutundadır.
• Kaynak Tüketimi: V8’in arkada çalıştırdığı devasa çöp toplayıcı (Garbage Collector) ve optimizasyon iplikleri (threads) olmadığı için RAM kullanımı olağanüstü düşüktür.

2. Kaputun Altı: Rust, SWC ve LLVM Üçgeni 🫀

Perry’nin gücü, modern yazılım ekosisteminin en sağlam taşları üzerine inşa edilmesinden gelir. Derleyicinin (compiler) kendisi tamamen Rust ile yazılmıştır.

Derleme süreci (Compilation Pipeline) üç ana aşamadan oluşur:

1. Ayrıştırma (Parsing) - SWC: Perry, TypeScript kodunuzu ayrıştırmak (parse) ve bir Abstract Syntax Tree (AST) oluşturmak için Next.js’in de kullandığı süper hızlı Rust tabanlı SWC kütüphanesini kullanır.
2. HIR (High-Level Intermediate Representation): SWC’den gelen AST, Perry’nin kendi iç mimarisi olan HIR’a (perry-hir) dönüştürülür. Bu aşamada değişkenlerin kapsamı (scope), closure’ların bağlamı (capture) hesaplanır ve tip çıkarma (type inference) yapılır.
3. LLVM Kod Üretimi (Codegen): En büyük sihir burada başlar. Perry’nin ilk sürümlerinde hızlı derleme için Cranelift kullanılıyordu. Ancak Cranelift, “hızlı kod üretme” odaklı bir JIT derleyicisiydi. Perry ekibi, uygulamanın hız tavanını (optimizer ceiling) kırmak ve Apple Watch (arm64_32) gibi mimarilere tam destek vermek için devasa bir mimari göçe imza attı ve tamamen LLVM altyapısına geçti. LLVM, Apple’ın Swift’ini, C++’ı (Clang) ve Rust’ı derleyen altyapının ta kendisidir. Böylece Perry, 30 yıllık “endüstri standardı” kod optimizasyon tekniklerinin (Loop vectorization, LICM, GVN vb.) hepsini bedavaya kapmış olur!

3. Veri Temsili Sırrı: “NaN-Boxing” Büyüsü 🪄

JavaScript dinamik tipli bir dildir. Bir değişken bir an sayı (number), bir an obje (object) olabilir. Geleneksel C/C++ yapılarında bunu yönetmek için değişkenleri büyük “yapılar” (structs) içinde ve Heap’te tutmanız gerekir. Ancak bu çok yavaştır.

Perry, V8 ve JavaScriptCore’un da kullandığı harika bir hileyi kullanır: NaN-Boxing. İncelediğimiz crates/perry-runtime/src/value.rs ve crates/perry-codegen/src/nanbox.rs dosyaları bu mimarinin kalbini oluşturuyor.

NaN-Boxing Nasıl Çalışır?

IEEE 754 standardına göre 64-bit ondalık sayılar (double float) için ayrılan alan o kadar büyüktür ki, “NaN” (Not a Number) olarak işaretlenmiş trilyonlarca geçersiz kombinasyon vardır.

Perry, 64-bit’lik belleği (register) şu şekilde kullanır: Eğer bitler geçerli bir sayıysa, doğrudan CPU’da işlem görür. Değilse, en üstteki 16 bit (Tag bits) verinin “tipini” (Undefined, Null, Boolean, String, Object) belirtir. Kalan 48 bit (Payload) ise verinin değerini veya Heap’teki işaretçisini (pointer) tutar.

Bu ne demek? Basit bir tam sayı (integer) aritmetiği yaptığınızda, obje yaratılmaz, bellek tahsisatı (allocation) yapılmaz. Her şey doğrudan CPU’nun en hızlı donanım yazmaçlarında (registers) gerçekleşir.

4. Bellek Yönetimi: V8’e Kafa Tutan Arena Allocator ve GC 🏗️

JavaScript demek, sürekli yaratılan ve yok edilen milyonlarca nesne demektir. Perry, Node.js gibi devasa bir bellek motoru kullanmadığı için perry-runtime içinde kendi harika bellek yöneticisini barındırır.

Thread-Local Bump Allocator ve mimalloc (Sıfır Maliyetli Tahsisat)

Yeni bir nesne (new ClassName()) yarattığınızda ne olur? crates/perry-runtime/src/arena.rs dosyası bize sırrı veriyor: Perry, global bellek yöneticisi olarak efsanevi mimalloc‘u kullanırken, her işletim sistemi ipliği (thread) için özel bir bellek havuzu (Arena) ayırır. Yeni bir nesne gerektiğinde, karmaşık işletim sistemi çağrıları (malloc) yapılmaz. Pointer sadece ileri doğru birkaç bayt kaydırılır (Bump Allocation) ve bu işlem doğrudan LLVM IR seviyesinde “inline” olarak (satır içi) kodlanır. Bu, donanım düzeyinde kelimenin tam anlamıyla “sıfır maliyetli” (zero-cost) bir işlemdir ve C dilindeki yığın (stack) tahsisatı kadar hızlıdır.

Muhafazakar (Conservative) Mark-Sweep GC

Peki dolan bellek nasıl temizlenir? crates/perry-runtime/src/gc.rs içinde uygulanan Mark-Sweep Garbage Collector, “muhafazakar yığın taraması” (conservative stack scanning) yapar. Yani CPU’nun yığınını (stack) okur, işaretçi (pointer) olabilecek değerleri bulur, onlara bağlı olan nesneleri “Canlı” (Mark) olarak işaretler ve geriye kalan her şeyi silip atar (Sweep). Üstelik Adaptive Malloc-Trigger mantığı sayesinde GC, son silme işleminin verimliliğine bakarak bir sonraki temizliğin ne zaman yapılacağını zekice belirler. Böylece CPU’nun duraklama süreleri (pause times) minimize edilir.

5. İleri Düzey Derleyici Optimizasyonları (Performans Sırları) 🚀

Perry’nin neden çok hızlı olduğunu PERF_ROADMAP.md belgelerinde detaylıca görebiliriz. Derleyici sadece kodu makine diline çevirmez, aynı zamanda kodu “daha akıllı” hale getirir:

1. Escape Analysis (Kaçış Analizi) ve Scalar Replacement: Eğer bir objeyi (veya array’i) sadece bir fonksiyonun içinde kullanıp işini bitiriyorsanız, Perry o objeyi Heap’te yaratmaz! Objeyi parçalar ve özelliklerini doğrudan CPU register’larına yerleştirir (Scalar Replacement). Obje hiç yaratılmadığı için Garbage Collector da yorulmaz.
2. i32 Fast Path ve Fast-Math Bayrakları: Kodunuzda matematik işlemi (veya döngü sayacı) varsa, Perry bunu JavaScript’in standart double float hesaplaması yerine yerel 32-bit tamsayı (i32) matematiğine çevirir. LLVM’e verilen reassoc contract (fast-math) bayrakları sayesinde factorial gibi yoğun matematik işlemlerinde Node.js’ten tam 24.6 kat (24.6x) daha hızlı çalışır (24ms vs Node’un 591ms’i)!
3. Monomorfik Satıriçi Önbellek (PIC - Inline Cache): Modern JS motorlarının kalbi olan Inline Cache yapısı Perry’de native olarak bulunur. Sürekli aynı tipte bir objenin özelliğine eriştiğinizde (PropertyGet), Perry dinamik metod aramak yerine doğrudan hafıza offset’ini cache’ler ve doğrudan bellekten yükler.
4. Typed Buffer Locals (noalias metadata): Buffer veya Uint8Array gibi veri yapılarını okurken normalde her adımda “NaN-Box açma” (unbox) yapılması gerekir. Perry, buffer tiplerini statik olarak belirler, bunlara LLVM’in anlayacağı noalias etiketleri vurur ve pointer yüklerini (load) doğrudan atar. Resim işleme (örneğin 4K 5x5 blur) testlerinde bu optimizasyon Zig veya C ile birebir aynı performansı (sıfır ek yük) yakalamasını sağlar.
5. SIMD Vektörizasyonu: Döngüler içindeki bağımsız matematik işlemleri (Loop-Invariant Code Motion) ve dizilimler, LLVM’nin akıllı analizleriyle aynı anda birden fazla veriyi işleyebilen (SIMD - Single Instruction, Multiple Data) makine komutlarına otomatik dönüştürülür.

Gelecek Performans Hedefleri: Zig’i Yakalamak

Mevcut durumda Perry, Node.js’i neredeyse tüm testlerde (factorial testinde 24.6x’e kadar) ezici bir şekilde geçse de, saf C/Zig hızına tam olarak ulaşmak için bazı optimizasyonların tamamlanması bekleniyor. Örneğin image_conv (4K çözünürlükte 5x5 piksel blur işlemi) benchmark’ında Perry şu an 457ms seviyesinde çalışırken, Zig 246ms ile zirvede yer alıyor. Aradaki bu mimari farkı kapatmak için “Typed Buffer Locals” (Buffer erişimlerinde unboxing işlemlerini atlamak için saf i64 slot kullanımı), “Interior/border loop splitting” (vektörizasyonu engelleyen gereksiz sınır kontrollerini kaldırmak) ve “Double-ABI FNV-1a hash” optimizasyonları bir sonraki sürümün (PERF_ROADMAP) odak noktasıdır.

6. Chromium’u Çöpe Atın: SwiftUI Zarafetinde %100 Native UI 📱

Node.js uygulamanızı masaüstüne taşımak istediğinizde Electron tek çarenizdi ve uygulamanızın boyutu anında 150 MB’a, RAM kullanımı 300 MB’a fırlıyordu.

Perry ise devrimsel bir yaklaşım sunar: Perry UI (@perry/ui). Yazımı inanılmaz derecede Apple’ın SwiftUI mimarisine benzer: VStack, HStack, ZStack, State ve Button gibi deklaratif bileşenler kullanarak TypeScript ile arayüz yazarsınız.

import { App, Text, Button, VStack, State } from "perry/ui";

function Counter() {
  const count = State(0);
  
  return VStack(16, [
    Text(`Sayaç: ${count.value}`).font("title"),
    Button("Arttır", () => count.value++)
  ]);
}

Ancak bu arayüz arka planda HTML/CSS veya WebView kullanılarak DOM’a basılmaz! Perry’nin dehası burada yatar: Yazdığınız bu bileşenler, işletim sisteminin 25’ten fazla gerçek yerel bileşenine (native widgets) (butonlar, metin alanları, tablolar, canvas, kaydırılabilir alanlar, QR kodları, sıçrama ekranları vb.) doğrudan haritalanır:

• macOS’te: VStack doğrudan NSStackView‘a dönüşür, butonlar gerçek AppKit/Cocoa butonlarıdır.
• Windows’ta: Gerçek Win32 / WinUI bileşenleri.
• Linux’ta: VStack doğrudan GtkBox‘a çevrilir, butonlar native GTK4 elementleridir.
• iOS/Android: UIStackView ve native platform elementleri.

Bu sayede sadece 5-10 MB’lık bir .exe veya .app dosyasıyla, işletim sistemiyle %100 uyumlu, pürüzsüz 60 FPS çalışan ve RAM tüketimi “yok” denilecek kadar az olan masaüstü programları yazabilirsiniz.

7. Gerçek OS Thread’leri: parallelMap ve spawn 🧵

Node.js dünyasında çoklu işlem yapmak bir kabustur; Web Worker’lar açmalı, postMessage ile veri kopyalamalı ve serileştirme (serialization) maliyeti ödemelisiniz.

Perry’de ise işletim sisteminin gerçek thread’lerine (Real OS Threads) erişiminiz vardır. Üstelik bunu tek satır kodla yaparsınız:

import { parallelMap } from "perry/thread";

// Verileri işletim sisteminin tüm çekirdeklerine dağıtır!
const results = parallelMap(data, (item) => heavyComputation(item));

perry/thread paketi, arka planda C/C++ thread’lerini yönetir. Closure’lar hafızaya (deep-copy mantığıyla) kopyalanır ve mutasyon hataları (compile-time) derleme zamanında engellenir. Veri bilimcilerin veya resim işleme motorlarının hayalini kurduğu paralel işleme mimarisi (parallelFilter, spawn) Perry’nin merkezindedir.

8. Dünyada Bir İlk: Geisterhand (Hayalet El) ile Dahili UI Testi 👻

Masaüstü uygulamalarını test etmek (E2E testing) eziyet vericidir. Perry, “Geisterhand” (Almanca: Hayalet El) adını verdiği inanılmaz bir eklentiyle bu sorunu kökten çözüyor.

Eğer projenizi --enable-geisterhand bayrağı (flag) ile derlerseniz:

perry app.ts -o app --enable-geisterhand

Perry, çalıştırılabilir dosyanızın içine gizli bir HTTP Sunucusu gömer (varsayılan: 7676 portu). Uygulamanız çalışırken, dışarıdan HTTP istekleri atarak programınızdaki herhangi bir butona tıklatabilir, TextField’lara yazı yazdırabilir, slider’ları çekebilir veya ekran görüntüsü aldırabilirsiniz. Selenium veya Puppeteer tarzı hantal test araçlarına ihtiyaç kalmaz. Python, cURL veya herhangi bir REST aracıyla native masaüstü uygulamanıza tam Chaos Fuzzing veya UI otomasyonu yapabilirsiniz!

9. Çıldırtan Özellik: NPM Paketlerinin Native Rust Sandıklarına (Crates) Dönüşmesi 📦

Bir derleyicinin Node.js’e rakip olabilmesi için NPM ekosistemini desteklemesi şarttır. “Peki yazdığım NPM paketleri çalışacak mı?” diye soruyorsanız, Perry burada kelimenin tam anlamıyla şov yapıyor.

Projenin native-libraries.md dokümanına göre Perry, en popüler 30+ NPM paketini native Rust kütüphaneleriyle (crates) eşleştiriyor! Siz TypeScript kodunuzda normal bir şekilde NPM paketi import ettiğinizde, Perry bunu Compile-Time Plugin mantığıyla derler; yani arka planda Node.js modülünü çalıştırmak yerine onun yüksek performanslı Rust karşılığını doğrudan makine koduna gömüyor (Sıfır çalışma zamanı eklentisi yükü, sıfır IPC sınırı):

• Veritabanı: mysql2, pg, mongodb, better-sqlite3, ioredis gibi popüler sürücüler, arka planda C/Rust sistemlerini kullanır.
• Güvenlik: bcrypt, argon2, jsonwebtoken ve crypto işlemleri anında yerel hızda işlenir.
• HTTP/Ağ: http, https, axios, node-fetch, ws ve nodemailer kullandığınızda, Rust’ın meşhur reqwest ve tungstenite sandıkları devreye girer.
• Veri & Araçlar: cheerio (Rust scraper), sharp, zlib, lodash, dayjs, uuid, dotenv, validator gibi onlarca paket tamamen native çalışır.

Ek olarak Perry, perry-stdlib ile fs, path, crypto, os ve child_process gibi çekirdek Node.js API’lerini de sıfırdan native olarak barındırıyor. Tüm bunlar size uygulamanın açıldığı anda ~0 ms başlangıç süresi (startup time) olarak geri dönüyor.

V8’den Vazgeçemeyenlere Özel: Opsiyonel V8 Motoru Desteği

Eğer yazdığınız uygulamanın içinde sadece saf JavaScript ile çalışan ve henüz native karşılığı olmayan spesifik bir NPM paketi kullanmanız şartsa, Perry sizi yine de yarı yolda bırakmıyor. Derleme anında --enable-js-runtime bayrağını eklerseniz, Perry uygulamanızın içine gizli bir V8 motoru gömüyor. Bu durumda binary boyutunuz standart 2-5 MB seviyelerinden 15-20 MB seviyelerine çıkıyor, ancak saf JavaScript NPM ekosisteminin devasa uyumluluğuna anında sahip oluyorsunuz.

Gerçek Dünya Testi: Hono, tRPC ve Strapi 🚀

Bu anlattıklarımız teorik değil. Perry’nin resmi bloglarında duyurulduğu üzere; Hono, tRPC ve devasa Strapi framework’leri şu anda Perry ile sorunsuz derlenebiliyor. Perry, bu framework’leri oluşturan yüzlerce modülü alıyor, birbirine bağlıyor (link) ve 1 saniyenin altında derleyerek 2 MB’ın altında tek bir yerel ARM64 çalıştırılabilir dosyasına (executable) inlining (gömme) yapıyor. Node.js’te devasa çalışma zamanı (runtime) yükü yaratan mimariler, Perry’nin makine kodunda “sıfır maliyetli” (zero-cost) bir bileşime dönüşüyor.

Perry ile Geliştirilmiş Gerçek Dünya Uygulamaları (Showcase)

Perry sadece “hello world” testlerinde değil, gerçek hayattaki kompleks projelerde de rüştünü ispatlamıştır. İşte ana sayfada sergilenen ve Perry ile baştan sona TypeScript kullanılarak inşa edilen bazı muazzam ürünler:

• Mango: Anında (1 saniyenin altında) açılan, native MongoDB veritabanı yönetim aracı. Sadece ~7 MB binary boyutuna sahip ve 100 MB’dan daha az RAM tüketiyor (macOS, Windows, Linux, iOS, Android).
• Hone: Native, yapay zeka (AI-first) destekli kod editörü. Yerleşik terminal, Git entegrasyonu ve LSP (Language Server) desteği barındırıyor. Salise altında (sub-second) açılış, <50 MB binary boyutu ve <100 MB bellek tüketimi sunuyor (Tüm platformlar ve Web).
• dB Meter: 60fps güncellemeler ve canlı ses dalgası animasyonlarıyla çalışan native desibel/ses seviyesi ölçüm uygulaması (iOS, macOS, Android).
• Pry: Perry ekibi tarafından referans olarak geliştirilmiş native JSON görüntüleyici. Ağaç navigasyonu (tree navigation) ve hızlı aramayı WebView veya Electron olmadan doğrudan işletim sisteminin yerel arayüzüyle sunar.
• Perry Demo: Perry, Node.js ve Bun arasında canlı hız ve boyut karşılaştırması yapabileceğiniz interaktif test platformu.
• Perry Starter: Perry projelerine hızlıca başlamak için hazırlanmış minimal proje şablonu.

Peki Neler Eksik? (Bilinçli Kısıtlamalar)

Perry bir sihirbaz değil, kuralları olan bir derleyici. AOT (Ahead-Of-Time) derlemenin doğası gereği, çalışma zamanında kodu yorumlamayı veya çalışma zamanı bellek ağacını dinamik değiştirmeyi gerektiren bazı özellikler bilinçli olarak desteklenmiyor (typescript-parity-gaps.md):

• eval() veya new Function() desteklenmez.
• Proxy ve Reflect API’leri, CPU’daki her özellik erişimine devasa bir “trap” (tuzak) maliyeti bindireceği için kasıtlı olarak atlanmıştır.
• Dinamik import() çağrıları ve karmaşık prototip zincirleri (prototype chains) yerine düz hafıza dizilimleri tercih edilmiştir.
• Dinamik Metot Atamaları (Dynamic property assignment on this): this[methodName] = function() gibi çalışma zamanında hesaplanan (computed) fonksiyon atamaları henüz tam desteklenmemektedir (Örn: Hono’daki route kayıt işlemlerinin dinamik basılması). Bu “eksiklikler” aslında Perry’nin C++ ve Zig ile aynı hızda çalışabilmesinin birincil nedenleridir.

10. Büyüyen Bir Ekosistem: Veritabanı, Push Bildirimleri ve React 🌐

Perry sadece bir derleyici olmaktan çıkıp tam teşekküllü bir ekosisteme dönüşüyor. Projenin kaynak kodlarındaki en son geliştirmeler şunları içeriyor:

• perry-prisma, perry-sqlite, perry-postgres: Prisma ORM API’si ile birebir uyumlu, ancak arkada Node.js yerine Rust’ın yüksek performanslı sqlx kütüphanesini kullanan ve FFI sınırında (boundary) sıfır maliyetle çalışan native veritabanı sürücüleri.
• perry-push (Universal Push Notifications): APNs (iOS/macOS), FCM (Android), Web Push ve WNS (Windows) platformlarının tamamına native olarak, tek bir kütüphane üzerinden anlık bildirim gönderme yeteneği. Şifreleme işlemleri için devasa OpenSSL paketleri yerine Rust’ın minimal ring sandığı (crate) kullanılır.
• perry-verify: Derlenen uygulamayı ayağa kaldıran, otomatize edilmiş yerleşik test sistemi (App Verification). Uygulamanızı test eder, platform bağımsız şekilde UI olaylarını tetikler ve deterministik olmayan senaryolarda Claude AI entegrasyonuyla görsel doğrulama yapar.
• perry-react: React geliştiricileri için JSX ve useState gibi Hook’ları destekleyen, ancak arka planda sanal DOM (Virtual DOM) oluşturmak yerine bileşenleri doğrudan yerel işletim sistemi arayüzlerine (AppKit, UIKit, Win32 vs.) bağlayan devrimsel bir uyumluluk katmanı.

11. Sınırsız Platform Özgürlüğü: 10 Farklı Hedef 🌍

Masaüstünde Native UI yeteneklerinden bahsetmiştik. Ancak Perry’nin vizyonunun sadece masaüstüyle sınırlı olmadığını görüyoruz. Perry kodlarınızı:

• macOS (x86_64, aarch64)
• Windows
• Linux (Ubuntu/GTK4)
• iOS ve iPadOS
• Android
• watchOS ve tvOS
• Web (WebAssembly) ve Web/JavaScript

hedef platformlarına tek satır komutla, çapraz derleme (cross-compile) yaparak taşıyabilirsiniz. Hatta sadece bir Linux makinesi üzerinden (örneğin Ubuntu yüklü bir CI/CD sunucusunda) doğrudan Windows, macOS ve iOS uygulamalarınızı derleyebilirsiniz (lld-link ve ld64.lld destekleri sayesinde Mac cihazına ihtiyaç duymadan).

12. Uzun Lafa Kısası: Nasıl Başlıyoruz?

Bütün bu “V8’siz native TypeScript” dünyasını denemek için sisteminize hiçbir şey kurmanıza gerek yok. Geliştirme deneyimi inanılmaz kolaylaştırılmıştır. Sadece terminalinizi açın ve şunu yazın (9 farklı platforma derleyebilirsiniz):

npx perry build src/main.ts -o app
./app

İşte bu kadar! app dosyanız artık ne Node.js ne de başka bir bağımlılığa ihtiyaç duyan, doğrudan C/C++ programı gibi çalışan bir makine kodu.

Sonuç olarak Perry; JavaScript dünyasının esnekliğini ve kolaylığını alıp, Rust’ın sistem programlama gücü ve LLVM’in donanım optimizasyonlarıyla harmanlayan muazzam bir mühendislik harikasıdır. Electron’un ve ağır JavaScript çalışma zamanlarının “tembelliğini” geride bırakıp, saniyenin binde birinde açılan gerçek native uygulamalar yazmak istiyorsanız, Perry geleceğin ta kendisidir.

Daha fazla zaman kaybetmeden projeyi ve kaputun altındaki kaynak kodlarını bizzat incelemek için Perry GitHub Repository’sine göz atabilirsiniz! 🌟