TypeScript 7: Native Compiler, What Changed, How to Upgrade

TypeScript 7 is the TypeScript compiler rewritten in Go and shipped as a native program. The language is the same, the command is still tsc, and the npm package is still typescript; what changes is speed (full builds about ten times faster), a set of new defaults, and the removal of options that TypeScript 6 deprecated. TypeScript 7.0 was released on July 8, 2026, and the version on npm is 7.0.2.

npm install --save-dev typescript@latest
npx tsc --version

Version 7.0.2

One of the few differences you can see at the type level is how template literal types split strings. JavaScript stores strings as UTF-16 code units, and an emoji such as 😀 takes two of them:

const text = "😀abc";

console.log(text.length);           // 5: UTF-16 code units
console.log([...text].length);      // 4: code points
console.log(text[0] === "\ud83d");  // true: indexing returns half of the emoji
console.log([...text][0] === "😀"); // true: iterating keeps it whole

TypeScript 6 split template literal types by code unit, like text[0]. TypeScript 7 splits them by code point, like [...text], so the emoji stays whole:

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

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

Why TypeScript Was Rewritten in Go

Through version 6, the TypeScript compiler was itself written in TypeScript and ran on Node.js. On large codebases that meant slow builds, slow editor startup and high memory use.

Anders Hejlsberg announced the native port on March 11, 2025, in a post titled "A 10x Faster TypeScript". The new codebase was code-named Corsa, and the JavaScript one Strada. The team ported the existing compiler's code rather than redesigning the type checker, so the new compiler follows the same rules and reports the same errors. TypeScript 6.0 (March 2026) was the last release of the JavaScript codebase and served as a bridge: it deprecated everything TypeScript 7 would remove. TypeScript 7.0 followed on July 8, 2026.

How Much Faster TypeScript 7 Is

Full builds of open source projects, as published with the 7.0 release:

Those runs used the default of 4 type-checking workers. With --checkers 8 on the same machine, the VS Code build took 7.51 s (16.7x) and tldraw 1.06 s (10.6x), at the cost of more memory.

The editor gains as much. The language service now runs as a native language server: in the VS Code codebase, the time from opening the editor to seeing the first error in a file went from about 17.5 seconds to under 1.3 seconds. The speedup matters most for monorepos, CI pipelines and editors on big codebases.

What Stays the Same

• The command and the package. npm install --save-dev typescript and npx tsc. On install, npm picks a prebuilt binary for your platform from optional dependencies such as @typescript/typescript-linux-x64, so there is nothing else to set up.
• The language. The same syntax, the same type system, the same error codes.
• The results. The release notes state that practically any code that compiles cleanly with TypeScript 6.0, with the stableTypeOrdering flag on and without any ignoreDeprecations setting, should compile identically in TypeScript 7.0.

New Defaults

TypeScript 6.0 changed these defaults and TypeScript 7 keeps them. They only matter for options your tsconfig.json does not set:

Removed Options and Syntax

Options deprecated in TypeScript 6 are errors in TypeScript 7:

• target: es5, and downlevelIteration, which only existed for ES5 output.
• moduleResolution: node (also called node10) and classic. Use nodenext or bundler.
• module: amd, umd, system and none.
• baseUrl (write paths relative to the tsconfig file) and outFile (use a bundler).
• esModuleInterop: false, allowSyntheticDefaultImports: false and alwaysStrict: false; all three are always on.

The compiler says exactly what to remove:

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 old syntax forms are errors too: module Foo { } for a namespace (write namespace Foo { }; declare module "foo" for a package is unaffected) and import assertions (assert { type: "json" } becomes with { type: "json" }).

// This does not compile: the module keyword for a namespace is removed.
module Shapes {
    export const sides = 4;
}

console.log(Shapes.sides);

index.ts(2,8): error TS1540: A 'namespace' declaration should not be declared using the 'module' keyword. Please use the 'namespace' keyword instead.

Changing module to namespace on line 2 fixes it, and the program prints 4.

On the command line, tsc file.ts in a folder that has a tsconfig.json now stops with error TS5112 instead of silently ignoring the config. Run tsc alone, or pass --ignoreConfig. In JavaScript files checked with JSDoc, TypeScript 7 reads types more like TypeScript does: @enum is no longer recognized, and a value used as a type needs typeof. The tsconfig page shows the replacement for each removed option.

Tools That Still Need TypeScript 6

TypeScript 7.0 does not ship a stable JavaScript API. require("typescript") returns only version information (version and versionMajorMinor), and the compiler functions that other tools call (createProgram, the language service) are not there; the package's typescript/unstable/* entry points are experimental and not a replacement. The release notes say the team expects TypeScript 7.1 to ship a new, different API. Until then, anything that imports the compiler as a library keeps using TypeScript 6:

• typescript-eslint (type-aware lint rules)
• Language tooling for Vue, Svelte and Astro files, Angular's template type checking, and MDX
• ts-node, which crashes on startup with TypeScript 7 installed

For those, TypeScript ships a compatibility package, @typescript/typescript6, which installs TypeScript 6 with its full API and a tsc6 command. With npm aliases, one project can have both: TypeScript 7 does the builds, and tools that import typescript get version 6.

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

After npm install:

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

If you do not use any of those tools, install plain typescript and skip this.

New Command Line Options

The native compiler parses, checks and emits in parallel. Three new flags control it, and the release notes call --checkers and --builders experimental:

--watch was rewritten as well, on a Go port of the file watcher from the Parcel bundler.

Editor Support

For VS Code, the TypeScript team publishes a dedicated TypeScript 7 extension; once installed it becomes the default, and the command palette's "Disable TypeScript 7 Language Server" switches back to TypeScript 6. The latest Visual Studio enables TypeScript 7 automatically based on the workspace, and other editors (Neovim, Zed, Sublime Text, Emacs) connect to it through the Language Server Protocol. Projects that use Vue, Svelte, Astro or MDX files, or Angular templates, keep TypeScript 6 based editor support until TypeScript 7 exposes an API those tools can use. An Angular project can still run TypeScript 7's tsc for fast whole-project checks.

How to Upgrade to TypeScript 7

1. Upgrade to TypeScript 6 first, if you are on 5.x: npm install --save-dev typescript@6. Fix every deprecation error it reports instead of silencing it with "ignoreDeprecations": "6.0".
2. Turn on "stableTypeOrdering": true under TypeScript 6 and fix anything it changes. This is the configuration the team states compiles identically in 7.
3. Set the options whose defaults changed if you depended on the old values, for example "types": ["node"] and "rootDir": "./src".
4. Install TypeScript 7: npm install --save-dev typescript@latest. Remove stableTypeOrdering afterwards if you like; it is always on in 7.
5. Check your tooling. If you use typescript-eslint, ts-node or a framework with template type checking, set up the TypeScript 6 alias shown above.
6. Confirm the version with npx tsc --version, and make sure CI installs from the updated lockfile.

tsgo and the Preview Builds

Before the release, the native compiler was published as @typescript/native-preview, whose command was tsgo, so it could be tried next to the JavaScript tsc. Articles from 2025 and early 2026 refer to tsgo. With 7.0 that name is gone from everyday use: the native compiler is tsc, and its nightly builds are published as typescript@next (7.1 development versions today).