TypeScript 7's Go Port and scriptc Both Cut Node Out of the Build

TypeScript's compiler reached general availability in a new, Go-based form on July 8, 2026. Days apart, a separate Vercel-backed project called scriptc surfaced with a different goal: compiling ordinary TypeScript straight into a native binary that never loads Node at all.

scriptc Compiles TypeScript to a Binary That Never Loads Node

scriptc, hosted at the scriptc project's technical README and described on the scriptc.dev product overview, takes unmodified TypeScript — no new syntax, no annotations — and compiles it to a small, self-contained native executable. There is no dialect to learn: the same code that runs on Node is type-checked by the real TypeScript compiler and lowered to native code.

The project is explicit about where that static compilation stops. It defines three tiers: code compiled statically to native instructions, which is the default and only mode unless a developer opts out; code that runs dynamically through an embedded quickjs-ng JavaScript engine (roughly 620KB) for npm dependencies' shipped JavaScript or for any-typed code, invoked with a --dynamic flag; and code that is rejected outright, with a specific diagnostic and, usually, a suggested rewrite. According to the README, nothing is silently miscompiled — a construct scriptc can't handle statically either falls back to the embedded engine or fails loudly.

The static surface is broad: classes with true dynamic dispatch, closures, generics, discriminated unions, async/await, and exceptions on the language side, plus a large slice of Node's own API surface — fs, path, process, child_process, net, http, https, tls, crypto, and fetch. Correctness is checked by differential testing: more than 800 programs run under both Node and a compiled native binary, with stdout, stderr, and exit codes required to match byte-for-byte, backed by a separate AddressSanitizer and reference-count audit lane for memory safety. Installing scriptc requires clang, and macOS arm64 is the primary target platform, with Linux and Windows builds produced by cross-compilation.

The practical case for scriptc rests on a small set of numbers the README publishes directly, measured on Apple M-series hardware.

These are vendor-published figures from a single README, not an independently reproduced benchmark, and scriptc itself is early — 41 stars on GitHub at the time of writing, with dynamic-mode compatibility for the broader npm ecosystem still the part of the project doing the least static compiling.

TypeScript 7 Takes the Opposite Route: Speed Up the Compiler, Don't Skip It

Where scriptc removes the runtime from the output, TypeScript 7 keeps the same execution model and rebuilds the compiler underneath it. Microsoft's official TypeScript 7.0 GA announcement describes a full port of the compiler and language service — codenamed "Corsa" — from the existing TypeScript-in-TypeScript codebase, internally called "Strada," into Go. Microsoft says the port was done "as faithfully as possible," carrying over the existing structure and logic so that type-checking behavior stays consistent between the two implementations, rather than being a rewrite from a blank page.

The headline number is a typical 8x-to-12x speedup on full builds, which Microsoft attributes to native code execution, shared-memory multithreading, and new optimizations layered on top of the ported logic. The GA release followed a Release Candidate that shipped June 18, 2026, per an analysis of the four separate speedup figures behind Microsoft's benchmark tables — a gap of just under three weeks. That same analysis makes a useful point for anyone about to cite "10x" in a planning document: Microsoft's own tables contain at least four distinct TypeScript-6-to-7 comparisons, scoped to different commands and configurations, and treating them as one number overstates how uniform the gain actually is.

The codebase-level numbers Microsoft published are specific enough to look at directly.

The range across these five projects — 7.7x for tldraw up to 11.9x for VS Code — supports Microsoft's "8x to 12x" framing better than a single flat "10x" would, though all five are Microsoft-selected, Microsoft-run benchmarks rather than independently reproduced numbers.

Memory Falls Too, Though Less Dramatically Than Build Time

Microsoft's tables also report peak memory (RSS) during a full build for the same five codebases, and the pattern is more modest than the time savings: reductions in the high single digits to high twenties, rather than an order of magnitude.

That gap between time and memory gains is consistent with what the port actually changed: Microsoft describes Corsa as structurally the same type-checker as before, moved to a faster execution substrate, not a redesign of how much state a build has to hold in memory at once. The speed comes largely from native execution and parallelism; the memory footprint still reflects the underlying algorithms.

TypeScript 7 also isn't friction-free on day one. Reporting on the day-one framework-template compatibility gap notes that the new API does not yet support template compilation for Vue, Astro, Svelte, or Angular — a real constraint for teams in those ecosystems weighing an immediate upgrade against waiting for a point release.

Native-Toolchain Momentum Isn't Limited to TypeScript

Neither release exists in isolation. This site has covered Bun's decision to rewrite its runtime in Zig and Rust, and separately the current economics of ultra-cheap static hosting — both signs that 2026's JavaScript tooling landscape is being pulled toward native code and away from general-purpose managed runtimes from more than one direction at once.

scriptc and TypeScript 7 sit on opposite ends of that pull. scriptc removes Node and V8 from the output entirely, for the subset of a program that compiles statically, and falls back to an embedded engine only where it must. TypeScript 7 keeps Node as the thing developers still run their application on, but replaces the compiler that checks and builds that code with a native, multithreaded one. Neither is a strict upgrade path for the other — a team adopting scriptc is choosing a narrower, ahead-of-time language subset in exchange for a binary with no runtime dependency at all, while a team adopting TypeScript 7 keeps its full application runtime model and gets a faster build loop on top of it.

What ties the two releases together isn't a shared codebase or a shared team — it's that both landed in mid-2026 pointed at the same bottleneck from different sides, and both come with the same kind of asterisk: scriptc's speed applies to the statically-compilable subset of a program, and TypeScript 7's speed applies to the compiler, not to whatever runtime the resulting JavaScript still executes on.