Vercel Labs’ scriptc is an experimental TypeScript compiler with a native output path. The important qualifier is its mode: the default static build contains no Node.js or JavaScript engine, but the optional --dynamic mode can embed QuickJS for code and npm dependencies that cannot compile statically. The compiler itself requires Node.js 24 or newer, even though a static executable does not need Node at runtime.
TL;DR: scriptc uses the TypeScript compiler for parsing and type checking, lowers code to typed IR, and can produce native executables and other compiler artifacts. Static builds omit a JavaScript engine;
--dynamicembeds QuickJS. InfoQ reported a very fast CLI startup in one benchmark, but also lower throughput for a Hono workload that used the dynamic mode.
What Is scriptc, and Who Maintains It?
scriptc comes from Vercel Labs and is explicitly described as experimental. InfoQ’s September 25, 2026 report identifies it as an Apache 2.0-licensed compiler. Its public GitHub repository contains the current README, installation command, supported output forms, and links to the project documentation.
The central idea is to compile TypeScript into native output rather than always running the transpiled JavaScript in a conventional runtime. That description applies most clearly to a fully static build. It does not mean that every scriptc mode is free of a JavaScript engine, or that every TypeScript program compiles without changes.
How Does the Compiler Pipeline Work?
The project says it uses the TypeScript compiler to parse and type-check input. It then lowers the program to typed intermediate representation and supports outputs including readable C, textual LLVM IR, native assembly and object files, native executables, and WebAssembly modules. InfoQ identifies WASI Preview 1 as the WebAssembly target.
This is more specific than saying that scriptc simply “turns TypeScript into machine code.” The compiler classifies program constructs by what it can compile statically, what needs dynamic execution, and what it must reject with a diagnostic. Supported behavior therefore depends on the code and selected mode.
What Is the Difference Between Static and Dynamic Builds?
Static compilation is the default path described by the project. A fully static executable contains a small native runtime but no Node.js or JavaScript engine. This is the scope of the “no JavaScript engine” claim.
The optional --dynamic flag changes that. InfoQ says it embeds QuickJS, about 620 KB, for npm package JavaScript and any-typed code. The executable still does not require Node at runtime, but it does contain a JavaScript engine. Some constructs can instead be rejected with diagnostics if they are unsupported by the selected mode.
That distinction matters when comparing scriptc with Node, Bun, or other runtimes. A static build and a build that embeds QuickJS are not the same execution model, and a general claim that all scriptc binaries omit every engine would be inaccurate. The project’s limitations documentation describes the current boundary.
How Do You Install and Build a Program?
The compiler requires Node.js 24 or newer. The documented global install is:
npm install -g scriptcThe README documents scriptc run hello.ts for running a program and scriptc build hello.ts -o hello for producing an executable. A static output does not need Node to run. Optional build tools depend on the chosen target and output mode, so check the current quickstart before setting up a build environment.
Which Outputs and Platforms Are Listed?
The repository lists typed IR, C, LLVM IR, assembly, object files, native executables, and WebAssembly. InfoQ names macOS, Linux, Windows, and WASI Preview 1 among the project’s targets. These are target claims, not a promise that every source program or API works identically on every platform. The platform-specific requirements and limitations should be checked against the official documentation.
What Do the Benchmarks Actually Show?
InfoQ reported a benchmark of scriptc 0.0.16 against Bun 1.3.12 and Node 24.18.0. Median CLI startup was 1.78 ms for scriptc, 21.29 ms for Bun, and 61.78 ms for Node. For a framework-free node:http server, the article reported 1.9 MiB of idle memory. Those are results for the described workloads, not a universal performance guarantee.
The same article describes a Hono workload that required --dynamic: 62% of the server ran in QuickJS, and measured throughput was 18.4 thousand requests per second, compared with 70.5 thousand for Bun. This is a useful counterweight to the startup result. The headline benefit of a small static binary does not imply that dynamic workloads will always execute faster.
The evidence supports a limited conclusion: scriptc had very short startup and low idle memory in the cited examples, while the dynamic Hono test showed a substantial throughput difference. Teams should measure their own applications and dependencies rather than extrapolating from one benchmark.
Is scriptc a Drop-in Node.js Replacement?
The available sources do not establish scriptc as a drop-in replacement for Node.js. Vercel Labs labels it experimental, and the compiler requires Node.js 24 or newer. Its static build can simplify runtime distribution for programs within its supported subset; --dynamic provides another path by embedding QuickJS. Neither mode proves that an existing Node application will compile or behave the same way without testing.
InfoQ and the repository provide concrete details that a short announcement snippet may omit: Apache 2.0 licensing, installation, Node version, output formats, targets, benchmark data, and the optional dynamic engine. The sources do not promise a release schedule or long-term support commitment, so those should remain open questions rather than be filled in by assumption.
Frequently Asked Questions
Does a scriptc executable need Node.js at runtime?
A fully static executable does not need Node.js to run. The compiler itself requires Node.js 24 or newer. The optional dynamic mode can embed QuickJS, but that is not the same as embedding Node.
Does every scriptc build omit JavaScript engines?
No. Static builds omit a JavaScript engine. With --dynamic, scriptc can embed QuickJS for npm package JavaScript and any-typed code.
What does scriptc compile to?
The repository lists typed IR, readable C, LLVM IR, assembly, object files, native executables, and WebAssembly modules. InfoQ names WASI Preview 1 as the WebAssembly target.
How fast is scriptc?
In the benchmark reported by InfoQ, median CLI startup was 1.78 ms for scriptc, 21.29 ms for Bun, and 61.78 ms for Node. A separate Hono test using QuickJS reported lower throughput than Bun. Neither result should be generalized to workloads that were not tested.
What license and project status does it have?
InfoQ and the public repository identify Apache 2.0 licensing. Vercel Labs labels the project experimental; that is not a guarantee of production support or a release schedule.
Summary
scriptc offers a TypeScript-to-native path, with an important distinction between its modes. A fully static build omits Node and a JavaScript engine, while --dynamic can embed QuickJS. The compiler requires Node.js 24 or newer, and the project lists several output formats and targets.
InfoQ’s benchmark reported a very fast CLI startup in one workload, but also lower throughput in a Hono test using the dynamic mode. The evidence does not support treating scriptc as a universal replacement for Node or assuming every program will compile statically. Check the official repository and limitations documentation, then test the exact code and dependencies that matter.