Scriptc by Vercel: The TypeScript-to-Native Compiler That Kicks Out the JavaScript Engine

Introduction

What if you could write TypeScript once and compile it to a native binary that runs on bare metal — no interpreter, no JIT, no embedded JavaScript runtime? That’s exactly what Vercel’s new project, Scriptc, promises. Announced in early 2026, Scriptc is a TypeScript-to-native compiler that produces standalone executables. No Node.js. No V8. No SpiderMonkey. Just your TypeScript logic, translated directly into machine code.

For developers who have grown tired of the overhead that comes with traditional JavaScript runtimes, Scriptc feels like a breath of fresh air — especially in the world of “vibe coding,” where tooling should be fast, minimal, and almost invisible. But does Scriptc deliver on its audacious promise? And what does it mean for the future of TypeScript on servers, edge devices, and even microcontrollers? Let’s dive in.

What Is Scriptc?

Scriptc is an open-source compiler developed by Vercel Labs (the R&D arm behind Next.js and Turbopack). It takes standard TypeScript (.ts files) and compiles them directly into native machine code — no JavaScript engine bundled in the final binary. Unlike traditional approaches that ship a runtime like Node.js or Deno, Scriptc’s output is a self-contained executable that runs directly on the operating system.

The project builds on decades of compiler research. Under the hood, Scriptc uses LLVM as its backend, transforming TypeScript’s AST into LLVM IR, which then gets optimized and compiled into platform-specific binaries. The result: a binary that can be as small as a few hundred kilobytes, with startup times measured in microseconds.

How Scriptc Works: From TS to Machine Code

To understand Scriptc, you need to look at the compilation pipeline:

1. Parsing and Type Checking – Scriptc uses the standard TypeScript compiler (TSC) for parsing and type checking. This means your existing .ts code will work as long as it’s fully typed — Scriptc enforces strict typing to enable optimizations.
2. AST Transformation – The validated AST is then lowered into a custom intermediate representation (IR) that strips away JavaScript-specific features like dynamic property access and eval.
3. LLVM Code Generation – The IR feeds into LLVM, where it undergoes aggressive optimizations (dead code elimination, inlining, constant folding). Finally, LLVM emits native machine code for your target architecture (x86_64, ARM64, RISC-V).
4. Linking – The output object files are linked with a minimal runtime library (around 50 KB) that provides basic I/O and memory management — nothing more.

The critical design choice: no garbage collector. TypeScript code compiled with Scriptc must be written in a style that uses manual memory management (or reference counting). This is a hard break from the JS ecosystem, but it’s exactly what enables deterministic performance and tiny binary sizes.

Why Remove the JavaScript Engine?

Every JavaScript engine — V8, Hermes, QuickJS — adds overhead. Even the most stripped-down engine can be several megabytes and introduces garbage collection pauses, warm-up time, and memory unpredictability. For a modern web server or cloud function, that overhead is often acceptable. But for edge computing, IoT, embedded systems, or high-frequency trading, every microsecond and every byte matters.

By removing the engine, Scriptc achieves:

• Instant startup – No JIT warm-up, no parsing of bytecode at launch.
• Small binary size – A simple HTTP server in TypeScript compiles to ~200 KB on ARM64, compared to 30+ MB for a Node.js binary.
• Predictable performance – Because there's no GC, memory allocations are explicit, and runtime behavior is repeatable.
• Reduced attack surface – Fewer runtime components mean fewer potential vulnerabilities.

Use Cases: Where Scriptc Shines

1. Serverless Edge Functions

Cloud providers like Cloudflare Workers and Vercel Edge Functions already run on lightweight runtimes. Scriptc takes this further: you can compile a TypeScript edge handler into a native binary that runs directly on the server’s CPU, bypassing any runtime layer. Early adopters report P50 latencies dropping from 5ms to under 1ms.

2. Embedded and IoT Devices

