← Back

TypeScript 7.0 RC dumps JavaScript for Go to run up to 10x faster

Original version ·

The wizards at Microsoft just pulled off the ultimate coding plot twist. They admitted their own language was holding them back and rebuilt the whole engine from scratch using a completely different technology, virtually vaporizing compile-time misery.

The team behind TypeScript 7.0 released a release candidate that completely replaces the old JavaScript-based compiler. Instead of compiling the compiler with the language it compiles, they ported the entire codebase to Go. The goal is pure, unadulterated speed, achieving compatibility with older codebases while making the type-checker run like it's on rocket fuel.

This performance leap comes from native concurrency, allowing the compiler to process files, check types, and generate output in parallel. By default, the compiler now spawns four parallel checking processes, controlled by a new --checkers flag, which developers can scale up if their machines have the memory to survive it. For multi-project setups, a --builders flag handles parallel builds, though combining them carelessly might turn local laptops into expensive space heaters.

The file-watching system tsc --watch has also been completely rewritten on Go, borrowing logic from the Parcel bundler. This change eliminates the heavy C++ build chain and prevents the bottomless pit of node_modules from choking the operating system during local development. For editors, a new VS Code extension called TypeScript Native Preview hooks into this speed via the Language Server Protocol.

However, early adopters should tread carefully because TypeScript 7.0 does not have a stable programmatic API yet. That means third-party linters, bundler plugins, and testing tools will likely break until version 7.1 drops. To prevent immediate infrastructure collapse, Microsoft released a helper package called @typescript/typescript6 so teams can run both versions simultaneously.

Migrating will also trigger stricter defaults, as strict mode is now enabled out of the box, and module defaults to esnext. Legacy options like target: es5 and older module resolution strategies have been entirely deprecated, while types now defaults to an empty array.

The irony of a web-focused language relying on a compiled system language just to run at a tolerable speed is delicious. It highlights a massive, unspoken truth in modern web development: JavaScript is fantastic for writing apps, but absolutely terrible at building the tools that make those apps possible.

Source: Microsoft DevBlogs

Comments

This is where the magic happens: AI reads your discussion and rewrites the article based on the most interesting comments. Each strong comment adds points to the meter below. Once the meter is full, the article updates live — no page reload needed.

16/24
  1. Encrypted Neckbeard
    finally i can stop playing doom while waiting for my build to finish
    +3 funnyAt least your productivity might finally exceed your gaming high score
  2. Serverless Stacktrace
    rewriting js tools in go/rust is the only way this ecosystem survives
    +4 solidA grim realization that the ecosystem is basically a house of cards held together by faster compilers
  3. Sandboxed Kernel
    so the language meant to replace js is now being compiled by go because js is too slow. ironic.
    +7 exceptionalThe irony is so thick you could cut it with a slow JavaScript runtime
  4. Cached Algorithm
    wait so all my custom linter plugins are dead until 7.1? hard pass for now
    +2 emotionalNothing says 'enterprise ready' like breaking your entire workflow for a speed boost you haven't even tested yet