TypeScript 7: What the Native Compiler Changes for You

TypeScript 7.0, released in July 2026, is the version where the compiler itself was rewritten in Go. The language did not change; the type checker’s behaviour did not change; what changed is that tsc and the editor language service run natively rather than as JavaScript, and the project reports full builds roughly eight to twelve times faster and editor responsiveness in large projects improved by a similar factor. For most teams the migration is updating a version number. Here is what to expect.

What happened#

The TypeScript compiler had always been written in TypeScript and run on Node. That was elegant and slow: single-threaded JavaScript, with the overhead of the JIT and garbage collector, checking projects that had grown to hundreds of thousands of lines. In March 2025 the team announced a port to Go, chosen because its structure could mirror the existing compiler closely and because it offers native code, shared-memory parallelism and a fast start. It shipped as a preview package, then as TypeScript 7.0.

The speed comes from three places: native execution instead of interpreted JavaScript, parallel parsing and checking across cores, and lower memory use that keeps large projects from thrashing.

What did not change#

• The language. No new syntax, no removed syntax. Code that type-checks on 6 type-checks on 7, with the same errors.
• The type system. The port is deliberately faithful; the goal was identical behaviour, verified against the existing test suite.
• tsconfig.json. The same options, with a small number of long-deprecated ones removed — the ones already warning under 5.x and 6.
• Emit. Generated JavaScript and declaration files are the same.

TypeScript 6.0, the release before, was the transition point: it turned the old deprecations into errors and adjusted some defaults, so that 7 could drop them. If you are on 5.x, go through 6 first and fix what it flags.

What you might actually hit#

• Removed options. Settings deprecated for years — older module resolution modes, some target-era flags — are gone. The error names them; delete or replace.
• The compiler API. Tools that called into the TypeScript compiler as a library (custom transformers, some linters, code generators) had a JavaScript API. Native TypeScript exposes its services differently, over a language-server-style protocol, and the ecosystem has been updating. Check any build plugin that imports typescript directly.
• Diagnostics ordering and wording. Identical errors, occasionally in a different order or with slightly different phrasing. Snapshot tests of compiler output may need refreshing.
• Memory and CPU profile. Faster, but different: it uses more cores. On a constrained CI runner, set parallelism explicitly if it competes with other jobs.

Editors and build tools#

VS Code uses the native language service with TypeScript 7 selected; the editor’s TypeScript: Select TypeScript Version command shows which is active. The improvement is most visible in large projects: go-to-definition, hover and error updates that used to lag now feel immediate.

Bundlers that transpile TypeScript themselves — esbuild, Vite, swc-based tools — were never using tsc for emit and are unaffected; they benefit when you run type checking alongside, which is the part that got faster. Tools that wrapped tsc directly need versions that know the new binary.

Upgrading#

npm install --save-dev typescript@7
npx tsc --version
npx tsc --noEmit          # a full check, timed against your previous build

Steps, in order:

1. Be on TypeScript 6 with no deprecation warnings. If not, do that first.
2. Install 7 and run a full check. Fix any removed-option errors in tsconfig.
3. Update build plugins and linters that depend on the compiler API to versions that support 7.
4. Run the test suite and any snapshot tests of type errors.
5. Measure the build. Then enjoy it.

Staying on 6#

TypeScript 6 remains available and receives fixes for a period, so a project blocked by a plugin that has not caught up can wait. Pin typescript@6 and revisit when the dependency updates. There is no pressure to move on day one; the benefit is speed, not correctness.

Where to go next#

• TypeScript vs JavaScript — if you are not using TypeScript yet.
• What’s new in JavaScript in 2026 — the language underneath.
• “error is of type unknown” — the most-searched TypeScript error.