TypeScript 7 and the Go-Native Compiler: Faster Builds and What Changed

TypeScript 7.0 shipped on July 8, 2026, with the compiler and language service rewritten in Go and compiled to a native binary. The command is still tsc, the package is still typescript, and the language is the same. The differences are speed, a new set of defaults, removed legacy options, and a missing JavaScript API that affects some of your tooling.

Quick Takeaways

• Speed: Full builds run roughly 8x to 12x faster than TypeScript 6 on real open-source projects. Editor startup drops from seconds to near-instant.
• Compatibility: The Go code is a port of the existing checker, not a redesign. Code that compiles cleanly on TypeScript 6 should produce the same results.
• Breaking changes: Options deprecated in 6.0 are now errors (target: es5, moduleResolution: node10, baseUrl, outFile). Defaults changed for strict, types, rootDir, and others.
• Tooling gap: TypeScript 7.0 has no stable programmatic API. Tools such as typescript-eslint and ts-node need a TypeScript 6 alias until 7.1.

Why Microsoft Rewrote the Compiler in Go

Through version 6, the TypeScript compiler was written in TypeScript and executed as JavaScript on Node.js. Large codebases paid for that design with slow builds, slow editor startup, and high memory use. A JavaScript runtime also limits how well a compiler can share data across threads.

Anders Hejlsberg announced the native port in March 2025 under the title “A 10x Faster TypeScript”. The new codebase went by the codename Corsa, and the old JavaScript one became Strada. Three design choices explain the result:

1. Native code. The compiler runs as a compiled binary with no JIT warm-up.
2. Shared-memory parallelism. Parsing, binding, checking, and emitting can run on multiple cores.
3. A faithful port. The team translated the existing checker method by method instead of designing a new one.

Go was the pragmatic fit. It offers native code, a garbage collector, and straightforward concurrency. A type checker is full of cyclic object graphs, and a garbage-collected language let the team keep the original structure. A borrow-checked language would have forced a redesign of those structures and put bug-for-bug compatibility at risk.

TypeScript 6.0, released in March 2026, was the last version built on the JavaScript codebase. It deprecated everything 7.0 would remove, so it works as a migration bridge.

How Much Faster TypeScript 7 Actually Is

Published full-build numbers from the 7.0 release, using the default of four checker workers:

Raising the worker count pushes this further at the cost of memory. With --checkers 8, the VS Code build dropped to 7.51 s and tldraw to 1.06 s.

The editor improved just as much. In the VS Code codebase, the wait from opening the editor to the first error appearing in a file fell from about 17.5 seconds to under 1.3 seconds.

Benchmark your own project before and after the upgrade. Gains vary with project size, core count, and how much time you spend in type-checking versus emit.

# Measure a clean full type-check. Run each command three times and compare.
# --noEmit isolates checking cost from file-writing cost.
time npx tsc --noEmit

# Compare worker counts on your own hardware.
time npx tsc --noEmit --checkers 2
time npx tsc --noEmit --checkers 8

The first command gives you a baseline wall-clock time. The other two show whether extra workers pay off on your machine. On small CI runners, fewer workers often win because memory becomes the constraint.

What Stays the Same

The 7.0 release leaves these things untouched:

• Install and invocation. Run npm install --save-dev typescript and call npx tsc. npm selects a prebuilt platform binary through optional dependencies such as @typescript/typescript-linux-x64.
• Syntax and type system. There are no new language features to learn for this release.
• Error codes and messages. The checker logic is structurally identical to TypeScript 6.0.
• Output parity. The release notes say that code compiling cleanly on 6.0, with stableTypeOrdering enabled and no ignoreDeprecations setting, should compile identically on 7.0.

New Defaults in TypeScript 7

TypeScript 6.0 introduced these defaults and 7.0 keeps them. They only affect options your tsconfig.json leaves unset.

The types: [] change causes the most surprise. A project that relied on global Node typings will suddenly lose process and Buffer.

{
  "compilerOptions": {
    // Opt back in to the globals you actually use.
    "types": ["node"],
    // Point rootDir at your source folder so outDir mirrors it correctly.
    "rootDir": "./src",
    "outDir": "./dist"
  }
}

