Upgrading to TypeScript 7.0: a tsconfig checklist for 5.x and 6.0 projects

TypeScript changed more in 2026 than in any year since its launch. TypeScript 6.0, released on 23 March 2026, was the last version built on the original JavaScript code base, and it changed several long-standing compiler defaults. TypeScript 7.0, released on 8 July 2026, is a new compiler written in Go. Microsoft's announcement reports full-build speed-ups of between 8x and 12x on the projects it measured.

For a team still on TypeScript 5.x, that means two sets of changes at once: new defaults and removed options from 6.0, and a new compiler with a temporary gap in tooling support in 7.0. Upgrading without a plan can produce hundreds of new errors, a broken lint step, or a build that silently emits files to a different folder.

This guide gives a step-by-step checklist for front-end and full-stack JavaScript projects, based on the official TypeScript 6.0 and 7.0 announcements. It explains what each change means, which tsconfig.json lines to add before upgrading, and how to keep ESLint and framework tooling working during the transition.

The timeline in brief

The recommended path is to move to 6.0 first, fix everything it reports, and only then switch the compiler to 7.0. The 6.0 release exists largely to make that second step uneventful.

Step 1: pin the defaults that changed in 6.0

TypeScript 6.0 changed defaults that many projects relied on without writing them down. The 7.0 announcement confirms that 7.0 keeps these new defaults. The safest first move, while still on 5.x, is to make your current behaviour explicit in tsconfig.json.

The announcement notes that the old behaviour of automatically including every @types package could slow builds by 20 to 50 percent, which is why types now defaults to an empty list. A typical browser app configuration that is explicit about all of this looks like:

{
  "compilerOptions": {
    "strict": true,
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "lib": ["es2022", "dom"],
    "types": ["vite/client"],
    "rootDir": "./src",
    "noEmit": true,
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["src"]
}

Adjust target and lib to your real browser support; the values here are examples. If you are not ready for strict mode, set "strict": false explicitly for now and turn on its individual checks later, one at a time. In 6.0 the dom library also includes what used to be dom.iterable and dom.asynciterable, so you can remove those entries.

Step 2: remove options that are deprecated in 6.0 and gone in 7.0

These settings produce deprecation errors in 6.0 and are not supported at all in 7.0:

• "target": "es5" and downlevelIteration. The lowest target is now ES2015. If you still need ES5 output for very old browsers, let your bundler or a separate transpiler handle it.
• "moduleResolution": "node" (also called node10) and classic. Use bundler for apps built with Vite, webpack or similar, and nodenext for code that runs directly in Node.js.
• "module": "amd", "umd", "system" or "none". Removed; use a bundler if you need those formats.
• baseUrl. Remove it and write full relative prefixes in paths, as in the example above ("./src/*" rather than "src/*").
• outFile. Removed; concatenate with a bundler.
• esModuleInterop: false and allowSyntheticDefaultImports: false. These can no longer be turned off; safer interop is always on. Delete the lines.
• alwaysStrict: false. Deprecated; strict mode parsing is assumed.

Two syntax changes may also appear in your source files:

// Before: legacy namespace keyword, now an error
module Analytics {
  export const version = 1;
}

// After
namespace Analytics {
  export const version = 1;
}

// Before: import assertions, deprecated
import config from './config.json' assert { type: 'json' };

// After: import attributes
import config from './config.json' with { type: 'json' };

Fix these in 6.0 rather than postponing them: on 7.0 the options are simply gone, so there is no setting that keeps them working.

Step 3: upgrade to 6.0 and fix the new errors

Install TypeScript 6 and run a type check across the whole project:

npm install -D typescript@6
npx tsc --noEmit

Work through the errors in this order, because each group tends to hide the next:

1. Configuration errors (removed or deprecated options).
2. Missing globals caused by types: []: add the packages you actually use, such as "types": ["vitest/globals"] or "types": ["node"] in the config that covers build scripts.
3. Module resolution errors after switching to bundler or nodenext.
4. Strict mode errors, usually the largest group. Fix them by folder, and consider committing per folder to keep reviews small.

TypeScript 6.0 also adds a --stableTypeOrdering flag that makes its internal type ordering match 7.0. Running with it on helps you spot the small number of cases where error messages or declaration output would differ after the switch.

Step 4: switch the compiler to 7.0

TypeScript 7.0 is published under the same npm package name and still provides a tsc command:

npm install -D typescript@7
npx tsc --noEmit

If 6.0 compiled cleanly, 7.0 should too. Time the type check before and after; the announcement cites the VS Code code base going from 125.7 seconds to 10.6 seconds and Slack cutting CI type-checking time from about 7.5 minutes to 1.25 minutes. Your results depend on project size and hardware, so measure rather than assume.

Two experimental flags control parallelism: --checkers for type-checking and --builders for building project references. Leave them at their defaults unless you have measured a reason to change them, for example on CI machines with limited memory.

For editors, the TypeScript team publishes a dedicated VS Code extension for TypeScript 7, Visual Studio enables it automatically, and other editors can use it through the Language Server Protocol.

Step 5: keep typescript-eslint and framework tools on 6.0

This is the step most likely to catch teams out. TypeScript 7.0 does not ship a programmatic API. Tools that load the compiler as a library, including typescript-eslint, cannot use 7.0 yet. The announcement also says that Vue, MDX, Astro, Svelte and Angular template type-checking still require 6.0 for now.

The TypeScript team provides a compatibility package, @typescript/typescript6, which installs a tsc6 command and can stand in for the typescript package name. The announcement shows this package.json arrangement to have both:

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

With this setup, tools that import 'typescript' (such as typescript-eslint) receive 6.0, while the tsc command comes from 7.0 for fast type checks and builds. Document the arrangement in your README, because it is easy for a later dependency update to undo it. Revisit it when TypeScript 7.1 and updated versions of your tools are released.

The complete checklist

• Record current type-check time and error count on 5.x.
• Make strict, module, target, types and rootDir explicit in every tsconfig file, including those for tests and scripts.
• Replace moduleResolution: node with bundler or nodenext; remove baseUrl and rewrite paths.
• Remove es5 targets, downlevelIteration, outFile, AMD/UMD/SystemJS modules and false values for interop flags.
• Replace module namespaces with namespace and assert with with.
• Upgrade to 6.0, fix all errors, and try --stableTypeOrdering.
• Check emitted output paths if you build with tsc.
• Upgrade the compiler to 7.0; keep typescript-eslint and framework checkers on @typescript/typescript6.
• Install the TypeScript 7 editor extension for the team.
• Measure the new type-check time and update CI timeouts and caches.

Summary

Treat the move from TypeScript 5.x to 7.0 as two upgrades. TypeScript 6.0 is where the real migration work happens: new defaults such as strict: true and types: [], and the removal of legacy module and target options. TypeScript 7.0 then brings the native compiler and large speed improvements, with one temporary gap: no programmatic API until 7.1, so linting and some framework tooling stay on 6.0 through the official compatibility package. Plan both steps, measure before and after, and keep your configuration explicit so the next default change does not surprise you.