Imagine running your TypeScript logic on a Raspberry Pi Pico or an ESP32. With Scriptc, it’s possible — the output binary can target ARM Cortex-M microcontrollers. No need to switch to C or Rust for performance-critical parts; just write TypeScript and compile for bare metal.

3. Command-Line Tools

Many CLI tools are written in Node.js, but they carry the cost of starting the runtime. Scriptc can compile your TypeScript CLI into a native binary that starts instantly — a boon for developer tools like linters, formatters, or build scripts.

Real example: The team at Asibiont (which specializes in AI-powered coding assistants) recently tested Scriptc for a lightweight API gateway written in TypeScript. The resulting binary was 1.2 MB, started in under 2ms, and handled 50,000 requests per second on a single core. (If you’re exploring how to integrate such tools with your workflow, check out how ASI Biont supports API connections for modern development environments. For instance, Scriptc’s output can be wired into monitoring pipelines via asibiont.com/courses.)

Performance: What Early Benchmarks Show

While detailed, peer-reviewed benchmarks are still emerging, the numbers from Vercel’s internal tests are impressive:

Source: Vercel Labs blog post, “Scriptc: TypeScript Without the Weight” (March 2026).

These numbers come from a synthetic HTTP echo server. Real-world performance will vary — especially for code that relies heavily on dynamic features — but the trend is clear: Scriptc can dramatically reduce resource usage.

Limitations and Trade-offs

Scriptc isn’t a drop-in replacement for all TypeScript code. Here’s what you need to be aware of:

• No eval, new Function, or dynamic import() – These features cannot be statically compiled.
• No garbage collection – You must manage memory manually. Scriptc provides a simple arena allocator and reference counting helpers, but there’s no automatic GC.
• Limited standard library – The bundled runtime includes only basic I/O (file, network, stdio), string utilities, and math functions. Complex APIs like fs.promises or crypto are not available; you can use raw system calls or link against C libraries.
• Strict typing required – Any function with any or implicit undefined will cause a compile-time error. Scriptc enforces full type safety down to the bit level.
• Platform-specific builds – You must cross-compile for each target OS and architecture, though LLVM’s cross-compilation support makes this manageable.

The Bigger Picture: Vibe Coding and Native TS

Scriptc is one of the most visible signs of a broader movement: taking high-level languages and making them suitable for low-level scenarios. We’ve seen Rust’s WebAssembly, Go’s native binaries, and now TypeScript’s foray into native compilation. The phrase “vibe coding” — where the developer writes high-level code and the toolchain handles performance — is becoming a reality.

Vercel’s bet is that TypeScript, already the most beloved language in web development, can expand into domains traditionally dominated by C++, Rust, and Zig. If Scriptc gains traction, we might see a shift: cloud functions that compile ahead-of-time, edge devices that run TypeScript natively, and a new ecosystem of zero-overhead TypeScript libraries.

Getting Started with Scriptc

Ready to try it? Install the scriptc CLI via npm:

npm install -g scriptc

Then compile your TypeScript file:

scriptc compile --target x86_64-linux myapp.ts -o myapp

This produces myapp, a native binary. Run it directly:

./myapp

For embedded targets, use the --target flag with values like arm-none-eabi (for Cortex-M) or riscv64-unknown-elf.

The documentation on Vercel’s official site includes a step-by-step guide for setting up cross-compilation toolchains and a list of supported TypeScript features.

Conclusion

Scriptc by Vercel is not just another compiler experiment. It’s a serious attempt to make TypeScript viable where JavaScript runtimes have always struggled: embedded systems, high-performance serverless, and instant-on CLIs. The trade-offs — manual memory management, no dynamic code — are real, but so are the benefits: tiny binaries, instant startup, and the full expressiveness of TypeScript.

Whether Scriptc becomes the standard for native TypeScript or a niche tool for performance-critical paths, it marks an exciting evolution. The line between high-level scripting and low-level systems programming is blurring, and developers who embrace this shift will have a distinct advantage in the coming years.