Setting "types": ["*"] restores the old load-everything behavior. Prefer the explicit list: it speeds up checking and stops unrelated typings from leaking into your program.

Removed Options and Syntax

Every option TypeScript 6 deprecated is now a hard error.

The compiler tells you exactly what to delete:

error TS5102: Option 'baseUrl' has been removed. Please remove it from your configuration.
error TS5108: Option 'moduleResolution=node10' has been removed. Please remove it from your configuration.

Two syntax forms also stop compiling. The first is the module keyword for namespaces:

// Removed: "module" as a namespace keyword.
module Shapes {
  export const sides = 4;
}

// Fixed: use "namespace".
namespace Shapes {
  export const sides = 4;
}

console.log(Shapes.sides); // 4

The old form fails with TS1540. The fixed version compiles and prints 4. Ambient declarations like declare module "foo" are unaffected.

The second is the legacy import assertion syntax:

// Removed: assert-style import attributes.
import data from "./data.json" assert { type: "json" };

// Fixed: use "with".
import data from "./data.json" with { type: "json" };

console.log(Object.keys(data));

Two smaller behavior changes are worth knowing. Running tsc file.ts in a folder that contains a tsconfig.json now stops with TS5112 instead of silently ignoring the config; run plain tsc or pass --ignoreConfig. In JSDoc-checked JavaScript files, @enum is no longer recognized, and a value used in a type position needs typeof.

A Type-Level Change: Template Literal Splitting

JavaScript strings are UTF-16, so an emoji occupies two code units. TypeScript 6 split template literal types by code unit. TypeScript 7 splits by code point.

type HeadTail<S> = S extends `${infer Head}${infer Tail}` ? [Head, Tail] : never;

type Result = HeadTail<"😀abc">;
// TypeScript 7: ["😀", "abc"]
// TypeScript 6: ["\ud83d", "\ude00abc"]

The new result matches what [...text] does at runtime, so string-parsing utility types that handle emoji or other astral characters now behave the way you would expect. If you wrote workarounds for the old split, remove them.

Tools That Still Need TypeScript 6

