Can TypeScript Produce Standalone Native Binaries? A Deep Dive into scriptc and Perry

If TypeScript could compile directly to a native binary like Go or Rust, would you use it? Vercel Labs recently open‑sourced scriptc, which turns a simple fib.ts into an approximately 178 KB standalone executable with a reported startup time of around 2 ms.

What scriptc actually does

scriptc

is not a bundler like pkg or Node.js SEA that merely packages JavaScript together with a runtime. Traditional single‑file packagers embed the JavaScript engine, whereas scriptc’s static mode attempts to translate TypeScript code into true machine code, producing a binary that contains no Node.js, V8, or other JavaScript engine.

The compilation chain is straightforward:

Use the official TypeScript compiler for parsing and type checking.

Convert the code into a typed intermediate representation.

Generate machine code via LLVM by default, keeping a C backend as a reference implementation.

Pass the C backend to Clang, which links the final native executable.

The real difficulty lies not in turning number values into instructions but in faithfully reproducing JavaScript semantics: UTF‑16 strings, array/Map/Set ordering and identity, closures, exceptions, async/await, and the event loop. To achieve this, scriptc implements a C runtime and uses differential testing to compare output, error messages, and exit codes between Node.js and the native binary.

When static compilation cannot handle certain npm dependencies or any code, developers may enable --dynamic, which embeds quickjs‑ng into the binary. The project classifies results into three categories:

Static compilation : no JavaScript engine is bundled.

Dynamic execution : an embedded engine handles the parts that cannot be statically compiled.

Compilation rejected : the tool emits specific error codes and suggestions instead of silently producing a broken binary.

Perry arrived earlier

The criticism that scriptc merely copies Perry stems from the fact that Perry’s GitHub repository was created in January 2026, with its first public commit that same month, while scriptc’s npm package appeared on July 13 and its repository went public on July 22, giving Perry roughly a six‑month head start.

Both projects share similar marketing messages: they emphasize direct TypeScript‑to‑native compilation, independence from Node.js and V8, small binary size, low startup latency, and single‑file distribution, and they both aim to fill common Node.js API and npm‑package compatibility gaps.

Code‑level differences

Three major architectural differences stand out:

1. Compiler front‑end : scriptc directly invokes the TypeScript compiler API ( tsc) for parsing, type checking, and type narrowing, then produces its own typed IR. Perry’s core is written in Rust, uses SWC for parsing, and maintains its own type system, HIR, and transformation pipeline.

2. Runtime strategy : scriptc’s static runtime is implemented in C with reference counting and cycle collection, while its dynamic mode embeds quickjs‑ng. Perry’s runtime is Rust‑based, employing a custom garbage collector, standard library, and many native extensions.

3. Product scope : scriptc is positioned as an experiment targeting CLI and server‑side programs, focusing on Node.js behavior fidelity, static coverage, and diagnosability. Perry targets a broader range—including desktop, mobile, watch, TV, WebAssembly, and native UI components—showing a clearly larger ambition.

Both follow the classic native compiler stages of parsing, type representation, lowering, code generation, and linking, and both rely on LLVM. However, similarity in overall architecture does not constitute plagiarism without concrete code‑similarity evidence.

Current status and outlook

At the time of writing scriptc is at version 0.0.x and officially supports macOS arm64 as its primary platform. Perry, while covering more platforms, is still far from full Node.js ecosystem compatibility.

The broader significance is that scriptc, backed by Vercel Labs, brings the niche idea of native TypeScript compilation into the spotlight, encouraging more developers to explore this direction. Perry deserves recognition as the earlier effort, and scriptc should be evaluated on its own technical merits. Claims of outright copying remain unsubstantiated until concrete evidence of code reuse or license violation emerges.

Ultimately, the success of native TypeScript compilation will depend on real‑world projects, long‑term maintenance, and thorough compatibility testing.