Vercel's Scriptc compiles TypeScript to native binaries without Node or V8

Why it matters

Scriptc gives TypeScript developers a credible path toward tiny native CLIs and services, while exposing exactly where JavaScript's dynamic behavior still requires a runtime.

Vercel, founded and led by Guillermo Rauch, has surfaced Scriptc, an open-source compiler that turns ordinary TypeScript into native executables without bundling Node.js, V8 or another JavaScript engine into binaries produced through its default static path. The Apache-2.0 project reached version 0.0.17 on July 27, one of several releases cut during a burst of development over the past four days. (github.com)

The release trail shows Chris Tate as an active Scriptc committer, though the supplied sources do not establish that he founded or formally leads the project. Tate's commits appear across recent Scriptc activity, with work touching native foreign-function calls, Windows cross-compilation, Node compatibility tests and the rules governing npm packages that cannot compile statically. (github.com)

Scriptc extends a bet Rauch has pursued since before Vercel carried its current name. He created Mongoose, the object-modeling library for MongoDB, and built Vercel around giving ordinary developers infrastructure once reserved for large technology companies. Vercel began as ZEIT, focused on simplifying deployment, then expanded across frameworks, build systems, AI tooling and managed compute. Scriptc pushes that thesis below deployment and into the executable itself: TypeScript developers should be able to keep their language while shedding much of the runtime weight traditionally attached to it. (vercel.com)

A compiler that makes dynamic behavior explicit

Scriptc's central design choice is a three-tier execution model. Supported TypeScript is compiled into native code. Code that depends on shipped JavaScript from npm packages or values typed as any can run through an embedded QuickJS engine when the developer explicitly enables --dynamic. Unsupported constructs fail compilation with a numbered diagnostic and, in many cases, a suggested rewrite. (scriptc.dev)

That qualification matters. The headline claim that Scriptc produces binaries with no JavaScript engine applies to its static tier. A build using --dynamic carries an embedded engine, and Scriptc's materials put dynamic-mode binaries around 3 MB rather than the smaller static range. The compiler includes a coverage command that reports which statements compile statically, which require dynamic execution and which block the build.

This static-or-refuse posture gives Scriptc a sharper boundary than conventional JavaScript packaging tools. Bun's standalone executable feature bundles the Bun runtime with imported files and packages. Deno compile embeds an application into denort, a stripped Deno runtime. Node's single executable applications inject a prepared application blob into a Node binary. Those systems prioritize compatibility by carrying a runtime. Scriptc tries to prove that each supported construct can become native code, then refuses the rest unless the developer opts into QuickJS. (docs.deno.com)

Porffor is a closer technical comparison. It also compiles JavaScript and TypeScript ahead of time into WebAssembly or native binaries without packaging a full runtime. Scriptc is making a distinct compatibility promise around ordinary TypeScript, the official TypeScript checker and selected Node APIs, including file access, networking, HTTP, TLS, child processes and buffers. The project presents that surface as suitable for command-line programs and small services. (porffor.dev)

The benchmarks remain Scriptc's claims

Scriptc says it runs more than 800 differential tests, executing each corpus program under Node and as a native binary before comparing standard output, errors and exit codes. The repository also describes an AddressSanitizer test lane intended to catch memory errors and leaks. Those safeguards are stronger than a demo benchmark, but they remain tests designed and reported by Scriptc's maintainers. (github.com)

The performance figures should be read carefully. Scriptc's materials describe static binaries of about 170 KB to 200 KB, startup around 2 to 4 milliseconds, typical memory usage of 1 MB to 4 MB, and dynamic-mode binaries around 3 MB. Those are maintainer figures; the supplied pages do not provide enough methodology to treat them as independent benchmarks. (github.com)

Scriptc's timing fits a wider move toward native tooling inside the TypeScript market. Microsoft released TypeScript 7.0 on July 8 as a native Go port, reporting full-build speedups of 8x to 12x. Microsoft's work accelerates the compiler and language services while preserving JavaScript as TypeScript's normal output. Scriptc takes the next step and attempts to make the application native too. (devblogs.microsoft.com)

Vercel moves further down the stack

Vercel can fund that experiment without forcing an immediate commercial model. In September 2025, Vercel raised a $300 million Series F at a $9.3 billion post-money valuation, co-led by Accel and GIC. Scriptc is available as an Apache-2.0 licensed Vercel Labs repository. (vercel.com)

The direction still matches Vercel's expansion from frontend deployment into the infrastructure surrounding software creation and execution. Scriptc approaches the stack from the other end, offering developers a way to produce small, portable executables from the language already common across Vercel's products and customer base.

The project's hardest task will be maintaining the boundary it has drawn. JavaScript earns much of its usefulness from dynamic behavior, npm compatibility and runtime reflection. Each unsupported feature creates pressure either to expand Scriptc's native lowering or send more code through QuickJS, weakening the small-binary proposition. The compiler's refusal codes and coverage reports make that trade visible. Whether developers accept those constraints will determine if Scriptc becomes a practical tool for TypeScript CLIs and services or remains an ambitious demonstration of how much JavaScript can be compiled away.