TypeScript 7.0 does not ship a stable JavaScript API. require("typescript") exposes only version and versionMajorMinor. Functions like createProgram and the language service entry points are absent. The typescript/unstable/* paths are experimental and not a replacement. The team expects a new, different API in TypeScript 7.1.

Anything that imports the compiler as a library is affected:

• typescript-eslint type-aware rules
• Vue, Svelte, Astro, and MDX language tooling
• Angular template type checking
• ts-node, which crashes on startup under TypeScript 7

The fix is the @typescript/typescript6 compatibility package, which installs TypeScript 6 with the full API and a tsc6 binary. Use npm aliases to run both versions side by side.

{
  "devDependencies": {
    "@typescript/native": "npm:typescript@^7.0.2",
    "typescript": "npm:@typescript/typescript6@^6.0.2"
  }
}

After npm install, the two versions coexist:

$ npx tsc --version
Version 7.0.2
$ npx tsc6 --version
Version 6.0.3

Tools that import "typescript" receive version 6 and keep working. Your build scripts call the native tsc for speed. Skip this setup if none of the tools above are in your project.

New Command-Line Flags for Parallelism

The native compiler parallelizes parsing, checking, and emitting. Three flags control it, and the release notes label --checkers and --builders as experimental.

# CI on a small runner: cap memory by limiting concurrency.
npx tsc --build --checkers 2 --builders 2

# Local monorepo build on a many-core workstation.
npx tsc --build --checkers 6 --builders 4

# Reproduce a flaky error deterministically.
npx tsc --noEmit --singleThreaded

The first command keeps peak memory low on a constrained container. The second uses spare cores on a developer machine. The third removes concurrency as a variable when you are chasing a bug. Remember that --builders multiplies the checker count, so large values on both flags can exhaust RAM.

Watch mode was also rebuilt, on a Go port of the file watcher from the Parcel bundler.

Editor Support

• VS Code: The TypeScript team publishes a dedicated TypeScript 7 extension. Once installed, it becomes the default. The command “Disable TypeScript 7 Language Server” switches back to version 6.
• Visual Studio: The latest release enables TypeScript 7 automatically based on the workspace.
• Other editors: Neovim, Zed, Sublime Text, and Emacs connect through the Language Server Protocol.
• Framework files: Projects with Vue, Svelte, Astro, or MDX files keep TypeScript 6 editor support until the new API lands. An Angular project can still run TypeScript 7’s tsc for fast whole-project checks.

Bad Config vs. Good Config

Here is a typical legacy tsconfig.json that fails on TypeScript 7:

// ANTI-PATTERN: every line below breaks or hides a problem on TypeScript 7.
{
  "compilerOptions": {
    "target": "es5",                 // removed
    "downlevelIteration": true,      // removed with es5
    "module": "amd",                 // removed
    "moduleResolution": "node",      // removed (node10)
    "baseUrl": "./src",              // removed
    "outFile": "./dist/bundle.js",   // removed
    "ignoreDeprecations": "6.0"      // hides every warning above on TS 6
  }
}

This configuration silenced warnings with ignoreDeprecations for months. TypeScript 7 refuses to compile it. Here is the refactored version:

// GOOD: modern, explicit, and valid on TypeScript 7.
{
  "compilerOptions": {
    "target": "es2022",              // pick what your runtime supports
    "module": "esnext",
    "moduleResolution": "bundler",   // use "nodenext" for Node ESM libraries
    "strict": true,
    "rootDir": "./src",
    "outDir": "./dist",
    "types": ["node"],               // explicit globals only
    "paths": {
      "@app/*": ["./src/*"]          // relative to this file; no baseUrl needed
    }
  },
  "include": ["src"]
}

The new file sets every important option explicitly, so future default changes cannot surprise you. Bundling moves to a dedicated tool, and path aliases resolve relative to the config file itself.

How to Upgrade to TypeScript 7

1. Move to TypeScript 6 first if you are on 5.x: npm install --save-dev typescript@6.
2. Fix every deprecation instead of suppressing it with ignoreDeprecations.
3. Enable "stableTypeOrdering": true under 6.x and resolve any changes it exposes. This is the configuration the team says compiles identically on 7.
4. Set options whose defaults changed (types, rootDir) if you depended on the old behavior.
5. Install TypeScript 7: npm install --save-dev typescript@latest.
6. Audit your tooling. If typescript-eslint, ts-node, or a framework template checker is present, add the TypeScript 6 alias shown earlier.
7. Verify the version with npx tsc --version, and confirm CI installs from the updated lockfile.

What Happened to tsgo

Before release, the native compiler shipped as @typescript/native-preview with a binary called tsgo, so you could run it beside the JavaScript tsc. Articles from 2025 and early 2026 use that name. In 7.0, the native compiler is simply tsc in the standard typescript package. Nightly builds publish under typescript@next, which now tracks 7.1 development. The typescript-go repository is being merged back into the main TypeScript repository to restore a single issue tracker.

Frequently Asked Questions

What is TypeScript 7?

TypeScript 7 is the first release of the TypeScript compiler rewritten in Go and compiled to a native binary instead of running as JavaScript on Node.js. It checks the same language with the same tsc command. Full builds run about 8x to 12x faster than TypeScript 6. It was released on July 8, 2026.

Do I need to change my code to use TypeScript 7?

Usually you change configuration, not code. TypeScript 7 removes options that 6.0 deprecated and changes defaults such as strict: true and types: []. Code that compiles cleanly on TypeScript 6.0 with stableTypeOrdering on and no ignoreDeprecations should compile identically on 7.0.

Does typescript-eslint work with TypeScript 7?

Not directly. TypeScript 7.0 ships no stable JavaScript API, and typescript-eslint, ts-node, and several framework template checkers depend on it. Keep TypeScript 6 installed through the @typescript/typescript6 alias for those tools, and use TypeScript 7’s tsc for builds. A new API is expected in TypeScript 7.1.

What happened to tsgo?

tsgo was the command name of the native compiler’s preview builds, published as @typescript/native-preview. After the 7.0 release, the native compiler is tsc in the typescript package, and nightly builds come from typescript@next.