Perry vs Deno
Deno is a modern JavaScript and TypeScript runtime built on V8, with first-class TypeScript support, a permissions-based security model, and a `deno compile` command that produces a single executable by bundling V8 with your application. Perry compiles TypeScript directly to native machine code — no V8 in the output, no runtime layer, just a small native binary.
What is Deno?
Deno is a TypeScript and JavaScript runtime built in Rust on top of V8 and Tokio. It executes `.ts` source directly, has built-in tooling (formatter, linter, test runner, language server), and uses a permissions model that requires explicit grants for network, file, and environment access. `deno compile` produces a self-contained executable by bundling the Deno runtime (which includes V8) with your code. Deno targets Linux, macOS, and Windows on x64 and arm64.
What is Perry?
Perry is a native TypeScript compiler written in Rust. It compiles TypeScript directly to native machine code via LLVM — no V8, no JIT, no runtime. The output is a single binary, typically a few hundred KB to a few MB for native code, optionally larger if you opt into the embedded V8 runtime for npm packages that need a JS engine.
Side by side
| Feature | Perry | Deno |
|---|---|---|
| Output | Native machine code (LLVM) | Your code + Deno runtime (V8) bundled |
| JavaScript engine in binary | None by default; optional V8 | V8, always |
| Hello-world binary size | ~330 KB | ~80–100 MB (includes V8) |
| JIT | No (AOT compiled) | Yes (V8 TurboFan) |
| Mobile targets | iOS, iPadOS, Android | No |
| Watch / TV / WASM / Web | watchOS, tvOS, Wear OS, WASM, Web/JS | No |
| Native UI | 25+ widgets via native platform APIs | No |
| Permissions model | Standard OS process permissions | Granular runtime permissions (--allow-net, --allow-read, etc.) |
| Stability | Pre-1.0 | Stable (1.x / 2.x) |
| Built in | Rust | Rust (on V8) |
Where Perry wins
- +Dramatically smaller binaries. A Perry hello world is ~330 KB. `deno compile` outputs include V8 and land in the 80–100 MB range.
- +No JavaScript engine in the binary. Your TypeScript is compiled to native machine code, not interpreted by V8 at runtime.
- +Mobile, watch, TV, WASM, and Web targets. Deno is server/desktop only.
- +Native UI widgets that map to AppKit, UIKit, GTK4, Win32, and JNI — no equivalent in Deno.
- +Faster cold start. AOT-compiled native binaries don't pay V8 startup cost.
- +Compute microbench leadership in matched conditions on M1 Max where Perry's `reassoc contract` fast-math defaults let LLVM autovectorize and fold trivially-foldable accumulators (e.g., loop_overhead 12 ms, math_intensive 14 ms; see perry/benchmarks).
Where Deno wins
- +Mature, stable runtime with a long track record and active 2.x line.
- +Granular permissions model. Deno requires explicit `--allow-net`, `--allow-read`, etc. — useful for sandboxed scripts and untrusted code.
- +Built-in tooling: formatter, linter, test runner, doc generator, LSP, all in the runtime.
- +Full V8 ecosystem at runtime — anything that runs on V8 runs on Deno, including JIT optimizations on long-running hot paths.
- +First-class TypeScript without a separate compiler step in development, with a fully managed type-checking pipeline.
- +Standardized web-platform APIs (fetch, Web Streams, Web Crypto) implemented natively in the runtime.
When to choose Perry
Choose Perry if you want a small, fast-starting native binary, you're shipping to mobile or other non-server targets, you want native UI, or you want to compile TypeScript to a binary that doesn't contain a JS engine.
When to choose Deno
Choose Deno if you want a stable, batteries-included TypeScript runtime, you value the permissions sandbox, you're building server-side or scripting workloads, or you need full V8 ecosystem compatibility at runtime.
Verdict
Both let you ship a TypeScript program as a single binary; the difference is what's inside that binary. Deno gives you V8 + a curated runtime + permission sandbox. Perry gives you native machine code with no engine. Deno is the better choice for server-side and scripting work where the ecosystem and permissions model matter. Perry is the better choice when you need a small, fast-starting binary, mobile targets, or native UI.